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 10#include"cache.h" 11#include"blob.h" 12#include"delta.h" 13#include"diff.h" 14#include"dir.h" 15#include"xdiff-interface.h" 16#include"ll-merge.h" 17#include"lockfile.h" 18#include"parse-options.h" 19#include"quote.h" 20#include"rerere.h" 21#include"apply.h" 22 23static voidgit_apply_config(void) 24{ 25git_config_get_string_const("apply.whitespace", &apply_default_whitespace); 26git_config_get_string_const("apply.ignorewhitespace", &apply_default_ignorewhitespace); 27git_config(git_default_config, NULL); 28} 29 30static intparse_whitespace_option(struct apply_state *state,const char*option) 31{ 32if(!option) { 33 state->ws_error_action = warn_on_ws_error; 34return0; 35} 36if(!strcmp(option,"warn")) { 37 state->ws_error_action = warn_on_ws_error; 38return0; 39} 40if(!strcmp(option,"nowarn")) { 41 state->ws_error_action = nowarn_ws_error; 42return0; 43} 44if(!strcmp(option,"error")) { 45 state->ws_error_action = die_on_ws_error; 46return0; 47} 48if(!strcmp(option,"error-all")) { 49 state->ws_error_action = die_on_ws_error; 50 state->squelch_whitespace_errors =0; 51return0; 52} 53if(!strcmp(option,"strip") || !strcmp(option,"fix")) { 54 state->ws_error_action = correct_ws_error; 55return0; 56} 57returnerror(_("unrecognized whitespace option '%s'"), option); 58} 59 60static intparse_ignorewhitespace_option(struct apply_state *state, 61const char*option) 62{ 63if(!option || !strcmp(option,"no") || 64!strcmp(option,"false") || !strcmp(option,"never") || 65!strcmp(option,"none")) { 66 state->ws_ignore_action = ignore_ws_none; 67return0; 68} 69if(!strcmp(option,"change")) { 70 state->ws_ignore_action = ignore_ws_change; 71return0; 72} 73returnerror(_("unrecognized whitespace ignore option '%s'"), option); 74} 75 76intinit_apply_state(struct apply_state *state, 77const char*prefix, 78struct lock_file *lock_file) 79{ 80memset(state,0,sizeof(*state)); 81 state->prefix = prefix; 82 state->prefix_length = state->prefix ?strlen(state->prefix) :0; 83 state->lock_file = lock_file; 84 state->newfd = -1; 85 state->apply =1; 86 state->line_termination ='\n'; 87 state->p_value =1; 88 state->p_context = UINT_MAX; 89 state->squelch_whitespace_errors =5; 90 state->ws_error_action = warn_on_ws_error; 91 state->ws_ignore_action = ignore_ws_none; 92 state->linenr =1; 93string_list_init(&state->fn_table,0); 94string_list_init(&state->limit_by_name,0); 95string_list_init(&state->symlink_changes,0); 96strbuf_init(&state->root,0); 97 98git_apply_config(); 99if(apply_default_whitespace &&parse_whitespace_option(state, apply_default_whitespace)) 100return-1; 101if(apply_default_ignorewhitespace &&parse_ignorewhitespace_option(state, apply_default_ignorewhitespace)) 102return-1; 103return0; 104} 105 106voidclear_apply_state(struct apply_state *state) 107{ 108string_list_clear(&state->limit_by_name,0); 109string_list_clear(&state->symlink_changes,0); 110strbuf_release(&state->root); 111 112/* &state->fn_table is cleared at the end of apply_patch() */ 113} 114 115static voidmute_routine(const char*msg,va_list params) 116{ 117/* do nothing */ 118} 119 120intcheck_apply_state(struct apply_state *state,int force_apply) 121{ 122int is_not_gitdir = !startup_info->have_repository; 123 124if(state->apply_with_reject && state->threeway) 125returnerror(_("--reject and --3way cannot be used together.")); 126if(state->cached && state->threeway) 127returnerror(_("--cached and --3way cannot be used together.")); 128if(state->threeway) { 129if(is_not_gitdir) 130returnerror(_("--3way outside a repository")); 131 state->check_index =1; 132} 133if(state->apply_with_reject) { 134 state->apply =1; 135if(state->apply_verbosity == verbosity_normal) 136 state->apply_verbosity = verbosity_verbose; 137} 138if(!force_apply && (state->diffstat || state->numstat || state->summary || state->check || state->fake_ancestor)) 139 state->apply =0; 140if(state->check_index && is_not_gitdir) 141returnerror(_("--index outside a repository")); 142if(state->cached) { 143if(is_not_gitdir) 144returnerror(_("--cached outside a repository")); 145 state->check_index =1; 146} 147if(state->check_index) 148 state->unsafe_paths =0; 149if(!state->lock_file) 150returnerror("BUG: state->lock_file should not be NULL"); 151 152if(state->apply_verbosity <= verbosity_silent) { 153 state->saved_error_routine =get_error_routine(); 154 state->saved_warn_routine =get_warn_routine(); 155set_error_routine(mute_routine); 156set_warn_routine(mute_routine); 157} 158 159return0; 160} 161 162static voidset_default_whitespace_mode(struct apply_state *state) 163{ 164if(!state->whitespace_option && !apply_default_whitespace) 165 state->ws_error_action = (state->apply ? warn_on_ws_error : nowarn_ws_error); 166} 167 168/* 169 * This represents one "hunk" from a patch, starting with 170 * "@@ -oldpos,oldlines +newpos,newlines @@" marker. The 171 * patch text is pointed at by patch, and its byte length 172 * is stored in size. leading and trailing are the number 173 * of context lines. 174 */ 175struct fragment { 176unsigned long leading, trailing; 177unsigned long oldpos, oldlines; 178unsigned long newpos, newlines; 179/* 180 * 'patch' is usually borrowed from buf in apply_patch(), 181 * but some codepaths store an allocated buffer. 182 */ 183const char*patch; 184unsigned free_patch:1, 185 rejected:1; 186int size; 187int linenr; 188struct fragment *next; 189}; 190 191/* 192 * When dealing with a binary patch, we reuse "leading" field 193 * to store the type of the binary hunk, either deflated "delta" 194 * or deflated "literal". 195 */ 196#define binary_patch_method leading 197#define BINARY_DELTA_DEFLATED 1 198#define BINARY_LITERAL_DEFLATED 2 199 200/* 201 * This represents a "patch" to a file, both metainfo changes 202 * such as creation/deletion, filemode and content changes represented 203 * as a series of fragments. 204 */ 205struct patch { 206char*new_name, *old_name, *def_name; 207unsigned int old_mode, new_mode; 208int is_new, is_delete;/* -1 = unknown, 0 = false, 1 = true */ 209int rejected; 210unsigned ws_rule; 211int lines_added, lines_deleted; 212int score; 213int extension_linenr;/* first line specifying delete/new/rename/copy */ 214unsigned int is_toplevel_relative:1; 215unsigned int inaccurate_eof:1; 216unsigned int is_binary:1; 217unsigned int is_copy:1; 218unsigned int is_rename:1; 219unsigned int recount:1; 220unsigned int conflicted_threeway:1; 221unsigned int direct_to_threeway:1; 222struct fragment *fragments; 223char*result; 224size_t resultsize; 225char old_sha1_prefix[41]; 226char new_sha1_prefix[41]; 227struct patch *next; 228 229/* three-way fallback result */ 230struct object_id threeway_stage[3]; 231}; 232 233static voidfree_fragment_list(struct fragment *list) 234{ 235while(list) { 236struct fragment *next = list->next; 237if(list->free_patch) 238free((char*)list->patch); 239free(list); 240 list = next; 241} 242} 243 244static voidfree_patch(struct patch *patch) 245{ 246free_fragment_list(patch->fragments); 247free(patch->def_name); 248free(patch->old_name); 249free(patch->new_name); 250free(patch->result); 251free(patch); 252} 253 254static voidfree_patch_list(struct patch *list) 255{ 256while(list) { 257struct patch *next = list->next; 258free_patch(list); 259 list = next; 260} 261} 262 263/* 264 * A line in a file, len-bytes long (includes the terminating LF, 265 * except for an incomplete line at the end if the file ends with 266 * one), and its contents hashes to 'hash'. 267 */ 268struct line { 269size_t len; 270unsigned hash :24; 271unsigned flag :8; 272#define LINE_COMMON 1 273#define LINE_PATCHED 2 274}; 275 276/* 277 * This represents a "file", which is an array of "lines". 278 */ 279struct image { 280char*buf; 281size_t len; 282size_t nr; 283size_t alloc; 284struct line *line_allocated; 285struct line *line; 286}; 287 288static uint32_thash_line(const char*cp,size_t len) 289{ 290size_t i; 291uint32_t h; 292for(i =0, h =0; i < len; i++) { 293if(!isspace(cp[i])) { 294 h = h *3+ (cp[i] &0xff); 295} 296} 297return h; 298} 299 300/* 301 * Compare lines s1 of length n1 and s2 of length n2, ignoring 302 * whitespace difference. Returns 1 if they match, 0 otherwise 303 */ 304static intfuzzy_matchlines(const char*s1,size_t n1, 305const char*s2,size_t n2) 306{ 307const char*last1 = s1 + n1 -1; 308const char*last2 = s2 + n2 -1; 309int result =0; 310 311/* ignore line endings */ 312while((*last1 =='\r') || (*last1 =='\n')) 313 last1--; 314while((*last2 =='\r') || (*last2 =='\n')) 315 last2--; 316 317/* skip leading whitespaces, if both begin with whitespace */ 318if(s1 <= last1 && s2 <= last2 &&isspace(*s1) &&isspace(*s2)) { 319while(isspace(*s1) && (s1 <= last1)) 320 s1++; 321while(isspace(*s2) && (s2 <= last2)) 322 s2++; 323} 324/* early return if both lines are empty */ 325if((s1 > last1) && (s2 > last2)) 326return1; 327while(!result) { 328 result = *s1++ - *s2++; 329/* 330 * Skip whitespace inside. We check for whitespace on 331 * both buffers because we don't want "a b" to match 332 * "ab" 333 */ 334if(isspace(*s1) &&isspace(*s2)) { 335while(isspace(*s1) && s1 <= last1) 336 s1++; 337while(isspace(*s2) && s2 <= last2) 338 s2++; 339} 340/* 341 * If we reached the end on one side only, 342 * lines don't match 343 */ 344if( 345((s2 > last2) && (s1 <= last1)) || 346((s1 > last1) && (s2 <= last2))) 347return0; 348if((s1 > last1) && (s2 > last2)) 349break; 350} 351 352return!result; 353} 354 355static voidadd_line_info(struct image *img,const char*bol,size_t len,unsigned flag) 356{ 357ALLOC_GROW(img->line_allocated, img->nr +1, img->alloc); 358 img->line_allocated[img->nr].len = len; 359 img->line_allocated[img->nr].hash =hash_line(bol, len); 360 img->line_allocated[img->nr].flag = flag; 361 img->nr++; 362} 363 364/* 365 * "buf" has the file contents to be patched (read from various sources). 366 * attach it to "image" and add line-based index to it. 367 * "image" now owns the "buf". 368 */ 369static voidprepare_image(struct image *image,char*buf,size_t len, 370int prepare_linetable) 371{ 372const char*cp, *ep; 373 374memset(image,0,sizeof(*image)); 375 image->buf = buf; 376 image->len = len; 377 378if(!prepare_linetable) 379return; 380 381 ep = image->buf + image->len; 382 cp = image->buf; 383while(cp < ep) { 384const char*next; 385for(next = cp; next < ep && *next !='\n'; next++) 386; 387if(next < ep) 388 next++; 389add_line_info(image, cp, next - cp,0); 390 cp = next; 391} 392 image->line = image->line_allocated; 393} 394 395static voidclear_image(struct image *image) 396{ 397free(image->buf); 398free(image->line_allocated); 399memset(image,0,sizeof(*image)); 400} 401 402/* fmt must contain _one_ %s and no other substitution */ 403static voidsay_patch_name(FILE*output,const char*fmt,struct patch *patch) 404{ 405struct strbuf sb = STRBUF_INIT; 406 407if(patch->old_name && patch->new_name && 408strcmp(patch->old_name, patch->new_name)) { 409quote_c_style(patch->old_name, &sb, NULL,0); 410strbuf_addstr(&sb," => "); 411quote_c_style(patch->new_name, &sb, NULL,0); 412}else{ 413const char*n = patch->new_name; 414if(!n) 415 n = patch->old_name; 416quote_c_style(n, &sb, NULL,0); 417} 418fprintf(output, fmt, sb.buf); 419fputc('\n', output); 420strbuf_release(&sb); 421} 422 423#define SLOP (16) 424 425static intread_patch_file(struct strbuf *sb,int fd) 426{ 427if(strbuf_read(sb, fd,0) <0) 428returnerror_errno("git apply: failed to read"); 429 430/* 431 * Make sure that we have some slop in the buffer 432 * so that we can do speculative "memcmp" etc, and 433 * see to it that it is NUL-filled. 434 */ 435strbuf_grow(sb, SLOP); 436memset(sb->buf + sb->len,0, SLOP); 437return0; 438} 439 440static unsigned longlinelen(const char*buffer,unsigned long size) 441{ 442unsigned long len =0; 443while(size--) { 444 len++; 445if(*buffer++ =='\n') 446break; 447} 448return len; 449} 450 451static intis_dev_null(const char*str) 452{ 453returnskip_prefix(str,"/dev/null", &str) &&isspace(*str); 454} 455 456#define TERM_SPACE 1 457#define TERM_TAB 2 458 459static intname_terminate(int c,int terminate) 460{ 461if(c ==' '&& !(terminate & TERM_SPACE)) 462return0; 463if(c =='\t'&& !(terminate & TERM_TAB)) 464return0; 465 466return1; 467} 468 469/* remove double slashes to make --index work with such filenames */ 470static char*squash_slash(char*name) 471{ 472int i =0, j =0; 473 474if(!name) 475return NULL; 476 477while(name[i]) { 478if((name[j++] = name[i++]) =='/') 479while(name[i] =='/') 480 i++; 481} 482 name[j] ='\0'; 483return name; 484} 485 486static char*find_name_gnu(struct apply_state *state, 487const char*line, 488const char*def, 489int p_value) 490{ 491struct strbuf name = STRBUF_INIT; 492char*cp; 493 494/* 495 * Proposed "new-style" GNU patch/diff format; see 496 * http://marc.info/?l=git&m=112927316408690&w=2 497 */ 498if(unquote_c_style(&name, line, NULL)) { 499strbuf_release(&name); 500return NULL; 501} 502 503for(cp = name.buf; p_value; p_value--) { 504 cp =strchr(cp,'/'); 505if(!cp) { 506strbuf_release(&name); 507return NULL; 508} 509 cp++; 510} 511 512strbuf_remove(&name,0, cp - name.buf); 513if(state->root.len) 514strbuf_insert(&name,0, state->root.buf, state->root.len); 515returnsquash_slash(strbuf_detach(&name, NULL)); 516} 517 518static size_tsane_tz_len(const char*line,size_t len) 519{ 520const char*tz, *p; 521 522if(len <strlen(" +0500") || line[len-strlen(" +0500")] !=' ') 523return0; 524 tz = line + len -strlen(" +0500"); 525 526if(tz[1] !='+'&& tz[1] !='-') 527return0; 528 529for(p = tz +2; p != line + len; p++) 530if(!isdigit(*p)) 531return0; 532 533return line + len - tz; 534} 535 536static size_ttz_with_colon_len(const char*line,size_t len) 537{ 538const char*tz, *p; 539 540if(len <strlen(" +08:00") || line[len -strlen(":00")] !=':') 541return0; 542 tz = line + len -strlen(" +08:00"); 543 544if(tz[0] !=' '|| (tz[1] !='+'&& tz[1] !='-')) 545return0; 546 p = tz +2; 547if(!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 548!isdigit(*p++) || !isdigit(*p++)) 549return0; 550 551return line + len - tz; 552} 553 554static size_tdate_len(const char*line,size_t len) 555{ 556const char*date, *p; 557 558if(len <strlen("72-02-05") || line[len-strlen("-05")] !='-') 559return0; 560 p = date = line + len -strlen("72-02-05"); 561 562if(!isdigit(*p++) || !isdigit(*p++) || *p++ !='-'|| 563!isdigit(*p++) || !isdigit(*p++) || *p++ !='-'|| 564!isdigit(*p++) || !isdigit(*p++))/* Not a date. */ 565return0; 566 567if(date - line >=strlen("19") && 568isdigit(date[-1]) &&isdigit(date[-2]))/* 4-digit year */ 569 date -=strlen("19"); 570 571return line + len - date; 572} 573 574static size_tshort_time_len(const char*line,size_t len) 575{ 576const char*time, *p; 577 578if(len <strlen(" 07:01:32") || line[len-strlen(":32")] !=':') 579return0; 580 p = time = line + len -strlen(" 07:01:32"); 581 582/* Permit 1-digit hours? */ 583if(*p++ !=' '|| 584!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 585!isdigit(*p++) || !isdigit(*p++) || *p++ !=':'|| 586!isdigit(*p++) || !isdigit(*p++))/* Not a time. */ 587return0; 588 589return line + len - time; 590} 591 592static size_tfractional_time_len(const char*line,size_t len) 593{ 594const char*p; 595size_t n; 596 597/* Expected format: 19:41:17.620000023 */ 598if(!len || !isdigit(line[len -1])) 599return0; 600 p = line + len -1; 601 602/* Fractional seconds. */ 603while(p > line &&isdigit(*p)) 604 p--; 605if(*p !='.') 606return0; 607 608/* Hours, minutes, and whole seconds. */ 609 n =short_time_len(line, p - line); 610if(!n) 611return0; 612 613return line + len - p + n; 614} 615 616static size_ttrailing_spaces_len(const char*line,size_t len) 617{ 618const char*p; 619 620/* Expected format: ' ' x (1 or more) */ 621if(!len || line[len -1] !=' ') 622return0; 623 624 p = line + len; 625while(p != line) { 626 p--; 627if(*p !=' ') 628return line + len - (p +1); 629} 630 631/* All spaces! */ 632return len; 633} 634 635static size_tdiff_timestamp_len(const char*line,size_t len) 636{ 637const char*end = line + len; 638size_t n; 639 640/* 641 * Posix: 2010-07-05 19:41:17 642 * GNU: 2010-07-05 19:41:17.620000023 -0500 643 */ 644 645if(!isdigit(end[-1])) 646return0; 647 648 n =sane_tz_len(line, end - line); 649if(!n) 650 n =tz_with_colon_len(line, end - line); 651 end -= n; 652 653 n =short_time_len(line, end - line); 654if(!n) 655 n =fractional_time_len(line, end - line); 656 end -= n; 657 658 n =date_len(line, end - line); 659if(!n)/* No date. Too bad. */ 660return0; 661 end -= n; 662 663if(end == line)/* No space before date. */ 664return0; 665if(end[-1] =='\t') {/* Success! */ 666 end--; 667return line + len - end; 668} 669if(end[-1] !=' ')/* No space before date. */ 670return0; 671 672/* Whitespace damage. */ 673 end -=trailing_spaces_len(line, end - line); 674return line + len - end; 675} 676 677static char*find_name_common(struct apply_state *state, 678const char*line, 679const char*def, 680int p_value, 681const char*end, 682int terminate) 683{ 684int len; 685const char*start = NULL; 686 687if(p_value ==0) 688 start = line; 689while(line != end) { 690char c = *line; 691 692if(!end &&isspace(c)) { 693if(c =='\n') 694break; 695if(name_terminate(c, terminate)) 696break; 697} 698 line++; 699if(c =='/'&& !--p_value) 700 start = line; 701} 702if(!start) 703returnsquash_slash(xstrdup_or_null(def)); 704 len = line - start; 705if(!len) 706returnsquash_slash(xstrdup_or_null(def)); 707 708/* 709 * Generally we prefer the shorter name, especially 710 * if the other one is just a variation of that with 711 * something else tacked on to the end (ie "file.orig" 712 * or "file~"). 713 */ 714if(def) { 715int deflen =strlen(def); 716if(deflen < len && !strncmp(start, def, deflen)) 717returnsquash_slash(xstrdup(def)); 718} 719 720if(state->root.len) { 721char*ret =xstrfmt("%s%.*s", state->root.buf, len, start); 722returnsquash_slash(ret); 723} 724 725returnsquash_slash(xmemdupz(start, len)); 726} 727 728static char*find_name(struct apply_state *state, 729const char*line, 730char*def, 731int p_value, 732int terminate) 733{ 734if(*line =='"') { 735char*name =find_name_gnu(state, line, def, p_value); 736if(name) 737return name; 738} 739 740returnfind_name_common(state, line, def, p_value, NULL, terminate); 741} 742 743static char*find_name_traditional(struct apply_state *state, 744const char*line, 745char*def, 746int p_value) 747{ 748size_t len; 749size_t date_len; 750 751if(*line =='"') { 752char*name =find_name_gnu(state, line, def, p_value); 753if(name) 754return name; 755} 756 757 len =strchrnul(line,'\n') - line; 758 date_len =diff_timestamp_len(line, len); 759if(!date_len) 760returnfind_name_common(state, line, def, p_value, NULL, TERM_TAB); 761 len -= date_len; 762 763returnfind_name_common(state, line, def, p_value, line + len,0); 764} 765 766static intcount_slashes(const char*cp) 767{ 768int cnt =0; 769char ch; 770 771while((ch = *cp++)) 772if(ch =='/') 773 cnt++; 774return cnt; 775} 776 777/* 778 * Given the string after "--- " or "+++ ", guess the appropriate 779 * p_value for the given patch. 780 */ 781static intguess_p_value(struct apply_state *state,const char*nameline) 782{ 783char*name, *cp; 784int val = -1; 785 786if(is_dev_null(nameline)) 787return-1; 788 name =find_name_traditional(state, nameline, NULL,0); 789if(!name) 790return-1; 791 cp =strchr(name,'/'); 792if(!cp) 793 val =0; 794else if(state->prefix) { 795/* 796 * Does it begin with "a/$our-prefix" and such? Then this is 797 * very likely to apply to our directory. 798 */ 799if(!strncmp(name, state->prefix, state->prefix_length)) 800 val =count_slashes(state->prefix); 801else{ 802 cp++; 803if(!strncmp(cp, state->prefix, state->prefix_length)) 804 val =count_slashes(state->prefix) +1; 805} 806} 807free(name); 808return val; 809} 810 811/* 812 * Does the ---/+++ line have the POSIX timestamp after the last HT? 813 * GNU diff puts epoch there to signal a creation/deletion event. Is 814 * this such a timestamp? 815 */ 816static inthas_epoch_timestamp(const char*nameline) 817{ 818/* 819 * We are only interested in epoch timestamp; any non-zero 820 * fraction cannot be one, hence "(\.0+)?" in the regexp below. 821 * For the same reason, the date must be either 1969-12-31 or 822 * 1970-01-01, and the seconds part must be "00". 823 */ 824const char stamp_regexp[] = 825"^(1969-12-31|1970-01-01)" 826" " 827"[0-2][0-9]:[0-5][0-9]:00(\\.0+)?" 828" " 829"([-+][0-2][0-9]:?[0-5][0-9])\n"; 830const char*timestamp = NULL, *cp, *colon; 831static regex_t *stamp; 832 regmatch_t m[10]; 833int zoneoffset; 834int hourminute; 835int status; 836 837for(cp = nameline; *cp !='\n'; cp++) { 838if(*cp =='\t') 839 timestamp = cp +1; 840} 841if(!timestamp) 842return0; 843if(!stamp) { 844 stamp =xmalloc(sizeof(*stamp)); 845if(regcomp(stamp, stamp_regexp, REG_EXTENDED)) { 846warning(_("Cannot prepare timestamp regexp%s"), 847 stamp_regexp); 848return0; 849} 850} 851 852 status =regexec(stamp, timestamp,ARRAY_SIZE(m), m,0); 853if(status) { 854if(status != REG_NOMATCH) 855warning(_("regexec returned%dfor input:%s"), 856 status, timestamp); 857return0; 858} 859 860 zoneoffset =strtol(timestamp + m[3].rm_so +1, (char**) &colon,10); 861if(*colon ==':') 862 zoneoffset = zoneoffset *60+strtol(colon +1, NULL,10); 863else 864 zoneoffset = (zoneoffset /100) *60+ (zoneoffset %100); 865if(timestamp[m[3].rm_so] =='-') 866 zoneoffset = -zoneoffset; 867 868/* 869 * YYYY-MM-DD hh:mm:ss must be from either 1969-12-31 870 * (west of GMT) or 1970-01-01 (east of GMT) 871 */ 872if((zoneoffset <0&&memcmp(timestamp,"1969-12-31",10)) || 873(0<= zoneoffset &&memcmp(timestamp,"1970-01-01",10))) 874return0; 875 876 hourminute = (strtol(timestamp +11, NULL,10) *60+ 877strtol(timestamp +14, NULL,10) - 878 zoneoffset); 879 880return((zoneoffset <0&& hourminute ==1440) || 881(0<= zoneoffset && !hourminute)); 882} 883 884/* 885 * Get the name etc info from the ---/+++ lines of a traditional patch header 886 * 887 * FIXME! The end-of-filename heuristics are kind of screwy. For existing 888 * files, we can happily check the index for a match, but for creating a 889 * new file we should try to match whatever "patch" does. I have no idea. 890 */ 891static intparse_traditional_patch(struct apply_state *state, 892const char*first, 893const char*second, 894struct patch *patch) 895{ 896char*name; 897 898 first +=4;/* skip "--- " */ 899 second +=4;/* skip "+++ " */ 900if(!state->p_value_known) { 901int p, q; 902 p =guess_p_value(state, first); 903 q =guess_p_value(state, second); 904if(p <0) p = q; 905if(0<= p && p == q) { 906 state->p_value = p; 907 state->p_value_known =1; 908} 909} 910if(is_dev_null(first)) { 911 patch->is_new =1; 912 patch->is_delete =0; 913 name =find_name_traditional(state, second, NULL, state->p_value); 914 patch->new_name = name; 915}else if(is_dev_null(second)) { 916 patch->is_new =0; 917 patch->is_delete =1; 918 name =find_name_traditional(state, first, NULL, state->p_value); 919 patch->old_name = name; 920}else{ 921char*first_name; 922 first_name =find_name_traditional(state, first, NULL, state->p_value); 923 name =find_name_traditional(state, second, first_name, state->p_value); 924free(first_name); 925if(has_epoch_timestamp(first)) { 926 patch->is_new =1; 927 patch->is_delete =0; 928 patch->new_name = name; 929}else if(has_epoch_timestamp(second)) { 930 patch->is_new =0; 931 patch->is_delete =1; 932 patch->old_name = name; 933}else{ 934 patch->old_name = name; 935 patch->new_name =xstrdup_or_null(name); 936} 937} 938if(!name) 939returnerror(_("unable to find filename in patch at line%d"), state->linenr); 940 941return0; 942} 943 944static intgitdiff_hdrend(struct apply_state *state, 945const char*line, 946struct patch *patch) 947{ 948return1; 949} 950 951/* 952 * We're anal about diff header consistency, to make 953 * sure that we don't end up having strange ambiguous 954 * patches floating around. 955 * 956 * As a result, gitdiff_{old|new}name() will check 957 * their names against any previous information, just 958 * to make sure.. 959 */ 960#define DIFF_OLD_NAME 0 961#define DIFF_NEW_NAME 1 962 963static intgitdiff_verify_name(struct apply_state *state, 964const char*line, 965int isnull, 966char**name, 967int side) 968{ 969if(!*name && !isnull) { 970*name =find_name(state, line, NULL, state->p_value, TERM_TAB); 971return0; 972} 973 974if(*name) { 975int len =strlen(*name); 976char*another; 977if(isnull) 978returnerror(_("git apply: bad git-diff - expected /dev/null, got%son line%d"), 979*name, state->linenr); 980 another =find_name(state, line, NULL, state->p_value, TERM_TAB); 981if(!another ||memcmp(another, *name, len +1)) { 982free(another); 983returnerror((side == DIFF_NEW_NAME) ? 984_("git apply: bad git-diff - inconsistent new filename on line%d") : 985_("git apply: bad git-diff - inconsistent old filename on line%d"), state->linenr); 986} 987free(another); 988}else{ 989/* expect "/dev/null" */ 990if(memcmp("/dev/null", line,9) || line[9] !='\n') 991returnerror(_("git apply: bad git-diff - expected /dev/null on line%d"), state->linenr); 992} 993 994return0; 995} 996 997static intgitdiff_oldname(struct apply_state *state, 998const char*line, 999struct patch *patch)1000{1001returngitdiff_verify_name(state, line,1002 patch->is_new, &patch->old_name,1003 DIFF_OLD_NAME);1004}10051006static intgitdiff_newname(struct apply_state *state,1007const char*line,1008struct patch *patch)1009{1010returngitdiff_verify_name(state, line,1011 patch->is_delete, &patch->new_name,1012 DIFF_NEW_NAME);1013}10141015static intparse_mode_line(const char*line,int linenr,unsigned int*mode)1016{1017char*end;1018*mode =strtoul(line, &end,8);1019if(end == line || !isspace(*end))1020returnerror(_("invalid mode on line%d:%s"), linenr, line);1021return0;1022}10231024static intgitdiff_oldmode(struct apply_state *state,1025const char*line,1026struct patch *patch)1027{1028returnparse_mode_line(line, state->linenr, &patch->old_mode);1029}10301031static intgitdiff_newmode(struct apply_state *state,1032const char*line,1033struct patch *patch)1034{1035returnparse_mode_line(line, state->linenr, &patch->new_mode);1036}10371038static intgitdiff_delete(struct apply_state *state,1039const char*line,1040struct patch *patch)1041{1042 patch->is_delete =1;1043free(patch->old_name);1044 patch->old_name =xstrdup_or_null(patch->def_name);1045returngitdiff_oldmode(state, line, patch);1046}10471048static intgitdiff_newfile(struct apply_state *state,1049const char*line,1050struct patch *patch)1051{1052 patch->is_new =1;1053free(patch->new_name);1054 patch->new_name =xstrdup_or_null(patch->def_name);1055returngitdiff_newmode(state, line, patch);1056}10571058static intgitdiff_copysrc(struct apply_state *state,1059const char*line,1060struct patch *patch)1061{1062 patch->is_copy =1;1063free(patch->old_name);1064 patch->old_name =find_name(state, line, NULL, state->p_value ? state->p_value -1:0,0);1065return0;1066}10671068static intgitdiff_copydst(struct apply_state *state,1069const char*line,1070struct patch *patch)1071{1072 patch->is_copy =1;1073free(patch->new_name);1074 patch->new_name =find_name(state, line, NULL, state->p_value ? state->p_value -1:0,0);1075return0;1076}10771078static intgitdiff_renamesrc(struct apply_state *state,1079const char*line,1080struct patch *patch)1081{1082 patch->is_rename =1;1083free(patch->old_name);1084 patch->old_name =find_name(state, line, NULL, state->p_value ? state->p_value -1:0,0);1085return0;1086}10871088static intgitdiff_renamedst(struct apply_state *state,1089const char*line,1090struct patch *patch)1091{1092 patch->is_rename =1;1093free(patch->new_name);1094 patch->new_name =find_name(state, line, NULL, state->p_value ? state->p_value -1:0,0);1095return0;1096}10971098static intgitdiff_similarity(struct apply_state *state,1099const char*line,1100struct patch *patch)1101{1102unsigned long val =strtoul(line, NULL,10);1103if(val <=100)1104 patch->score = val;1105return0;1106}11071108static intgitdiff_dissimilarity(struct apply_state *state,1109const char*line,1110struct patch *patch)1111{1112unsigned long val =strtoul(line, NULL,10);1113if(val <=100)1114 patch->score = val;1115return0;1116}11171118static intgitdiff_index(struct apply_state *state,1119const char*line,1120struct patch *patch)1121{1122/*1123 * index line is N hexadecimal, "..", N hexadecimal,1124 * and optional space with octal mode.1125 */1126const char*ptr, *eol;1127int len;11281129 ptr =strchr(line,'.');1130if(!ptr || ptr[1] !='.'||40< ptr - line)1131return0;1132 len = ptr - line;1133memcpy(patch->old_sha1_prefix, line, len);1134 patch->old_sha1_prefix[len] =0;11351136 line = ptr +2;1137 ptr =strchr(line,' ');1138 eol =strchrnul(line,'\n');11391140if(!ptr || eol < ptr)1141 ptr = eol;1142 len = ptr - line;11431144if(40< len)1145return0;1146memcpy(patch->new_sha1_prefix, line, len);1147 patch->new_sha1_prefix[len] =0;1148if(*ptr ==' ')1149returngitdiff_oldmode(state, ptr +1, patch);1150return0;1151}11521153/*1154 * This is normal for a diff that doesn't change anything: we'll fall through1155 * into the next diff. Tell the parser to break out.1156 */1157static intgitdiff_unrecognized(struct apply_state *state,1158const char*line,1159struct patch *patch)1160{1161return1;1162}11631164/*1165 * Skip p_value leading components from "line"; as we do not accept1166 * absolute paths, return NULL in that case.1167 */1168static const char*skip_tree_prefix(struct apply_state *state,1169const char*line,1170int llen)1171{1172int nslash;1173int i;11741175if(!state->p_value)1176return(llen && line[0] =='/') ? NULL : line;11771178 nslash = state->p_value;1179for(i =0; i < llen; i++) {1180int ch = line[i];1181if(ch =='/'&& --nslash <=0)1182return(i ==0) ? NULL : &line[i +1];1183}1184return NULL;1185}11861187/*1188 * This is to extract the same name that appears on "diff --git"1189 * line. We do not find and return anything if it is a rename1190 * patch, and it is OK because we will find the name elsewhere.1191 * We need to reliably find name only when it is mode-change only,1192 * creation or deletion of an empty file. In any of these cases,1193 * both sides are the same name under a/ and b/ respectively.1194 */1195static char*git_header_name(struct apply_state *state,1196const char*line,1197int llen)1198{1199const char*name;1200const char*second = NULL;1201size_t len, line_len;12021203 line +=strlen("diff --git ");1204 llen -=strlen("diff --git ");12051206if(*line =='"') {1207const char*cp;1208struct strbuf first = STRBUF_INIT;1209struct strbuf sp = STRBUF_INIT;12101211if(unquote_c_style(&first, line, &second))1212goto free_and_fail1;12131214/* strip the a/b prefix including trailing slash */1215 cp =skip_tree_prefix(state, first.buf, first.len);1216if(!cp)1217goto free_and_fail1;1218strbuf_remove(&first,0, cp - first.buf);12191220/*1221 * second points at one past closing dq of name.1222 * find the second name.1223 */1224while((second < line + llen) &&isspace(*second))1225 second++;12261227if(line + llen <= second)1228goto free_and_fail1;1229if(*second =='"') {1230if(unquote_c_style(&sp, second, NULL))1231goto free_and_fail1;1232 cp =skip_tree_prefix(state, sp.buf, sp.len);1233if(!cp)1234goto free_and_fail1;1235/* They must match, otherwise ignore */1236if(strcmp(cp, first.buf))1237goto free_and_fail1;1238strbuf_release(&sp);1239returnstrbuf_detach(&first, NULL);1240}12411242/* unquoted second */1243 cp =skip_tree_prefix(state, second, line + llen - second);1244if(!cp)1245goto free_and_fail1;1246if(line + llen - cp != first.len ||1247memcmp(first.buf, cp, first.len))1248goto free_and_fail1;1249returnstrbuf_detach(&first, NULL);12501251 free_and_fail1:1252strbuf_release(&first);1253strbuf_release(&sp);1254return NULL;1255}12561257/* unquoted first name */1258 name =skip_tree_prefix(state, line, llen);1259if(!name)1260return NULL;12611262/*1263 * since the first name is unquoted, a dq if exists must be1264 * the beginning of the second name.1265 */1266for(second = name; second < line + llen; second++) {1267if(*second =='"') {1268struct strbuf sp = STRBUF_INIT;1269const char*np;12701271if(unquote_c_style(&sp, second, NULL))1272goto free_and_fail2;12731274 np =skip_tree_prefix(state, sp.buf, sp.len);1275if(!np)1276goto free_and_fail2;12771278 len = sp.buf + sp.len - np;1279if(len < second - name &&1280!strncmp(np, name, len) &&1281isspace(name[len])) {1282/* Good */1283strbuf_remove(&sp,0, np - sp.buf);1284returnstrbuf_detach(&sp, NULL);1285}12861287 free_and_fail2:1288strbuf_release(&sp);1289return NULL;1290}1291}12921293/*1294 * Accept a name only if it shows up twice, exactly the same1295 * form.1296 */1297 second =strchr(name,'\n');1298if(!second)1299return NULL;1300 line_len = second - name;1301for(len =0; ; len++) {1302switch(name[len]) {1303default:1304continue;1305case'\n':1306return NULL;1307case'\t':case' ':1308/*1309 * Is this the separator between the preimage1310 * and the postimage pathname? Again, we are1311 * only interested in the case where there is1312 * no rename, as this is only to set def_name1313 * and a rename patch has the names elsewhere1314 * in an unambiguous form.1315 */1316if(!name[len +1])1317return NULL;/* no postimage name */1318 second =skip_tree_prefix(state, name + len +1,1319 line_len - (len +1));1320if(!second)1321return NULL;1322/*1323 * Does len bytes starting at "name" and "second"1324 * (that are separated by one HT or SP we just1325 * found) exactly match?1326 */1327if(second[len] =='\n'&& !strncmp(name, second, len))1328returnxmemdupz(name, len);1329}1330}1331}13321333static intcheck_header_line(struct apply_state *state,struct patch *patch)1334{1335int extensions = (patch->is_delete ==1) + (patch->is_new ==1) +1336(patch->is_rename ==1) + (patch->is_copy ==1);1337if(extensions >1)1338returnerror(_("inconsistent header lines%dand%d"),1339 patch->extension_linenr, state->linenr);1340if(extensions && !patch->extension_linenr)1341 patch->extension_linenr = state->linenr;1342return0;1343}13441345/* Verify that we recognize the lines following a git header */1346static intparse_git_header(struct apply_state *state,1347const char*line,1348int len,1349unsigned int size,1350struct patch *patch)1351{1352unsigned long offset;13531354/* A git diff has explicit new/delete information, so we don't guess */1355 patch->is_new =0;1356 patch->is_delete =0;13571358/*1359 * Some things may not have the old name in the1360 * rest of the headers anywhere (pure mode changes,1361 * or removing or adding empty files), so we get1362 * the default name from the header.1363 */1364 patch->def_name =git_header_name(state, line, len);1365if(patch->def_name && state->root.len) {1366char*s =xstrfmt("%s%s", state->root.buf, patch->def_name);1367free(patch->def_name);1368 patch->def_name = s;1369}13701371 line += len;1372 size -= len;1373 state->linenr++;1374for(offset = len ; size >0; offset += len, size -= len, line += len, state->linenr++) {1375static const struct opentry {1376const char*str;1377int(*fn)(struct apply_state *,const char*,struct patch *);1378} optable[] = {1379{"@@ -", gitdiff_hdrend },1380{"--- ", gitdiff_oldname },1381{"+++ ", gitdiff_newname },1382{"old mode ", gitdiff_oldmode },1383{"new mode ", gitdiff_newmode },1384{"deleted file mode ", gitdiff_delete },1385{"new file mode ", gitdiff_newfile },1386{"copy from ", gitdiff_copysrc },1387{"copy to ", gitdiff_copydst },1388{"rename old ", gitdiff_renamesrc },1389{"rename new ", gitdiff_renamedst },1390{"rename from ", gitdiff_renamesrc },1391{"rename to ", gitdiff_renamedst },1392{"similarity index ", gitdiff_similarity },1393{"dissimilarity index ", gitdiff_dissimilarity },1394{"index ", gitdiff_index },1395{"", gitdiff_unrecognized },1396};1397int i;13981399 len =linelen(line, size);1400if(!len || line[len-1] !='\n')1401break;1402for(i =0; i <ARRAY_SIZE(optable); i++) {1403const struct opentry *p = optable + i;1404int oplen =strlen(p->str);1405int res;1406if(len < oplen ||memcmp(p->str, line, oplen))1407continue;1408 res = p->fn(state, line + oplen, patch);1409if(res <0)1410return-1;1411if(check_header_line(state, patch))1412return-1;1413if(res >0)1414return offset;1415break;1416}1417}14181419return offset;1420}14211422static intparse_num(const char*line,unsigned long*p)1423{1424char*ptr;14251426if(!isdigit(*line))1427return0;1428*p =strtoul(line, &ptr,10);1429return ptr - line;1430}14311432static intparse_range(const char*line,int len,int offset,const char*expect,1433unsigned long*p1,unsigned long*p2)1434{1435int digits, ex;14361437if(offset <0|| offset >= len)1438return-1;1439 line += offset;1440 len -= offset;14411442 digits =parse_num(line, p1);1443if(!digits)1444return-1;14451446 offset += digits;1447 line += digits;1448 len -= digits;14491450*p2 =1;1451if(*line ==',') {1452 digits =parse_num(line+1, p2);1453if(!digits)1454return-1;14551456 offset += digits+1;1457 line += digits+1;1458 len -= digits+1;1459}14601461 ex =strlen(expect);1462if(ex > len)1463return-1;1464if(memcmp(line, expect, ex))1465return-1;14661467return offset + ex;1468}14691470static voidrecount_diff(const char*line,int size,struct fragment *fragment)1471{1472int oldlines =0, newlines =0, ret =0;14731474if(size <1) {1475warning("recount: ignore empty hunk");1476return;1477}14781479for(;;) {1480int len =linelen(line, size);1481 size -= len;1482 line += len;14831484if(size <1)1485break;14861487switch(*line) {1488case' ':case'\n':1489 newlines++;1490/* fall through */1491case'-':1492 oldlines++;1493continue;1494case'+':1495 newlines++;1496continue;1497case'\\':1498continue;1499case'@':1500 ret = size <3|| !starts_with(line,"@@ ");1501break;1502case'd':1503 ret = size <5|| !starts_with(line,"diff ");1504break;1505default:1506 ret = -1;1507break;1508}1509if(ret) {1510warning(_("recount: unexpected line: %.*s"),1511(int)linelen(line, size), line);1512return;1513}1514break;1515}1516 fragment->oldlines = oldlines;1517 fragment->newlines = newlines;1518}15191520/*1521 * Parse a unified diff fragment header of the1522 * form "@@ -a,b +c,d @@"1523 */1524static intparse_fragment_header(const char*line,int len,struct fragment *fragment)1525{1526int offset;15271528if(!len || line[len-1] !='\n')1529return-1;15301531/* Figure out the number of lines in a fragment */1532 offset =parse_range(line, len,4," +", &fragment->oldpos, &fragment->oldlines);1533 offset =parse_range(line, len, offset," @@", &fragment->newpos, &fragment->newlines);15341535return offset;1536}15371538/*1539 * Find file diff header1540 *1541 * Returns:1542 * -1 if no header was found1543 * -128 in case of error1544 * the size of the header in bytes (called "offset") otherwise1545 */1546static intfind_header(struct apply_state *state,1547const char*line,1548unsigned long size,1549int*hdrsize,1550struct patch *patch)1551{1552unsigned long offset, len;15531554 patch->is_toplevel_relative =0;1555 patch->is_rename = patch->is_copy =0;1556 patch->is_new = patch->is_delete = -1;1557 patch->old_mode = patch->new_mode =0;1558 patch->old_name = patch->new_name = NULL;1559for(offset =0; size >0; offset += len, size -= len, line += len, state->linenr++) {1560unsigned long nextlen;15611562 len =linelen(line, size);1563if(!len)1564break;15651566/* Testing this early allows us to take a few shortcuts.. */1567if(len <6)1568continue;15691570/*1571 * Make sure we don't find any unconnected patch fragments.1572 * That's a sign that we didn't find a header, and that a1573 * patch has become corrupted/broken up.1574 */1575if(!memcmp("@@ -", line,4)) {1576struct fragment dummy;1577if(parse_fragment_header(line, len, &dummy) <0)1578continue;1579error(_("patch fragment without header at line%d: %.*s"),1580 state->linenr, (int)len-1, line);1581return-128;1582}15831584if(size < len +6)1585break;15861587/*1588 * Git patch? It might not have a real patch, just a rename1589 * or mode change, so we handle that specially1590 */1591if(!memcmp("diff --git ", line,11)) {1592int git_hdr_len =parse_git_header(state, line, len, size, patch);1593if(git_hdr_len <0)1594return-128;1595if(git_hdr_len <= len)1596continue;1597if(!patch->old_name && !patch->new_name) {1598if(!patch->def_name) {1599error(Q_("git diff header lacks filename information when removing "1600"%dleading pathname component (line%d)",1601"git diff header lacks filename information when removing "1602"%dleading pathname components (line%d)",1603 state->p_value),1604 state->p_value, state->linenr);1605return-128;1606}1607 patch->old_name =xstrdup(patch->def_name);1608 patch->new_name =xstrdup(patch->def_name);1609}1610if((!patch->new_name && !patch->is_delete) ||1611(!patch->old_name && !patch->is_new)) {1612error(_("git diff header lacks filename information "1613"(line%d)"), state->linenr);1614return-128;1615}1616 patch->is_toplevel_relative =1;1617*hdrsize = git_hdr_len;1618return offset;1619}16201621/* --- followed by +++ ? */1622if(memcmp("--- ", line,4) ||memcmp("+++ ", line + len,4))1623continue;16241625/*1626 * We only accept unified patches, so we want it to1627 * at least have "@@ -a,b +c,d @@\n", which is 14 chars1628 * minimum ("@@ -0,0 +1 @@\n" is the shortest).1629 */1630 nextlen =linelen(line + len, size - len);1631if(size < nextlen +14||memcmp("@@ -", line + len + nextlen,4))1632continue;16331634/* Ok, we'll consider it a patch */1635if(parse_traditional_patch(state, line, line+len, patch))1636return-128;1637*hdrsize = len + nextlen;1638 state->linenr +=2;1639return offset;1640}1641return-1;1642}16431644static voidrecord_ws_error(struct apply_state *state,1645unsigned result,1646const char*line,1647int len,1648int linenr)1649{1650char*err;16511652if(!result)1653return;16541655 state->whitespace_error++;1656if(state->squelch_whitespace_errors &&1657 state->squelch_whitespace_errors < state->whitespace_error)1658return;16591660 err =whitespace_error_string(result);1661if(state->apply_verbosity > verbosity_silent)1662fprintf(stderr,"%s:%d:%s.\n%.*s\n",1663 state->patch_input_file, linenr, err, len, line);1664free(err);1665}16661667static voidcheck_whitespace(struct apply_state *state,1668const char*line,1669int len,1670unsigned ws_rule)1671{1672unsigned result =ws_check(line +1, len -1, ws_rule);16731674record_ws_error(state, result, line +1, len -2, state->linenr);1675}16761677/*1678 * Parse a unified diff. Note that this really needs to parse each1679 * fragment separately, since the only way to know the difference1680 * between a "---" that is part of a patch, and a "---" that starts1681 * the next patch is to look at the line counts..1682 */1683static intparse_fragment(struct apply_state *state,1684const char*line,1685unsigned long size,1686struct patch *patch,1687struct fragment *fragment)1688{1689int added, deleted;1690int len =linelen(line, size), offset;1691unsigned long oldlines, newlines;1692unsigned long leading, trailing;16931694 offset =parse_fragment_header(line, len, fragment);1695if(offset <0)1696return-1;1697if(offset >0&& patch->recount)1698recount_diff(line + offset, size - offset, fragment);1699 oldlines = fragment->oldlines;1700 newlines = fragment->newlines;1701 leading =0;1702 trailing =0;17031704/* Parse the thing.. */1705 line += len;1706 size -= len;1707 state->linenr++;1708 added = deleted =0;1709for(offset = len;17100< size;1711 offset += len, size -= len, line += len, state->linenr++) {1712if(!oldlines && !newlines)1713break;1714 len =linelen(line, size);1715if(!len || line[len-1] !='\n')1716return-1;1717switch(*line) {1718default:1719return-1;1720case'\n':/* newer GNU diff, an empty context line */1721case' ':1722 oldlines--;1723 newlines--;1724if(!deleted && !added)1725 leading++;1726 trailing++;1727if(!state->apply_in_reverse &&1728 state->ws_error_action == correct_ws_error)1729check_whitespace(state, line, len, patch->ws_rule);1730break;1731case'-':1732if(state->apply_in_reverse &&1733 state->ws_error_action != nowarn_ws_error)1734check_whitespace(state, line, len, patch->ws_rule);1735 deleted++;1736 oldlines--;1737 trailing =0;1738break;1739case'+':1740if(!state->apply_in_reverse &&1741 state->ws_error_action != nowarn_ws_error)1742check_whitespace(state, line, len, patch->ws_rule);1743 added++;1744 newlines--;1745 trailing =0;1746break;17471748/*1749 * We allow "\ No newline at end of file". Depending1750 * on locale settings when the patch was produced we1751 * don't know what this line looks like. The only1752 * thing we do know is that it begins with "\ ".1753 * Checking for 12 is just for sanity check -- any1754 * l10n of "\ No newline..." is at least that long.1755 */1756case'\\':1757if(len <12||memcmp(line,"\\",2))1758return-1;1759break;1760}1761}1762if(oldlines || newlines)1763return-1;1764if(!deleted && !added)1765return-1;17661767 fragment->leading = leading;1768 fragment->trailing = trailing;17691770/*1771 * If a fragment ends with an incomplete line, we failed to include1772 * it in the above loop because we hit oldlines == newlines == 01773 * before seeing it.1774 */1775if(12< size && !memcmp(line,"\\",2))1776 offset +=linelen(line, size);17771778 patch->lines_added += added;1779 patch->lines_deleted += deleted;17801781if(0< patch->is_new && oldlines)1782returnerror(_("new file depends on old contents"));1783if(0< patch->is_delete && newlines)1784returnerror(_("deleted file still has contents"));1785return offset;1786}17871788/*1789 * We have seen "diff --git a/... b/..." header (or a traditional patch1790 * header). Read hunks that belong to this patch into fragments and hang1791 * them to the given patch structure.1792 *1793 * The (fragment->patch, fragment->size) pair points into the memory given1794 * by the caller, not a copy, when we return.1795 *1796 * Returns:1797 * -1 in case of error,1798 * the number of bytes in the patch otherwise.1799 */1800static intparse_single_patch(struct apply_state *state,1801const char*line,1802unsigned long size,1803struct patch *patch)1804{1805unsigned long offset =0;1806unsigned long oldlines =0, newlines =0, context =0;1807struct fragment **fragp = &patch->fragments;18081809while(size >4&& !memcmp(line,"@@ -",4)) {1810struct fragment *fragment;1811int len;18121813 fragment =xcalloc(1,sizeof(*fragment));1814 fragment->linenr = state->linenr;1815 len =parse_fragment(state, line, size, patch, fragment);1816if(len <=0) {1817free(fragment);1818returnerror(_("corrupt patch at line%d"), state->linenr);1819}1820 fragment->patch = line;1821 fragment->size = len;1822 oldlines += fragment->oldlines;1823 newlines += fragment->newlines;1824 context += fragment->leading + fragment->trailing;18251826*fragp = fragment;1827 fragp = &fragment->next;18281829 offset += len;1830 line += len;1831 size -= len;1832}18331834/*1835 * If something was removed (i.e. we have old-lines) it cannot1836 * be creation, and if something was added it cannot be1837 * deletion. However, the reverse is not true; --unified=01838 * patches that only add are not necessarily creation even1839 * though they do not have any old lines, and ones that only1840 * delete are not necessarily deletion.1841 *1842 * Unfortunately, a real creation/deletion patch do _not_ have1843 * any context line by definition, so we cannot safely tell it1844 * apart with --unified=0 insanity. At least if the patch has1845 * more than one hunk it is not creation or deletion.1846 */1847if(patch->is_new <0&&1848(oldlines || (patch->fragments && patch->fragments->next)))1849 patch->is_new =0;1850if(patch->is_delete <0&&1851(newlines || (patch->fragments && patch->fragments->next)))1852 patch->is_delete =0;18531854if(0< patch->is_new && oldlines)1855returnerror(_("new file%sdepends on old contents"), patch->new_name);1856if(0< patch->is_delete && newlines)1857returnerror(_("deleted file%sstill has contents"), patch->old_name);1858if(!patch->is_delete && !newlines && context && state->apply_verbosity > verbosity_silent)1859fprintf_ln(stderr,1860_("** warning: "1861"file%sbecomes empty but is not deleted"),1862 patch->new_name);18631864return offset;1865}18661867staticinlineintmetadata_changes(struct patch *patch)1868{1869return patch->is_rename >0||1870 patch->is_copy >0||1871 patch->is_new >0||1872 patch->is_delete ||1873(patch->old_mode && patch->new_mode &&1874 patch->old_mode != patch->new_mode);1875}18761877static char*inflate_it(const void*data,unsigned long size,1878unsigned long inflated_size)1879{1880 git_zstream stream;1881void*out;1882int st;18831884memset(&stream,0,sizeof(stream));18851886 stream.next_in = (unsigned char*)data;1887 stream.avail_in = size;1888 stream.next_out = out =xmalloc(inflated_size);1889 stream.avail_out = inflated_size;1890git_inflate_init(&stream);1891 st =git_inflate(&stream, Z_FINISH);1892git_inflate_end(&stream);1893if((st != Z_STREAM_END) || stream.total_out != inflated_size) {1894free(out);1895return NULL;1896}1897return out;1898}18991900/*1901 * Read a binary hunk and return a new fragment; fragment->patch1902 * points at an allocated memory that the caller must free, so1903 * it is marked as "->free_patch = 1".1904 */1905static struct fragment *parse_binary_hunk(struct apply_state *state,1906char**buf_p,1907unsigned long*sz_p,1908int*status_p,1909int*used_p)1910{1911/*1912 * Expect a line that begins with binary patch method ("literal"1913 * or "delta"), followed by the length of data before deflating.1914 * a sequence of 'length-byte' followed by base-85 encoded data1915 * should follow, terminated by a newline.1916 *1917 * Each 5-byte sequence of base-85 encodes up to 4 bytes,1918 * and we would limit the patch line to 66 characters,1919 * so one line can fit up to 13 groups that would decode1920 * to 52 bytes max. The length byte 'A'-'Z' corresponds1921 * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.1922 */1923int llen, used;1924unsigned long size = *sz_p;1925char*buffer = *buf_p;1926int patch_method;1927unsigned long origlen;1928char*data = NULL;1929int hunk_size =0;1930struct fragment *frag;19311932 llen =linelen(buffer, size);1933 used = llen;19341935*status_p =0;19361937if(starts_with(buffer,"delta ")) {1938 patch_method = BINARY_DELTA_DEFLATED;1939 origlen =strtoul(buffer +6, NULL,10);1940}1941else if(starts_with(buffer,"literal ")) {1942 patch_method = BINARY_LITERAL_DEFLATED;1943 origlen =strtoul(buffer +8, NULL,10);1944}1945else1946return NULL;19471948 state->linenr++;1949 buffer += llen;1950while(1) {1951int byte_length, max_byte_length, newsize;1952 llen =linelen(buffer, size);1953 used += llen;1954 state->linenr++;1955if(llen ==1) {1956/* consume the blank line */1957 buffer++;1958 size--;1959break;1960}1961/*1962 * Minimum line is "A00000\n" which is 7-byte long,1963 * and the line length must be multiple of 5 plus 2.1964 */1965if((llen <7) || (llen-2) %5)1966goto corrupt;1967 max_byte_length = (llen -2) /5*4;1968 byte_length = *buffer;1969if('A'<= byte_length && byte_length <='Z')1970 byte_length = byte_length -'A'+1;1971else if('a'<= byte_length && byte_length <='z')1972 byte_length = byte_length -'a'+27;1973else1974goto corrupt;1975/* if the input length was not multiple of 4, we would1976 * have filler at the end but the filler should never1977 * exceed 3 bytes1978 */1979if(max_byte_length < byte_length ||1980 byte_length <= max_byte_length -4)1981goto corrupt;1982 newsize = hunk_size + byte_length;1983 data =xrealloc(data, newsize);1984if(decode_85(data + hunk_size, buffer +1, byte_length))1985goto corrupt;1986 hunk_size = newsize;1987 buffer += llen;1988 size -= llen;1989}19901991 frag =xcalloc(1,sizeof(*frag));1992 frag->patch =inflate_it(data, hunk_size, origlen);1993 frag->free_patch =1;1994if(!frag->patch)1995goto corrupt;1996free(data);1997 frag->size = origlen;1998*buf_p = buffer;1999*sz_p = size;2000*used_p = used;2001 frag->binary_patch_method = patch_method;2002return frag;20032004 corrupt:2005free(data);2006*status_p = -1;2007error(_("corrupt binary patch at line%d: %.*s"),2008 state->linenr-1, llen-1, buffer);2009return NULL;2010}20112012/*2013 * Returns:2014 * -1 in case of error,2015 * the length of the parsed binary patch otherwise2016 */2017static intparse_binary(struct apply_state *state,2018char*buffer,2019unsigned long size,2020struct patch *patch)2021{2022/*2023 * We have read "GIT binary patch\n"; what follows is a line2024 * that says the patch method (currently, either "literal" or2025 * "delta") and the length of data before deflating; a2026 * sequence of 'length-byte' followed by base-85 encoded data2027 * follows.2028 *2029 * When a binary patch is reversible, there is another binary2030 * hunk in the same format, starting with patch method (either2031 * "literal" or "delta") with the length of data, and a sequence2032 * of length-byte + base-85 encoded data, terminated with another2033 * empty line. This data, when applied to the postimage, produces2034 * the preimage.2035 */2036struct fragment *forward;2037struct fragment *reverse;2038int status;2039int used, used_1;20402041 forward =parse_binary_hunk(state, &buffer, &size, &status, &used);2042if(!forward && !status)2043/* there has to be one hunk (forward hunk) */2044returnerror(_("unrecognized binary patch at line%d"), state->linenr-1);2045if(status)2046/* otherwise we already gave an error message */2047return status;20482049 reverse =parse_binary_hunk(state, &buffer, &size, &status, &used_1);2050if(reverse)2051 used += used_1;2052else if(status) {2053/*2054 * Not having reverse hunk is not an error, but having2055 * a corrupt reverse hunk is.2056 */2057free((void*) forward->patch);2058free(forward);2059return status;2060}2061 forward->next = reverse;2062 patch->fragments = forward;2063 patch->is_binary =1;2064return used;2065}20662067static voidprefix_one(struct apply_state *state,char**name)2068{2069char*old_name = *name;2070if(!old_name)2071return;2072*name =prefix_filename(state->prefix, *name);2073free(old_name);2074}20752076static voidprefix_patch(struct apply_state *state,struct patch *p)2077{2078if(!state->prefix || p->is_toplevel_relative)2079return;2080prefix_one(state, &p->new_name);2081prefix_one(state, &p->old_name);2082}20832084/*2085 * include/exclude2086 */20872088static voidadd_name_limit(struct apply_state *state,2089const char*name,2090int exclude)2091{2092struct string_list_item *it;20932094 it =string_list_append(&state->limit_by_name, name);2095 it->util = exclude ? NULL : (void*)1;2096}20972098static intuse_patch(struct apply_state *state,struct patch *p)2099{2100const char*pathname = p->new_name ? p->new_name : p->old_name;2101int i;21022103/* Paths outside are not touched regardless of "--include" */2104if(0< state->prefix_length) {2105int pathlen =strlen(pathname);2106if(pathlen <= state->prefix_length ||2107memcmp(state->prefix, pathname, state->prefix_length))2108return0;2109}21102111/* See if it matches any of exclude/include rule */2112for(i =0; i < state->limit_by_name.nr; i++) {2113struct string_list_item *it = &state->limit_by_name.items[i];2114if(!wildmatch(it->string, pathname,0, NULL))2115return(it->util != NULL);2116}21172118/*2119 * If we had any include, a path that does not match any rule is2120 * not used. Otherwise, we saw bunch of exclude rules (or none)2121 * and such a path is used.2122 */2123return!state->has_include;2124}21252126/*2127 * Read the patch text in "buffer" that extends for "size" bytes; stop2128 * reading after seeing a single patch (i.e. changes to a single file).2129 * Create fragments (i.e. patch hunks) and hang them to the given patch.2130 *2131 * Returns:2132 * -1 if no header was found or parse_binary() failed,2133 * -128 on another error,2134 * the number of bytes consumed otherwise,2135 * so that the caller can call us again for the next patch.2136 */2137static intparse_chunk(struct apply_state *state,char*buffer,unsigned long size,struct patch *patch)2138{2139int hdrsize, patchsize;2140int offset =find_header(state, buffer, size, &hdrsize, patch);21412142if(offset <0)2143return offset;21442145prefix_patch(state, patch);21462147if(!use_patch(state, patch))2148 patch->ws_rule =0;2149else2150 patch->ws_rule =whitespace_rule(patch->new_name2151? patch->new_name2152: patch->old_name);21532154 patchsize =parse_single_patch(state,2155 buffer + offset + hdrsize,2156 size - offset - hdrsize,2157 patch);21582159if(patchsize <0)2160return-128;21612162if(!patchsize) {2163static const char git_binary[] ="GIT binary patch\n";2164int hd = hdrsize + offset;2165unsigned long llen =linelen(buffer + hd, size - hd);21662167if(llen ==sizeof(git_binary) -1&&2168!memcmp(git_binary, buffer + hd, llen)) {2169int used;2170 state->linenr++;2171 used =parse_binary(state, buffer + hd + llen,2172 size - hd - llen, patch);2173if(used <0)2174return-1;2175if(used)2176 patchsize = used + llen;2177else2178 patchsize =0;2179}2180else if(!memcmp(" differ\n", buffer + hd + llen -8,8)) {2181static const char*binhdr[] = {2182"Binary files ",2183"Files ",2184 NULL,2185};2186int i;2187for(i =0; binhdr[i]; i++) {2188int len =strlen(binhdr[i]);2189if(len < size - hd &&2190!memcmp(binhdr[i], buffer + hd, len)) {2191 state->linenr++;2192 patch->is_binary =1;2193 patchsize = llen;2194break;2195}2196}2197}21982199/* Empty patch cannot be applied if it is a text patch2200 * without metadata change. A binary patch appears2201 * empty to us here.2202 */2203if((state->apply || state->check) &&2204(!patch->is_binary && !metadata_changes(patch))) {2205error(_("patch with only garbage at line%d"), state->linenr);2206return-128;2207}2208}22092210return offset + hdrsize + patchsize;2211}22122213static voidreverse_patches(struct patch *p)2214{2215for(; p; p = p->next) {2216struct fragment *frag = p->fragments;22172218SWAP(p->new_name, p->old_name);2219SWAP(p->new_mode, p->old_mode);2220SWAP(p->is_new, p->is_delete);2221SWAP(p->lines_added, p->lines_deleted);2222SWAP(p->old_sha1_prefix, p->new_sha1_prefix);22232224for(; frag; frag = frag->next) {2225SWAP(frag->newpos, frag->oldpos);2226SWAP(frag->newlines, frag->oldlines);2227}2228}2229}22302231static const char pluses[] =2232"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";2233static const char minuses[]=2234"----------------------------------------------------------------------";22352236static voidshow_stats(struct apply_state *state,struct patch *patch)2237{2238struct strbuf qname = STRBUF_INIT;2239char*cp = patch->new_name ? patch->new_name : patch->old_name;2240int max, add, del;22412242quote_c_style(cp, &qname, NULL,0);22432244/*2245 * "scale" the filename2246 */2247 max = state->max_len;2248if(max >50)2249 max =50;22502251if(qname.len > max) {2252 cp =strchr(qname.buf + qname.len +3- max,'/');2253if(!cp)2254 cp = qname.buf + qname.len +3- max;2255strbuf_splice(&qname,0, cp - qname.buf,"...",3);2256}22572258if(patch->is_binary) {2259printf(" %-*s | Bin\n", max, qname.buf);2260strbuf_release(&qname);2261return;2262}22632264printf(" %-*s |", max, qname.buf);2265strbuf_release(&qname);22662267/*2268 * scale the add/delete2269 */2270 max = max + state->max_change >70?70- max : state->max_change;2271 add = patch->lines_added;2272 del = patch->lines_deleted;22732274if(state->max_change >0) {2275int total = ((add + del) * max + state->max_change /2) / state->max_change;2276 add = (add * max + state->max_change /2) / state->max_change;2277 del = total - add;2278}2279printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,2280 add, pluses, del, minuses);2281}22822283static intread_old_data(struct stat *st,const char*path,struct strbuf *buf)2284{2285switch(st->st_mode & S_IFMT) {2286case S_IFLNK:2287if(strbuf_readlink(buf, path, st->st_size) <0)2288returnerror(_("unable to read symlink%s"), path);2289return0;2290case S_IFREG:2291if(strbuf_read_file(buf, path, st->st_size) != st->st_size)2292returnerror(_("unable to open or read%s"), path);2293convert_to_git(path, buf->buf, buf->len, buf,0);2294return0;2295default:2296return-1;2297}2298}22992300/*2301 * Update the preimage, and the common lines in postimage,2302 * from buffer buf of length len. If postlen is 0 the postimage2303 * is updated in place, otherwise it's updated on a new buffer2304 * of length postlen2305 */23062307static voidupdate_pre_post_images(struct image *preimage,2308struct image *postimage,2309char*buf,2310size_t len,size_t postlen)2311{2312int i, ctx, reduced;2313char*new, *old, *fixed;2314struct image fixed_preimage;23152316/*2317 * Update the preimage with whitespace fixes. Note that we2318 * are not losing preimage->buf -- apply_one_fragment() will2319 * free "oldlines".2320 */2321prepare_image(&fixed_preimage, buf, len,1);2322assert(postlen2323? fixed_preimage.nr == preimage->nr2324: fixed_preimage.nr <= preimage->nr);2325for(i =0; i < fixed_preimage.nr; i++)2326 fixed_preimage.line[i].flag = preimage->line[i].flag;2327free(preimage->line_allocated);2328*preimage = fixed_preimage;23292330/*2331 * Adjust the common context lines in postimage. This can be2332 * done in-place when we are shrinking it with whitespace2333 * fixing, but needs a new buffer when ignoring whitespace or2334 * expanding leading tabs to spaces.2335 *2336 * We trust the caller to tell us if the update can be done2337 * in place (postlen==0) or not.2338 */2339 old = postimage->buf;2340if(postlen)2341new= postimage->buf =xmalloc(postlen);2342else2343new= old;2344 fixed = preimage->buf;23452346for(i = reduced = ctx =0; i < postimage->nr; i++) {2347size_t l_len = postimage->line[i].len;2348if(!(postimage->line[i].flag & LINE_COMMON)) {2349/* an added line -- no counterparts in preimage */2350memmove(new, old, l_len);2351 old += l_len;2352new+= l_len;2353continue;2354}23552356/* a common context -- skip it in the original postimage */2357 old += l_len;23582359/* and find the corresponding one in the fixed preimage */2360while(ctx < preimage->nr &&2361!(preimage->line[ctx].flag & LINE_COMMON)) {2362 fixed += preimage->line[ctx].len;2363 ctx++;2364}23652366/*2367 * preimage is expected to run out, if the caller2368 * fixed addition of trailing blank lines.2369 */2370if(preimage->nr <= ctx) {2371 reduced++;2372continue;2373}23742375/* and copy it in, while fixing the line length */2376 l_len = preimage->line[ctx].len;2377memcpy(new, fixed, l_len);2378new+= l_len;2379 fixed += l_len;2380 postimage->line[i].len = l_len;2381 ctx++;2382}23832384if(postlen2385? postlen <new- postimage->buf2386: postimage->len <new- postimage->buf)2387die("BUG: caller miscounted postlen: asked%d, orig =%d, used =%d",2388(int)postlen, (int) postimage->len, (int)(new- postimage->buf));23892390/* Fix the length of the whole thing */2391 postimage->len =new- postimage->buf;2392 postimage->nr -= reduced;2393}23942395static intline_by_line_fuzzy_match(struct image *img,2396struct image *preimage,2397struct image *postimage,2398unsigned longtry,2399int try_lno,2400int preimage_limit)2401{2402int i;2403size_t imgoff =0;2404size_t preoff =0;2405size_t postlen = postimage->len;2406size_t extra_chars;2407char*buf;2408char*preimage_eof;2409char*preimage_end;2410struct strbuf fixed;2411char*fixed_buf;2412size_t fixed_len;24132414for(i =0; i < preimage_limit; i++) {2415size_t prelen = preimage->line[i].len;2416size_t imglen = img->line[try_lno+i].len;24172418if(!fuzzy_matchlines(img->buf +try+ imgoff, imglen,2419 preimage->buf + preoff, prelen))2420return0;2421if(preimage->line[i].flag & LINE_COMMON)2422 postlen += imglen - prelen;2423 imgoff += imglen;2424 preoff += prelen;2425}24262427/*2428 * Ok, the preimage matches with whitespace fuzz.2429 *2430 * imgoff now holds the true length of the target that2431 * matches the preimage before the end of the file.2432 *2433 * Count the number of characters in the preimage that fall2434 * beyond the end of the file and make sure that all of them2435 * are whitespace characters. (This can only happen if2436 * we are removing blank lines at the end of the file.)2437 */2438 buf = preimage_eof = preimage->buf + preoff;2439for( ; i < preimage->nr; i++)2440 preoff += preimage->line[i].len;2441 preimage_end = preimage->buf + preoff;2442for( ; buf < preimage_end; buf++)2443if(!isspace(*buf))2444return0;24452446/*2447 * Update the preimage and the common postimage context2448 * lines to use the same whitespace as the target.2449 * If whitespace is missing in the target (i.e.2450 * if the preimage extends beyond the end of the file),2451 * use the whitespace from the preimage.2452 */2453 extra_chars = preimage_end - preimage_eof;2454strbuf_init(&fixed, imgoff + extra_chars);2455strbuf_add(&fixed, img->buf +try, imgoff);2456strbuf_add(&fixed, preimage_eof, extra_chars);2457 fixed_buf =strbuf_detach(&fixed, &fixed_len);2458update_pre_post_images(preimage, postimage,2459 fixed_buf, fixed_len, postlen);2460return1;2461}24622463static intmatch_fragment(struct apply_state *state,2464struct image *img,2465struct image *preimage,2466struct image *postimage,2467unsigned longtry,2468int try_lno,2469unsigned ws_rule,2470int match_beginning,int match_end)2471{2472int i;2473char*fixed_buf, *buf, *orig, *target;2474struct strbuf fixed;2475size_t fixed_len, postlen;2476int preimage_limit;24772478if(preimage->nr + try_lno <= img->nr) {2479/*2480 * The hunk falls within the boundaries of img.2481 */2482 preimage_limit = preimage->nr;2483if(match_end && (preimage->nr + try_lno != img->nr))2484return0;2485}else if(state->ws_error_action == correct_ws_error &&2486(ws_rule & WS_BLANK_AT_EOF)) {2487/*2488 * This hunk extends beyond the end of img, and we are2489 * removing blank lines at the end of the file. This2490 * many lines from the beginning of the preimage must2491 * match with img, and the remainder of the preimage2492 * must be blank.2493 */2494 preimage_limit = img->nr - try_lno;2495}else{2496/*2497 * The hunk extends beyond the end of the img and2498 * we are not removing blanks at the end, so we2499 * should reject the hunk at this position.2500 */2501return0;2502}25032504if(match_beginning && try_lno)2505return0;25062507/* Quick hash check */2508for(i =0; i < preimage_limit; i++)2509if((img->line[try_lno + i].flag & LINE_PATCHED) ||2510(preimage->line[i].hash != img->line[try_lno + i].hash))2511return0;25122513if(preimage_limit == preimage->nr) {2514/*2515 * Do we have an exact match? If we were told to match2516 * at the end, size must be exactly at try+fragsize,2517 * otherwise try+fragsize must be still within the preimage,2518 * and either case, the old piece should match the preimage2519 * exactly.2520 */2521if((match_end2522? (try+ preimage->len == img->len)2523: (try+ preimage->len <= img->len)) &&2524!memcmp(img->buf +try, preimage->buf, preimage->len))2525return1;2526}else{2527/*2528 * The preimage extends beyond the end of img, so2529 * there cannot be an exact match.2530 *2531 * There must be one non-blank context line that match2532 * a line before the end of img.2533 */2534char*buf_end;25352536 buf = preimage->buf;2537 buf_end = buf;2538for(i =0; i < preimage_limit; i++)2539 buf_end += preimage->line[i].len;25402541for( ; buf < buf_end; buf++)2542if(!isspace(*buf))2543break;2544if(buf == buf_end)2545return0;2546}25472548/*2549 * No exact match. If we are ignoring whitespace, run a line-by-line2550 * fuzzy matching. We collect all the line length information because2551 * we need it to adjust whitespace if we match.2552 */2553if(state->ws_ignore_action == ignore_ws_change)2554returnline_by_line_fuzzy_match(img, preimage, postimage,2555try, try_lno, preimage_limit);25562557if(state->ws_error_action != correct_ws_error)2558return0;25592560/*2561 * The hunk does not apply byte-by-byte, but the hash says2562 * it might with whitespace fuzz. We weren't asked to2563 * ignore whitespace, we were asked to correct whitespace2564 * errors, so let's try matching after whitespace correction.2565 *2566 * While checking the preimage against the target, whitespace2567 * errors in both fixed, we count how large the corresponding2568 * postimage needs to be. The postimage prepared by2569 * apply_one_fragment() has whitespace errors fixed on added2570 * lines already, but the common lines were propagated as-is,2571 * which may become longer when their whitespace errors are2572 * fixed.2573 */25742575/* First count added lines in postimage */2576 postlen =0;2577for(i =0; i < postimage->nr; i++) {2578if(!(postimage->line[i].flag & LINE_COMMON))2579 postlen += postimage->line[i].len;2580}25812582/*2583 * The preimage may extend beyond the end of the file,2584 * but in this loop we will only handle the part of the2585 * preimage that falls within the file.2586 */2587strbuf_init(&fixed, preimage->len +1);2588 orig = preimage->buf;2589 target = img->buf +try;2590for(i =0; i < preimage_limit; i++) {2591size_t oldlen = preimage->line[i].len;2592size_t tgtlen = img->line[try_lno + i].len;2593size_t fixstart = fixed.len;2594struct strbuf tgtfix;2595int match;25962597/* Try fixing the line in the preimage */2598ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);25992600/* Try fixing the line in the target */2601strbuf_init(&tgtfix, tgtlen);2602ws_fix_copy(&tgtfix, target, tgtlen, ws_rule, NULL);26032604/*2605 * If they match, either the preimage was based on2606 * a version before our tree fixed whitespace breakage,2607 * or we are lacking a whitespace-fix patch the tree2608 * the preimage was based on already had (i.e. target2609 * has whitespace breakage, the preimage doesn't).2610 * In either case, we are fixing the whitespace breakages2611 * so we might as well take the fix together with their2612 * real change.2613 */2614 match = (tgtfix.len == fixed.len - fixstart &&2615!memcmp(tgtfix.buf, fixed.buf + fixstart,2616 fixed.len - fixstart));26172618/* Add the length if this is common with the postimage */2619if(preimage->line[i].flag & LINE_COMMON)2620 postlen += tgtfix.len;26212622strbuf_release(&tgtfix);2623if(!match)2624goto unmatch_exit;26252626 orig += oldlen;2627 target += tgtlen;2628}262926302631/*2632 * Now handle the lines in the preimage that falls beyond the2633 * end of the file (if any). They will only match if they are2634 * empty or only contain whitespace (if WS_BLANK_AT_EOL is2635 * false).2636 */2637for( ; i < preimage->nr; i++) {2638size_t fixstart = fixed.len;/* start of the fixed preimage */2639size_t oldlen = preimage->line[i].len;2640int j;26412642/* Try fixing the line in the preimage */2643ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);26442645for(j = fixstart; j < fixed.len; j++)2646if(!isspace(fixed.buf[j]))2647goto unmatch_exit;26482649 orig += oldlen;2650}26512652/*2653 * Yes, the preimage is based on an older version that still2654 * has whitespace breakages unfixed, and fixing them makes the2655 * hunk match. Update the context lines in the postimage.2656 */2657 fixed_buf =strbuf_detach(&fixed, &fixed_len);2658if(postlen < postimage->len)2659 postlen =0;2660update_pre_post_images(preimage, postimage,2661 fixed_buf, fixed_len, postlen);2662return1;26632664 unmatch_exit:2665strbuf_release(&fixed);2666return0;2667}26682669static intfind_pos(struct apply_state *state,2670struct image *img,2671struct image *preimage,2672struct image *postimage,2673int line,2674unsigned ws_rule,2675int match_beginning,int match_end)2676{2677int i;2678unsigned long backwards, forwards,try;2679int backwards_lno, forwards_lno, try_lno;26802681/*2682 * If match_beginning or match_end is specified, there is no2683 * point starting from a wrong line that will never match and2684 * wander around and wait for a match at the specified end.2685 */2686if(match_beginning)2687 line =0;2688else if(match_end)2689 line = img->nr - preimage->nr;26902691/*2692 * Because the comparison is unsigned, the following test2693 * will also take care of a negative line number that can2694 * result when match_end and preimage is larger than the target.2695 */2696if((size_t) line > img->nr)2697 line = img->nr;26982699try=0;2700for(i =0; i < line; i++)2701try+= img->line[i].len;27022703/*2704 * There's probably some smart way to do this, but I'll leave2705 * that to the smart and beautiful people. I'm simple and stupid.2706 */2707 backwards =try;2708 backwards_lno = line;2709 forwards =try;2710 forwards_lno = line;2711 try_lno = line;27122713for(i =0; ; i++) {2714if(match_fragment(state, img, preimage, postimage,2715try, try_lno, ws_rule,2716 match_beginning, match_end))2717return try_lno;27182719 again:2720if(backwards_lno ==0&& forwards_lno == img->nr)2721break;27222723if(i &1) {2724if(backwards_lno ==0) {2725 i++;2726goto again;2727}2728 backwards_lno--;2729 backwards -= img->line[backwards_lno].len;2730try= backwards;2731 try_lno = backwards_lno;2732}else{2733if(forwards_lno == img->nr) {2734 i++;2735goto again;2736}2737 forwards += img->line[forwards_lno].len;2738 forwards_lno++;2739try= forwards;2740 try_lno = forwards_lno;2741}27422743}2744return-1;2745}27462747static voidremove_first_line(struct image *img)2748{2749 img->buf += img->line[0].len;2750 img->len -= img->line[0].len;2751 img->line++;2752 img->nr--;2753}27542755static voidremove_last_line(struct image *img)2756{2757 img->len -= img->line[--img->nr].len;2758}27592760/*2761 * The change from "preimage" and "postimage" has been found to2762 * apply at applied_pos (counts in line numbers) in "img".2763 * Update "img" to remove "preimage" and replace it with "postimage".2764 */2765static voidupdate_image(struct apply_state *state,2766struct image *img,2767int applied_pos,2768struct image *preimage,2769struct image *postimage)2770{2771/*2772 * remove the copy of preimage at offset in img2773 * and replace it with postimage2774 */2775int i, nr;2776size_t remove_count, insert_count, applied_at =0;2777char*result;2778int preimage_limit;27792780/*2781 * If we are removing blank lines at the end of img,2782 * the preimage may extend beyond the end.2783 * If that is the case, we must be careful only to2784 * remove the part of the preimage that falls within2785 * the boundaries of img. Initialize preimage_limit2786 * to the number of lines in the preimage that falls2787 * within the boundaries.2788 */2789 preimage_limit = preimage->nr;2790if(preimage_limit > img->nr - applied_pos)2791 preimage_limit = img->nr - applied_pos;27922793for(i =0; i < applied_pos; i++)2794 applied_at += img->line[i].len;27952796 remove_count =0;2797for(i =0; i < preimage_limit; i++)2798 remove_count += img->line[applied_pos + i].len;2799 insert_count = postimage->len;28002801/* Adjust the contents */2802 result =xmalloc(st_add3(st_sub(img->len, remove_count), insert_count,1));2803memcpy(result, img->buf, applied_at);2804memcpy(result + applied_at, postimage->buf, postimage->len);2805memcpy(result + applied_at + postimage->len,2806 img->buf + (applied_at + remove_count),2807 img->len - (applied_at + remove_count));2808free(img->buf);2809 img->buf = result;2810 img->len += insert_count - remove_count;2811 result[img->len] ='\0';28122813/* Adjust the line table */2814 nr = img->nr + postimage->nr - preimage_limit;2815if(preimage_limit < postimage->nr) {2816/*2817 * NOTE: this knows that we never call remove_first_line()2818 * on anything other than pre/post image.2819 */2820REALLOC_ARRAY(img->line, nr);2821 img->line_allocated = img->line;2822}2823if(preimage_limit != postimage->nr)2824memmove(img->line + applied_pos + postimage->nr,2825 img->line + applied_pos + preimage_limit,2826(img->nr - (applied_pos + preimage_limit)) *2827sizeof(*img->line));2828memcpy(img->line + applied_pos,2829 postimage->line,2830 postimage->nr *sizeof(*img->line));2831if(!state->allow_overlap)2832for(i =0; i < postimage->nr; i++)2833 img->line[applied_pos + i].flag |= LINE_PATCHED;2834 img->nr = nr;2835}28362837/*2838 * Use the patch-hunk text in "frag" to prepare two images (preimage and2839 * postimage) for the hunk. Find lines that match "preimage" in "img" and2840 * replace the part of "img" with "postimage" text.2841 */2842static intapply_one_fragment(struct apply_state *state,2843struct image *img,struct fragment *frag,2844int inaccurate_eof,unsigned ws_rule,2845int nth_fragment)2846{2847int match_beginning, match_end;2848const char*patch = frag->patch;2849int size = frag->size;2850char*old, *oldlines;2851struct strbuf newlines;2852int new_blank_lines_at_end =0;2853int found_new_blank_lines_at_end =0;2854int hunk_linenr = frag->linenr;2855unsigned long leading, trailing;2856int pos, applied_pos;2857struct image preimage;2858struct image postimage;28592860memset(&preimage,0,sizeof(preimage));2861memset(&postimage,0,sizeof(postimage));2862 oldlines =xmalloc(size);2863strbuf_init(&newlines, size);28642865 old = oldlines;2866while(size >0) {2867char first;2868int len =linelen(patch, size);2869int plen;2870int added_blank_line =0;2871int is_blank_context =0;2872size_t start;28732874if(!len)2875break;28762877/*2878 * "plen" is how much of the line we should use for2879 * the actual patch data. Normally we just remove the2880 * first character on the line, but if the line is2881 * followed by "\ No newline", then we also remove the2882 * last one (which is the newline, of course).2883 */2884 plen = len -1;2885if(len < size && patch[len] =='\\')2886 plen--;2887 first = *patch;2888if(state->apply_in_reverse) {2889if(first =='-')2890 first ='+';2891else if(first =='+')2892 first ='-';2893}28942895switch(first) {2896case'\n':2897/* Newer GNU diff, empty context line */2898if(plen <0)2899/* ... followed by '\No newline'; nothing */2900break;2901*old++ ='\n';2902strbuf_addch(&newlines,'\n');2903add_line_info(&preimage,"\n",1, LINE_COMMON);2904add_line_info(&postimage,"\n",1, LINE_COMMON);2905 is_blank_context =1;2906break;2907case' ':2908if(plen && (ws_rule & WS_BLANK_AT_EOF) &&2909ws_blank_line(patch +1, plen, ws_rule))2910 is_blank_context =1;2911case'-':2912memcpy(old, patch +1, plen);2913add_line_info(&preimage, old, plen,2914(first ==' '? LINE_COMMON :0));2915 old += plen;2916if(first =='-')2917break;2918/* Fall-through for ' ' */2919case'+':2920/* --no-add does not add new lines */2921if(first =='+'&& state->no_add)2922break;29232924 start = newlines.len;2925if(first !='+'||2926!state->whitespace_error ||2927 state->ws_error_action != correct_ws_error) {2928strbuf_add(&newlines, patch +1, plen);2929}2930else{2931ws_fix_copy(&newlines, patch +1, plen, ws_rule, &state->applied_after_fixing_ws);2932}2933add_line_info(&postimage, newlines.buf + start, newlines.len - start,2934(first =='+'?0: LINE_COMMON));2935if(first =='+'&&2936(ws_rule & WS_BLANK_AT_EOF) &&2937ws_blank_line(patch +1, plen, ws_rule))2938 added_blank_line =1;2939break;2940case'@':case'\\':2941/* Ignore it, we already handled it */2942break;2943default:2944if(state->apply_verbosity > verbosity_normal)2945error(_("invalid start of line: '%c'"), first);2946 applied_pos = -1;2947goto out;2948}2949if(added_blank_line) {2950if(!new_blank_lines_at_end)2951 found_new_blank_lines_at_end = hunk_linenr;2952 new_blank_lines_at_end++;2953}2954else if(is_blank_context)2955;2956else2957 new_blank_lines_at_end =0;2958 patch += len;2959 size -= len;2960 hunk_linenr++;2961}2962if(inaccurate_eof &&2963 old > oldlines && old[-1] =='\n'&&2964 newlines.len >0&& newlines.buf[newlines.len -1] =='\n') {2965 old--;2966strbuf_setlen(&newlines, newlines.len -1);2967}29682969 leading = frag->leading;2970 trailing = frag->trailing;29712972/*2973 * A hunk to change lines at the beginning would begin with2974 * @@ -1,L +N,M @@2975 * but we need to be careful. -U0 that inserts before the second2976 * line also has this pattern.2977 *2978 * And a hunk to add to an empty file would begin with2979 * @@ -0,0 +N,M @@2980 *2981 * In other words, a hunk that is (frag->oldpos <= 1) with or2982 * without leading context must match at the beginning.2983 */2984 match_beginning = (!frag->oldpos ||2985(frag->oldpos ==1&& !state->unidiff_zero));29862987/*2988 * A hunk without trailing lines must match at the end.2989 * However, we simply cannot tell if a hunk must match end2990 * from the lack of trailing lines if the patch was generated2991 * with unidiff without any context.2992 */2993 match_end = !state->unidiff_zero && !trailing;29942995 pos = frag->newpos ? (frag->newpos -1) :0;2996 preimage.buf = oldlines;2997 preimage.len = old - oldlines;2998 postimage.buf = newlines.buf;2999 postimage.len = newlines.len;3000 preimage.line = preimage.line_allocated;3001 postimage.line = postimage.line_allocated;30023003for(;;) {30043005 applied_pos =find_pos(state, img, &preimage, &postimage, pos,3006 ws_rule, match_beginning, match_end);30073008if(applied_pos >=0)3009break;30103011/* Am I at my context limits? */3012if((leading <= state->p_context) && (trailing <= state->p_context))3013break;3014if(match_beginning || match_end) {3015 match_beginning = match_end =0;3016continue;3017}30183019/*3020 * Reduce the number of context lines; reduce both3021 * leading and trailing if they are equal otherwise3022 * just reduce the larger context.3023 */3024if(leading >= trailing) {3025remove_first_line(&preimage);3026remove_first_line(&postimage);3027 pos--;3028 leading--;3029}3030if(trailing > leading) {3031remove_last_line(&preimage);3032remove_last_line(&postimage);3033 trailing--;3034}3035}30363037if(applied_pos >=0) {3038if(new_blank_lines_at_end &&3039 preimage.nr + applied_pos >= img->nr &&3040(ws_rule & WS_BLANK_AT_EOF) &&3041 state->ws_error_action != nowarn_ws_error) {3042record_ws_error(state, WS_BLANK_AT_EOF,"+",1,3043 found_new_blank_lines_at_end);3044if(state->ws_error_action == correct_ws_error) {3045while(new_blank_lines_at_end--)3046remove_last_line(&postimage);3047}3048/*3049 * We would want to prevent write_out_results()3050 * from taking place in apply_patch() that follows3051 * the callchain led us here, which is:3052 * apply_patch->check_patch_list->check_patch->3053 * apply_data->apply_fragments->apply_one_fragment3054 */3055if(state->ws_error_action == die_on_ws_error)3056 state->apply =0;3057}30583059if(state->apply_verbosity > verbosity_normal && applied_pos != pos) {3060int offset = applied_pos - pos;3061if(state->apply_in_reverse)3062 offset =0- offset;3063fprintf_ln(stderr,3064Q_("Hunk #%dsucceeded at%d(offset%dline).",3065"Hunk #%dsucceeded at%d(offset%dlines).",3066 offset),3067 nth_fragment, applied_pos +1, offset);3068}30693070/*3071 * Warn if it was necessary to reduce the number3072 * of context lines.3073 */3074if((leading != frag->leading ||3075 trailing != frag->trailing) && state->apply_verbosity > verbosity_silent)3076fprintf_ln(stderr,_("Context reduced to (%ld/%ld)"3077" to apply fragment at%d"),3078 leading, trailing, applied_pos+1);3079update_image(state, img, applied_pos, &preimage, &postimage);3080}else{3081if(state->apply_verbosity > verbosity_normal)3082error(_("while searching for:\n%.*s"),3083(int)(old - oldlines), oldlines);3084}30853086out:3087free(oldlines);3088strbuf_release(&newlines);3089free(preimage.line_allocated);3090free(postimage.line_allocated);30913092return(applied_pos <0);3093}30943095static intapply_binary_fragment(struct apply_state *state,3096struct image *img,3097struct patch *patch)3098{3099struct fragment *fragment = patch->fragments;3100unsigned long len;3101void*dst;31023103if(!fragment)3104returnerror(_("missing binary patch data for '%s'"),3105 patch->new_name ?3106 patch->new_name :3107 patch->old_name);31083109/* Binary patch is irreversible without the optional second hunk */3110if(state->apply_in_reverse) {3111if(!fragment->next)3112returnerror(_("cannot reverse-apply a binary patch "3113"without the reverse hunk to '%s'"),3114 patch->new_name3115? patch->new_name : patch->old_name);3116 fragment = fragment->next;3117}3118switch(fragment->binary_patch_method) {3119case BINARY_DELTA_DEFLATED:3120 dst =patch_delta(img->buf, img->len, fragment->patch,3121 fragment->size, &len);3122if(!dst)3123return-1;3124clear_image(img);3125 img->buf = dst;3126 img->len = len;3127return0;3128case BINARY_LITERAL_DEFLATED:3129clear_image(img);3130 img->len = fragment->size;3131 img->buf =xmemdupz(fragment->patch, img->len);3132return0;3133}3134return-1;3135}31363137/*3138 * Replace "img" with the result of applying the binary patch.3139 * The binary patch data itself in patch->fragment is still kept3140 * but the preimage prepared by the caller in "img" is freed here3141 * or in the helper function apply_binary_fragment() this calls.3142 */3143static intapply_binary(struct apply_state *state,3144struct image *img,3145struct patch *patch)3146{3147const char*name = patch->old_name ? patch->old_name : patch->new_name;3148struct object_id oid;31493150/*3151 * For safety, we require patch index line to contain3152 * full 40-byte textual SHA1 for old and new, at least for now.3153 */3154if(strlen(patch->old_sha1_prefix) !=40||3155strlen(patch->new_sha1_prefix) !=40||3156get_oid_hex(patch->old_sha1_prefix, &oid) ||3157get_oid_hex(patch->new_sha1_prefix, &oid))3158returnerror(_("cannot apply binary patch to '%s' "3159"without full index line"), name);31603161if(patch->old_name) {3162/*3163 * See if the old one matches what the patch3164 * applies to.3165 */3166hash_sha1_file(img->buf, img->len, blob_type, oid.hash);3167if(strcmp(oid_to_hex(&oid), patch->old_sha1_prefix))3168returnerror(_("the patch applies to '%s' (%s), "3169"which does not match the "3170"current contents."),3171 name,oid_to_hex(&oid));3172}3173else{3174/* Otherwise, the old one must be empty. */3175if(img->len)3176returnerror(_("the patch applies to an empty "3177"'%s' but it is not empty"), name);3178}31793180get_oid_hex(patch->new_sha1_prefix, &oid);3181if(is_null_oid(&oid)) {3182clear_image(img);3183return0;/* deletion patch */3184}31853186if(has_sha1_file(oid.hash)) {3187/* We already have the postimage */3188enum object_type type;3189unsigned long size;3190char*result;31913192 result =read_sha1_file(oid.hash, &type, &size);3193if(!result)3194returnerror(_("the necessary postimage%sfor "3195"'%s' cannot be read"),3196 patch->new_sha1_prefix, name);3197clear_image(img);3198 img->buf = result;3199 img->len = size;3200}else{3201/*3202 * We have verified buf matches the preimage;3203 * apply the patch data to it, which is stored3204 * in the patch->fragments->{patch,size}.3205 */3206if(apply_binary_fragment(state, img, patch))3207returnerror(_("binary patch does not apply to '%s'"),3208 name);32093210/* verify that the result matches */3211hash_sha1_file(img->buf, img->len, blob_type, oid.hash);3212if(strcmp(oid_to_hex(&oid), patch->new_sha1_prefix))3213returnerror(_("binary patch to '%s' creates incorrect result (expecting%s, got%s)"),3214 name, patch->new_sha1_prefix,oid_to_hex(&oid));3215}32163217return0;3218}32193220static intapply_fragments(struct apply_state *state,struct image *img,struct patch *patch)3221{3222struct fragment *frag = patch->fragments;3223const char*name = patch->old_name ? patch->old_name : patch->new_name;3224unsigned ws_rule = patch->ws_rule;3225unsigned inaccurate_eof = patch->inaccurate_eof;3226int nth =0;32273228if(patch->is_binary)3229returnapply_binary(state, img, patch);32303231while(frag) {3232 nth++;3233if(apply_one_fragment(state, img, frag, inaccurate_eof, ws_rule, nth)) {3234error(_("patch failed:%s:%ld"), name, frag->oldpos);3235if(!state->apply_with_reject)3236return-1;3237 frag->rejected =1;3238}3239 frag = frag->next;3240}3241return0;3242}32433244static intread_blob_object(struct strbuf *buf,const struct object_id *oid,unsigned mode)3245{3246if(S_ISGITLINK(mode)) {3247strbuf_grow(buf,100);3248strbuf_addf(buf,"Subproject commit%s\n",oid_to_hex(oid));3249}else{3250enum object_type type;3251unsigned long sz;3252char*result;32533254 result =read_sha1_file(oid->hash, &type, &sz);3255if(!result)3256return-1;3257/* XXX read_sha1_file NUL-terminates */3258strbuf_attach(buf, result, sz, sz +1);3259}3260return0;3261}32623263static intread_file_or_gitlink(const struct cache_entry *ce,struct strbuf *buf)3264{3265if(!ce)3266return0;3267returnread_blob_object(buf, &ce->oid, ce->ce_mode);3268}32693270static struct patch *in_fn_table(struct apply_state *state,const char*name)3271{3272struct string_list_item *item;32733274if(name == NULL)3275return NULL;32763277 item =string_list_lookup(&state->fn_table, name);3278if(item != NULL)3279return(struct patch *)item->util;32803281return NULL;3282}32833284/*3285 * item->util in the filename table records the status of the path.3286 * Usually it points at a patch (whose result records the contents3287 * of it after applying it), but it could be PATH_WAS_DELETED for a3288 * path that a previously applied patch has already removed, or3289 * PATH_TO_BE_DELETED for a path that a later patch would remove.3290 *3291 * The latter is needed to deal with a case where two paths A and B3292 * are swapped by first renaming A to B and then renaming B to A;3293 * moving A to B should not be prevented due to presence of B as we3294 * will remove it in a later patch.3295 */3296#define PATH_TO_BE_DELETED ((struct patch *) -2)3297#define PATH_WAS_DELETED ((struct patch *) -1)32983299static intto_be_deleted(struct patch *patch)3300{3301return patch == PATH_TO_BE_DELETED;3302}33033304static intwas_deleted(struct patch *patch)3305{3306return patch == PATH_WAS_DELETED;3307}33083309static voidadd_to_fn_table(struct apply_state *state,struct patch *patch)3310{3311struct string_list_item *item;33123313/*3314 * Always add new_name unless patch is a deletion3315 * This should cover the cases for normal diffs,3316 * file creations and copies3317 */3318if(patch->new_name != NULL) {3319 item =string_list_insert(&state->fn_table, patch->new_name);3320 item->util = patch;3321}33223323/*3324 * store a failure on rename/deletion cases because3325 * later chunks shouldn't patch old names3326 */3327if((patch->new_name == NULL) || (patch->is_rename)) {3328 item =string_list_insert(&state->fn_table, patch->old_name);3329 item->util = PATH_WAS_DELETED;3330}3331}33323333static voidprepare_fn_table(struct apply_state *state,struct patch *patch)3334{3335/*3336 * store information about incoming file deletion3337 */3338while(patch) {3339if((patch->new_name == NULL) || (patch->is_rename)) {3340struct string_list_item *item;3341 item =string_list_insert(&state->fn_table, patch->old_name);3342 item->util = PATH_TO_BE_DELETED;3343}3344 patch = patch->next;3345}3346}33473348static intcheckout_target(struct index_state *istate,3349struct cache_entry *ce,struct stat *st)3350{3351struct checkout costate = CHECKOUT_INIT;33523353 costate.refresh_cache =1;3354 costate.istate = istate;3355if(checkout_entry(ce, &costate, NULL) ||lstat(ce->name, st))3356returnerror(_("cannot checkout%s"), ce->name);3357return0;3358}33593360static struct patch *previous_patch(struct apply_state *state,3361struct patch *patch,3362int*gone)3363{3364struct patch *previous;33653366*gone =0;3367if(patch->is_copy || patch->is_rename)3368return NULL;/* "git" patches do not depend on the order */33693370 previous =in_fn_table(state, patch->old_name);3371if(!previous)3372return NULL;33733374if(to_be_deleted(previous))3375return NULL;/* the deletion hasn't happened yet */33763377if(was_deleted(previous))3378*gone =1;33793380return previous;3381}33823383static intverify_index_match(const struct cache_entry *ce,struct stat *st)3384{3385if(S_ISGITLINK(ce->ce_mode)) {3386if(!S_ISDIR(st->st_mode))3387return-1;3388return0;3389}3390returnce_match_stat(ce, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);3391}33923393#define SUBMODULE_PATCH_WITHOUT_INDEX 133943395static intload_patch_target(struct apply_state *state,3396struct strbuf *buf,3397const struct cache_entry *ce,3398struct stat *st,3399const char*name,3400unsigned expected_mode)3401{3402if(state->cached || state->check_index) {3403if(read_file_or_gitlink(ce, buf))3404returnerror(_("failed to read%s"), name);3405}else if(name) {3406if(S_ISGITLINK(expected_mode)) {3407if(ce)3408returnread_file_or_gitlink(ce, buf);3409else3410return SUBMODULE_PATCH_WITHOUT_INDEX;3411}else if(has_symlink_leading_path(name,strlen(name))) {3412returnerror(_("reading from '%s' beyond a symbolic link"), name);3413}else{3414if(read_old_data(st, name, buf))3415returnerror(_("failed to read%s"), name);3416}3417}3418return0;3419}34203421/*3422 * We are about to apply "patch"; populate the "image" with the3423 * current version we have, from the working tree or from the index,3424 * depending on the situation e.g. --cached/--index. If we are3425 * applying a non-git patch that incrementally updates the tree,3426 * we read from the result of a previous diff.3427 */3428static intload_preimage(struct apply_state *state,3429struct image *image,3430struct patch *patch,struct stat *st,3431const struct cache_entry *ce)3432{3433struct strbuf buf = STRBUF_INIT;3434size_t len;3435char*img;3436struct patch *previous;3437int status;34383439 previous =previous_patch(state, patch, &status);3440if(status)3441returnerror(_("path%shas been renamed/deleted"),3442 patch->old_name);3443if(previous) {3444/* We have a patched copy in memory; use that. */3445strbuf_add(&buf, previous->result, previous->resultsize);3446}else{3447 status =load_patch_target(state, &buf, ce, st,3448 patch->old_name, patch->old_mode);3449if(status <0)3450return status;3451else if(status == SUBMODULE_PATCH_WITHOUT_INDEX) {3452/*3453 * There is no way to apply subproject3454 * patch without looking at the index.3455 * NEEDSWORK: shouldn't this be flagged3456 * as an error???3457 */3458free_fragment_list(patch->fragments);3459 patch->fragments = NULL;3460}else if(status) {3461returnerror(_("failed to read%s"), patch->old_name);3462}3463}34643465 img =strbuf_detach(&buf, &len);3466prepare_image(image, img, len, !patch->is_binary);3467return0;3468}34693470static intthree_way_merge(struct image *image,3471char*path,3472const struct object_id *base,3473const struct object_id *ours,3474const struct object_id *theirs)3475{3476 mmfile_t base_file, our_file, their_file;3477 mmbuffer_t result = { NULL };3478int status;34793480read_mmblob(&base_file, base);3481read_mmblob(&our_file, ours);3482read_mmblob(&their_file, theirs);3483 status =ll_merge(&result, path,3484&base_file,"base",3485&our_file,"ours",3486&their_file,"theirs", NULL);3487free(base_file.ptr);3488free(our_file.ptr);3489free(their_file.ptr);3490if(status <0|| !result.ptr) {3491free(result.ptr);3492return-1;3493}3494clear_image(image);3495 image->buf = result.ptr;3496 image->len = result.size;34973498return status;3499}35003501/*3502 * When directly falling back to add/add three-way merge, we read from3503 * the current contents of the new_name. In no cases other than that3504 * this function will be called.3505 */3506static intload_current(struct apply_state *state,3507struct image *image,3508struct patch *patch)3509{3510struct strbuf buf = STRBUF_INIT;3511int status, pos;3512size_t len;3513char*img;3514struct stat st;3515struct cache_entry *ce;3516char*name = patch->new_name;3517unsigned mode = patch->new_mode;35183519if(!patch->is_new)3520die("BUG: patch to%sis not a creation", patch->old_name);35213522 pos =cache_name_pos(name,strlen(name));3523if(pos <0)3524returnerror(_("%s: does not exist in index"), name);3525 ce = active_cache[pos];3526if(lstat(name, &st)) {3527if(errno != ENOENT)3528returnerror_errno("%s", name);3529if(checkout_target(&the_index, ce, &st))3530return-1;3531}3532if(verify_index_match(ce, &st))3533returnerror(_("%s: does not match index"), name);35343535 status =load_patch_target(state, &buf, ce, &st, name, mode);3536if(status <0)3537return status;3538else if(status)3539return-1;3540 img =strbuf_detach(&buf, &len);3541prepare_image(image, img, len, !patch->is_binary);3542return0;3543}35443545static inttry_threeway(struct apply_state *state,3546struct image *image,3547struct patch *patch,3548struct stat *st,3549const struct cache_entry *ce)3550{3551struct object_id pre_oid, post_oid, our_oid;3552struct strbuf buf = STRBUF_INIT;3553size_t len;3554int status;3555char*img;3556struct image tmp_image;35573558/* No point falling back to 3-way merge in these cases */3559if(patch->is_delete ||3560S_ISGITLINK(patch->old_mode) ||S_ISGITLINK(patch->new_mode))3561return-1;35623563/* Preimage the patch was prepared for */3564if(patch->is_new)3565write_sha1_file("",0, blob_type, pre_oid.hash);3566else if(get_sha1(patch->old_sha1_prefix, pre_oid.hash) ||3567read_blob_object(&buf, &pre_oid, patch->old_mode))3568returnerror(_("repository lacks the necessary blob to fall back on 3-way merge."));35693570if(state->apply_verbosity > verbosity_silent)3571fprintf(stderr,_("Falling back to three-way merge...\n"));35723573 img =strbuf_detach(&buf, &len);3574prepare_image(&tmp_image, img, len,1);3575/* Apply the patch to get the post image */3576if(apply_fragments(state, &tmp_image, patch) <0) {3577clear_image(&tmp_image);3578return-1;3579}3580/* post_oid is theirs */3581write_sha1_file(tmp_image.buf, tmp_image.len, blob_type, post_oid.hash);3582clear_image(&tmp_image);35833584/* our_oid is ours */3585if(patch->is_new) {3586if(load_current(state, &tmp_image, patch))3587returnerror(_("cannot read the current contents of '%s'"),3588 patch->new_name);3589}else{3590if(load_preimage(state, &tmp_image, patch, st, ce))3591returnerror(_("cannot read the current contents of '%s'"),3592 patch->old_name);3593}3594write_sha1_file(tmp_image.buf, tmp_image.len, blob_type, our_oid.hash);3595clear_image(&tmp_image);35963597/* in-core three-way merge between post and our using pre as base */3598 status =three_way_merge(image, patch->new_name,3599&pre_oid, &our_oid, &post_oid);3600if(status <0) {3601if(state->apply_verbosity > verbosity_silent)3602fprintf(stderr,3603_("Failed to fall back on three-way merge...\n"));3604return status;3605}36063607if(status) {3608 patch->conflicted_threeway =1;3609if(patch->is_new)3610oidclr(&patch->threeway_stage[0]);3611else3612oidcpy(&patch->threeway_stage[0], &pre_oid);3613oidcpy(&patch->threeway_stage[1], &our_oid);3614oidcpy(&patch->threeway_stage[2], &post_oid);3615if(state->apply_verbosity > verbosity_silent)3616fprintf(stderr,3617_("Applied patch to '%s' with conflicts.\n"),3618 patch->new_name);3619}else{3620if(state->apply_verbosity > verbosity_silent)3621fprintf(stderr,3622_("Applied patch to '%s' cleanly.\n"),3623 patch->new_name);3624}3625return0;3626}36273628static intapply_data(struct apply_state *state,struct patch *patch,3629struct stat *st,const struct cache_entry *ce)3630{3631struct image image;36323633if(load_preimage(state, &image, patch, st, ce) <0)3634return-1;36353636if(patch->direct_to_threeway ||3637apply_fragments(state, &image, patch) <0) {3638/* Note: with --reject, apply_fragments() returns 0 */3639if(!state->threeway ||try_threeway(state, &image, patch, st, ce) <0)3640return-1;3641}3642 patch->result = image.buf;3643 patch->resultsize = image.len;3644add_to_fn_table(state, patch);3645free(image.line_allocated);36463647if(0< patch->is_delete && patch->resultsize)3648returnerror(_("removal patch leaves file contents"));36493650return0;3651}36523653/*3654 * If "patch" that we are looking at modifies or deletes what we have,3655 * we would want it not to lose any local modification we have, either3656 * in the working tree or in the index.3657 *3658 * This also decides if a non-git patch is a creation patch or a3659 * modification to an existing empty file. We do not check the state3660 * of the current tree for a creation patch in this function; the caller3661 * check_patch() separately makes sure (and errors out otherwise) that3662 * the path the patch creates does not exist in the current tree.3663 */3664static intcheck_preimage(struct apply_state *state,3665struct patch *patch,3666struct cache_entry **ce,3667struct stat *st)3668{3669const char*old_name = patch->old_name;3670struct patch *previous = NULL;3671int stat_ret =0, status;3672unsigned st_mode =0;36733674if(!old_name)3675return0;36763677assert(patch->is_new <=0);3678 previous =previous_patch(state, patch, &status);36793680if(status)3681returnerror(_("path%shas been renamed/deleted"), old_name);3682if(previous) {3683 st_mode = previous->new_mode;3684}else if(!state->cached) {3685 stat_ret =lstat(old_name, st);3686if(stat_ret && errno != ENOENT)3687returnerror_errno("%s", old_name);3688}36893690if(state->check_index && !previous) {3691int pos =cache_name_pos(old_name,strlen(old_name));3692if(pos <0) {3693if(patch->is_new <0)3694goto is_new;3695returnerror(_("%s: does not exist in index"), old_name);3696}3697*ce = active_cache[pos];3698if(stat_ret <0) {3699if(checkout_target(&the_index, *ce, st))3700return-1;3701}3702if(!state->cached &&verify_index_match(*ce, st))3703returnerror(_("%s: does not match index"), old_name);3704if(state->cached)3705 st_mode = (*ce)->ce_mode;3706}else if(stat_ret <0) {3707if(patch->is_new <0)3708goto is_new;3709returnerror_errno("%s", old_name);3710}37113712if(!state->cached && !previous)3713 st_mode =ce_mode_from_stat(*ce, st->st_mode);37143715if(patch->is_new <0)3716 patch->is_new =0;3717if(!patch->old_mode)3718 patch->old_mode = st_mode;3719if((st_mode ^ patch->old_mode) & S_IFMT)3720returnerror(_("%s: wrong type"), old_name);3721if(st_mode != patch->old_mode)3722warning(_("%shas type%o, expected%o"),3723 old_name, st_mode, patch->old_mode);3724if(!patch->new_mode && !patch->is_delete)3725 patch->new_mode = st_mode;3726return0;37273728 is_new:3729 patch->is_new =1;3730 patch->is_delete =0;3731free(patch->old_name);3732 patch->old_name = NULL;3733return0;3734}373537363737#define EXISTS_IN_INDEX 13738#define EXISTS_IN_WORKTREE 237393740static intcheck_to_create(struct apply_state *state,3741const char*new_name,3742int ok_if_exists)3743{3744struct stat nst;37453746if(state->check_index &&3747cache_name_pos(new_name,strlen(new_name)) >=0&&3748!ok_if_exists)3749return EXISTS_IN_INDEX;3750if(state->cached)3751return0;37523753if(!lstat(new_name, &nst)) {3754if(S_ISDIR(nst.st_mode) || ok_if_exists)3755return0;3756/*3757 * A leading component of new_name might be a symlink3758 * that is going to be removed with this patch, but3759 * still pointing at somewhere that has the path.3760 * In such a case, path "new_name" does not exist as3761 * far as git is concerned.3762 */3763if(has_symlink_leading_path(new_name,strlen(new_name)))3764return0;37653766return EXISTS_IN_WORKTREE;3767}else if((errno != ENOENT) && (errno != ENOTDIR)) {3768returnerror_errno("%s", new_name);3769}3770return0;3771}37723773static uintptr_tregister_symlink_changes(struct apply_state *state,3774const char*path,3775uintptr_t what)3776{3777struct string_list_item *ent;37783779 ent =string_list_lookup(&state->symlink_changes, path);3780if(!ent) {3781 ent =string_list_insert(&state->symlink_changes, path);3782 ent->util = (void*)0;3783}3784 ent->util = (void*)(what | ((uintptr_t)ent->util));3785return(uintptr_t)ent->util;3786}37873788static uintptr_tcheck_symlink_changes(struct apply_state *state,const char*path)3789{3790struct string_list_item *ent;37913792 ent =string_list_lookup(&state->symlink_changes, path);3793if(!ent)3794return0;3795return(uintptr_t)ent->util;3796}37973798static voidprepare_symlink_changes(struct apply_state *state,struct patch *patch)3799{3800for( ; patch; patch = patch->next) {3801if((patch->old_name &&S_ISLNK(patch->old_mode)) &&3802(patch->is_rename || patch->is_delete))3803/* the symlink at patch->old_name is removed */3804register_symlink_changes(state, patch->old_name, APPLY_SYMLINK_GOES_AWAY);38053806if(patch->new_name &&S_ISLNK(patch->new_mode))3807/* the symlink at patch->new_name is created or remains */3808register_symlink_changes(state, patch->new_name, APPLY_SYMLINK_IN_RESULT);3809}3810}38113812static intpath_is_beyond_symlink_1(struct apply_state *state,struct strbuf *name)3813{3814do{3815unsigned int change;38163817while(--name->len && name->buf[name->len] !='/')3818;/* scan backwards */3819if(!name->len)3820break;3821 name->buf[name->len] ='\0';3822 change =check_symlink_changes(state, name->buf);3823if(change & APPLY_SYMLINK_IN_RESULT)3824return1;3825if(change & APPLY_SYMLINK_GOES_AWAY)3826/*3827 * This cannot be "return 0", because we may3828 * see a new one created at a higher level.3829 */3830continue;38313832/* otherwise, check the preimage */3833if(state->check_index) {3834struct cache_entry *ce;38353836 ce =cache_file_exists(name->buf, name->len, ignore_case);3837if(ce &&S_ISLNK(ce->ce_mode))3838return1;3839}else{3840struct stat st;3841if(!lstat(name->buf, &st) &&S_ISLNK(st.st_mode))3842return1;3843}3844}while(1);3845return0;3846}38473848static intpath_is_beyond_symlink(struct apply_state *state,const char*name_)3849{3850int ret;3851struct strbuf name = STRBUF_INIT;38523853assert(*name_ !='\0');3854strbuf_addstr(&name, name_);3855 ret =path_is_beyond_symlink_1(state, &name);3856strbuf_release(&name);38573858return ret;3859}38603861static intcheck_unsafe_path(struct patch *patch)3862{3863const char*old_name = NULL;3864const char*new_name = NULL;3865if(patch->is_delete)3866 old_name = patch->old_name;3867else if(!patch->is_new && !patch->is_copy)3868 old_name = patch->old_name;3869if(!patch->is_delete)3870 new_name = patch->new_name;38713872if(old_name && !verify_path(old_name))3873returnerror(_("invalid path '%s'"), old_name);3874if(new_name && !verify_path(new_name))3875returnerror(_("invalid path '%s'"), new_name);3876return0;3877}38783879/*3880 * Check and apply the patch in-core; leave the result in patch->result3881 * for the caller to write it out to the final destination.3882 */3883static intcheck_patch(struct apply_state *state,struct patch *patch)3884{3885struct stat st;3886const char*old_name = patch->old_name;3887const char*new_name = patch->new_name;3888const char*name = old_name ? old_name : new_name;3889struct cache_entry *ce = NULL;3890struct patch *tpatch;3891int ok_if_exists;3892int status;38933894 patch->rejected =1;/* we will drop this after we succeed */38953896 status =check_preimage(state, patch, &ce, &st);3897if(status)3898return status;3899 old_name = patch->old_name;39003901/*3902 * A type-change diff is always split into a patch to delete3903 * old, immediately followed by a patch to create new (see3904 * diff.c::run_diff()); in such a case it is Ok that the entry3905 * to be deleted by the previous patch is still in the working3906 * tree and in the index.3907 *3908 * A patch to swap-rename between A and B would first rename A3909 * to B and then rename B to A. While applying the first one,3910 * the presence of B should not stop A from getting renamed to3911 * B; ask to_be_deleted() about the later rename. Removal of3912 * B and rename from A to B is handled the same way by asking3913 * was_deleted().3914 */3915if((tpatch =in_fn_table(state, new_name)) &&3916(was_deleted(tpatch) ||to_be_deleted(tpatch)))3917 ok_if_exists =1;3918else3919 ok_if_exists =0;39203921if(new_name &&3922((0< patch->is_new) || patch->is_rename || patch->is_copy)) {3923int err =check_to_create(state, new_name, ok_if_exists);39243925if(err && state->threeway) {3926 patch->direct_to_threeway =1;3927}else switch(err) {3928case0:3929break;/* happy */3930case EXISTS_IN_INDEX:3931returnerror(_("%s: already exists in index"), new_name);3932break;3933case EXISTS_IN_WORKTREE:3934returnerror(_("%s: already exists in working directory"),3935 new_name);3936default:3937return err;3938}39393940if(!patch->new_mode) {3941if(0< patch->is_new)3942 patch->new_mode = S_IFREG |0644;3943else3944 patch->new_mode = patch->old_mode;3945}3946}39473948if(new_name && old_name) {3949int same = !strcmp(old_name, new_name);3950if(!patch->new_mode)3951 patch->new_mode = patch->old_mode;3952if((patch->old_mode ^ patch->new_mode) & S_IFMT) {3953if(same)3954returnerror(_("new mode (%o) of%sdoes not "3955"match old mode (%o)"),3956 patch->new_mode, new_name,3957 patch->old_mode);3958else3959returnerror(_("new mode (%o) of%sdoes not "3960"match old mode (%o) of%s"),3961 patch->new_mode, new_name,3962 patch->old_mode, old_name);3963}3964}39653966if(!state->unsafe_paths &&check_unsafe_path(patch))3967return-128;39683969/*3970 * An attempt to read from or delete a path that is beyond a3971 * symbolic link will be prevented by load_patch_target() that3972 * is called at the beginning of apply_data() so we do not3973 * have to worry about a patch marked with "is_delete" bit3974 * here. We however need to make sure that the patch result3975 * is not deposited to a path that is beyond a symbolic link3976 * here.3977 */3978if(!patch->is_delete &&path_is_beyond_symlink(state, patch->new_name))3979returnerror(_("affected file '%s' is beyond a symbolic link"),3980 patch->new_name);39813982if(apply_data(state, patch, &st, ce) <0)3983returnerror(_("%s: patch does not apply"), name);3984 patch->rejected =0;3985return0;3986}39873988static intcheck_patch_list(struct apply_state *state,struct patch *patch)3989{3990int err =0;39913992prepare_symlink_changes(state, patch);3993prepare_fn_table(state, patch);3994while(patch) {3995int res;3996if(state->apply_verbosity > verbosity_normal)3997say_patch_name(stderr,3998_("Checking patch%s..."), patch);3999 res =check_patch(state, patch);4000if(res == -128)4001return-128;4002 err |= res;4003 patch = patch->next;4004}4005return err;4006}40074008static intread_apply_cache(struct apply_state *state)4009{4010if(state->index_file)4011returnread_cache_from(state->index_file);4012else4013returnread_cache();4014}40154016/* This function tries to read the object name from the current index */4017static intget_current_oid(struct apply_state *state,const char*path,4018struct object_id *oid)4019{4020int pos;40214022if(read_apply_cache(state) <0)4023return-1;4024 pos =cache_name_pos(path,strlen(path));4025if(pos <0)4026return-1;4027oidcpy(oid, &active_cache[pos]->oid);4028return0;4029}40304031static intpreimage_oid_in_gitlink_patch(struct patch *p,struct object_id *oid)4032{4033/*4034 * A usable gitlink patch has only one fragment (hunk) that looks like:4035 * @@ -1 +1 @@4036 * -Subproject commit <old sha1>4037 * +Subproject commit <new sha1>4038 * or4039 * @@ -1 +0,0 @@4040 * -Subproject commit <old sha1>4041 * for a removal patch.4042 */4043struct fragment *hunk = p->fragments;4044static const char heading[] ="-Subproject commit ";4045char*preimage;40464047if(/* does the patch have only one hunk? */4048 hunk && !hunk->next &&4049/* is its preimage one line? */4050 hunk->oldpos ==1&& hunk->oldlines ==1&&4051/* does preimage begin with the heading? */4052(preimage =memchr(hunk->patch,'\n', hunk->size)) != NULL &&4053starts_with(++preimage, heading) &&4054/* does it record full SHA-1? */4055!get_oid_hex(preimage +sizeof(heading) -1, oid) &&4056 preimage[sizeof(heading) + GIT_SHA1_HEXSZ -1] =='\n'&&4057/* does the abbreviated name on the index line agree with it? */4058starts_with(preimage +sizeof(heading) -1, p->old_sha1_prefix))4059return0;/* it all looks fine */40604061/* we may have full object name on the index line */4062returnget_oid_hex(p->old_sha1_prefix, oid);4063}40644065/* Build an index that contains the just the files needed for a 3way merge */4066static intbuild_fake_ancestor(struct apply_state *state,struct patch *list)4067{4068struct patch *patch;4069struct index_state result = { NULL };4070static struct lock_file lock;4071int res;40724073/* Once we start supporting the reverse patch, it may be4074 * worth showing the new sha1 prefix, but until then...4075 */4076for(patch = list; patch; patch = patch->next) {4077struct object_id oid;4078struct cache_entry *ce;4079const char*name;40804081 name = patch->old_name ? patch->old_name : patch->new_name;4082if(0< patch->is_new)4083continue;40844085if(S_ISGITLINK(patch->old_mode)) {4086if(!preimage_oid_in_gitlink_patch(patch, &oid))4087;/* ok, the textual part looks sane */4088else4089returnerror(_("sha1 information is lacking or "4090"useless for submodule%s"), name);4091}else if(!get_sha1_blob(patch->old_sha1_prefix, oid.hash)) {4092;/* ok */4093}else if(!patch->lines_added && !patch->lines_deleted) {4094/* mode-only change: update the current */4095if(get_current_oid(state, patch->old_name, &oid))4096returnerror(_("mode change for%s, which is not "4097"in current HEAD"), name);4098}else4099returnerror(_("sha1 information is lacking or useless "4100"(%s)."), name);41014102 ce =make_cache_entry(patch->old_mode, oid.hash, name,0,0);4103if(!ce)4104returnerror(_("make_cache_entry failed for path '%s'"),4105 name);4106if(add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD)) {4107free(ce);4108returnerror(_("could not add%sto temporary index"),4109 name);4110}4111}41124113hold_lock_file_for_update(&lock, state->fake_ancestor, LOCK_DIE_ON_ERROR);4114 res =write_locked_index(&result, &lock, COMMIT_LOCK);4115discard_index(&result);41164117if(res)4118returnerror(_("could not write temporary index to%s"),4119 state->fake_ancestor);41204121return0;4122}41234124static voidstat_patch_list(struct apply_state *state,struct patch *patch)4125{4126int files, adds, dels;41274128for(files = adds = dels =0; patch ; patch = patch->next) {4129 files++;4130 adds += patch->lines_added;4131 dels += patch->lines_deleted;4132show_stats(state, patch);4133}41344135print_stat_summary(stdout, files, adds, dels);4136}41374138static voidnumstat_patch_list(struct apply_state *state,4139struct patch *patch)4140{4141for( ; patch; patch = patch->next) {4142const char*name;4143 name = patch->new_name ? patch->new_name : patch->old_name;4144if(patch->is_binary)4145printf("-\t-\t");4146else4147printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);4148write_name_quoted(name, stdout, state->line_termination);4149}4150}41514152static voidshow_file_mode_name(const char*newdelete,unsigned int mode,const char*name)4153{4154if(mode)4155printf("%smode%06o%s\n", newdelete, mode, name);4156else4157printf("%s %s\n", newdelete, name);4158}41594160static voidshow_mode_change(struct patch *p,int show_name)4161{4162if(p->old_mode && p->new_mode && p->old_mode != p->new_mode) {4163if(show_name)4164printf(" mode change%06o =>%06o%s\n",4165 p->old_mode, p->new_mode, p->new_name);4166else4167printf(" mode change%06o =>%06o\n",4168 p->old_mode, p->new_mode);4169}4170}41714172static voidshow_rename_copy(struct patch *p)4173{4174const char*renamecopy = p->is_rename ?"rename":"copy";4175const char*old, *new;41764177/* Find common prefix */4178 old = p->old_name;4179new= p->new_name;4180while(1) {4181const char*slash_old, *slash_new;4182 slash_old =strchr(old,'/');4183 slash_new =strchr(new,'/');4184if(!slash_old ||4185!slash_new ||4186 slash_old - old != slash_new -new||4187memcmp(old,new, slash_new -new))4188break;4189 old = slash_old +1;4190new= slash_new +1;4191}4192/* p->old_name thru old is the common prefix, and old and new4193 * through the end of names are renames4194 */4195if(old != p->old_name)4196printf("%s%.*s{%s=>%s} (%d%%)\n", renamecopy,4197(int)(old - p->old_name), p->old_name,4198 old,new, p->score);4199else4200printf("%s %s=>%s(%d%%)\n", renamecopy,4201 p->old_name, p->new_name, p->score);4202show_mode_change(p,0);4203}42044205static voidsummary_patch_list(struct patch *patch)4206{4207struct patch *p;42084209for(p = patch; p; p = p->next) {4210if(p->is_new)4211show_file_mode_name("create", p->new_mode, p->new_name);4212else if(p->is_delete)4213show_file_mode_name("delete", p->old_mode, p->old_name);4214else{4215if(p->is_rename || p->is_copy)4216show_rename_copy(p);4217else{4218if(p->score) {4219printf(" rewrite%s(%d%%)\n",4220 p->new_name, p->score);4221show_mode_change(p,0);4222}4223else4224show_mode_change(p,1);4225}4226}4227}4228}42294230static voidpatch_stats(struct apply_state *state,struct patch *patch)4231{4232int lines = patch->lines_added + patch->lines_deleted;42334234if(lines > state->max_change)4235 state->max_change = lines;4236if(patch->old_name) {4237int len =quote_c_style(patch->old_name, NULL, NULL,0);4238if(!len)4239 len =strlen(patch->old_name);4240if(len > state->max_len)4241 state->max_len = len;4242}4243if(patch->new_name) {4244int len =quote_c_style(patch->new_name, NULL, NULL,0);4245if(!len)4246 len =strlen(patch->new_name);4247if(len > state->max_len)4248 state->max_len = len;4249}4250}42514252static intremove_file(struct apply_state *state,struct patch *patch,int rmdir_empty)4253{4254if(state->update_index) {4255if(remove_file_from_cache(patch->old_name) <0)4256returnerror(_("unable to remove%sfrom index"), patch->old_name);4257}4258if(!state->cached) {4259if(!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) {4260remove_path(patch->old_name);4261}4262}4263return0;4264}42654266static intadd_index_file(struct apply_state *state,4267const char*path,4268unsigned mode,4269void*buf,4270unsigned long size)4271{4272struct stat st;4273struct cache_entry *ce;4274int namelen =strlen(path);4275unsigned ce_size =cache_entry_size(namelen);42764277if(!state->update_index)4278return0;42794280 ce =xcalloc(1, ce_size);4281memcpy(ce->name, path, namelen);4282 ce->ce_mode =create_ce_mode(mode);4283 ce->ce_flags =create_ce_flags(0);4284 ce->ce_namelen = namelen;4285if(S_ISGITLINK(mode)) {4286const char*s;42874288if(!skip_prefix(buf,"Subproject commit ", &s) ||4289get_oid_hex(s, &ce->oid)) {4290free(ce);4291returnerror(_("corrupt patch for submodule%s"), path);4292}4293}else{4294if(!state->cached) {4295if(lstat(path, &st) <0) {4296free(ce);4297returnerror_errno(_("unable to stat newly "4298"created file '%s'"),4299 path);4300}4301fill_stat_cache_info(ce, &st);4302}4303if(write_sha1_file(buf, size, blob_type, ce->oid.hash) <0) {4304free(ce);4305returnerror(_("unable to create backing store "4306"for newly created file%s"), path);4307}4308}4309if(add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) <0) {4310free(ce);4311returnerror(_("unable to add cache entry for%s"), path);4312}43134314return0;4315}43164317/*4318 * Returns:4319 * -1 if an unrecoverable error happened4320 * 0 if everything went well4321 * 1 if a recoverable error happened4322 */4323static inttry_create_file(const char*path,unsigned int mode,const char*buf,unsigned long size)4324{4325int fd, res;4326struct strbuf nbuf = STRBUF_INIT;43274328if(S_ISGITLINK(mode)) {4329struct stat st;4330if(!lstat(path, &st) &&S_ISDIR(st.st_mode))4331return0;4332return!!mkdir(path,0777);4333}43344335if(has_symlinks &&S_ISLNK(mode))4336/* Although buf:size is counted string, it also is NUL4337 * terminated.4338 */4339return!!symlink(buf, path);43404341 fd =open(path, O_CREAT | O_EXCL | O_WRONLY, (mode &0100) ?0777:0666);4342if(fd <0)4343return1;43444345if(convert_to_working_tree(path, buf, size, &nbuf)) {4346 size = nbuf.len;4347 buf = nbuf.buf;4348}43494350 res =write_in_full(fd, buf, size) <0;4351if(res)4352error_errno(_("failed to write to '%s'"), path);4353strbuf_release(&nbuf);43544355if(close(fd) <0&& !res)4356returnerror_errno(_("closing file '%s'"), path);43574358return res ? -1:0;4359}43604361/*4362 * We optimistically assume that the directories exist,4363 * which is true 99% of the time anyway. If they don't,4364 * we create them and try again.4365 *4366 * Returns:4367 * -1 on error4368 * 0 otherwise4369 */4370static intcreate_one_file(struct apply_state *state,4371char*path,4372unsigned mode,4373const char*buf,4374unsigned long size)4375{4376int res;43774378if(state->cached)4379return0;43804381 res =try_create_file(path, mode, buf, size);4382if(res <0)4383return-1;4384if(!res)4385return0;43864387if(errno == ENOENT) {4388if(safe_create_leading_directories(path))4389return0;4390 res =try_create_file(path, mode, buf, size);4391if(res <0)4392return-1;4393if(!res)4394return0;4395}43964397if(errno == EEXIST || errno == EACCES) {4398/* We may be trying to create a file where a directory4399 * used to be.4400 */4401struct stat st;4402if(!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))4403 errno = EEXIST;4404}44054406if(errno == EEXIST) {4407unsigned int nr =getpid();44084409for(;;) {4410char newpath[PATH_MAX];4411mksnpath(newpath,sizeof(newpath),"%s~%u", path, nr);4412 res =try_create_file(newpath, mode, buf, size);4413if(res <0)4414return-1;4415if(!res) {4416if(!rename(newpath, path))4417return0;4418unlink_or_warn(newpath);4419break;4420}4421if(errno != EEXIST)4422break;4423++nr;4424}4425}4426returnerror_errno(_("unable to write file '%s' mode%o"),4427 path, mode);4428}44294430static intadd_conflicted_stages_file(struct apply_state *state,4431struct patch *patch)4432{4433int stage, namelen;4434unsigned ce_size, mode;4435struct cache_entry *ce;44364437if(!state->update_index)4438return0;4439 namelen =strlen(patch->new_name);4440 ce_size =cache_entry_size(namelen);4441 mode = patch->new_mode ? patch->new_mode : (S_IFREG |0644);44424443remove_file_from_cache(patch->new_name);4444for(stage =1; stage <4; stage++) {4445if(is_null_oid(&patch->threeway_stage[stage -1]))4446continue;4447 ce =xcalloc(1, ce_size);4448memcpy(ce->name, patch->new_name, namelen);4449 ce->ce_mode =create_ce_mode(mode);4450 ce->ce_flags =create_ce_flags(stage);4451 ce->ce_namelen = namelen;4452oidcpy(&ce->oid, &patch->threeway_stage[stage -1]);4453if(add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) <0) {4454free(ce);4455returnerror(_("unable to add cache entry for%s"),4456 patch->new_name);4457}4458}44594460return0;4461}44624463static intcreate_file(struct apply_state *state,struct patch *patch)4464{4465char*path = patch->new_name;4466unsigned mode = patch->new_mode;4467unsigned long size = patch->resultsize;4468char*buf = patch->result;44694470if(!mode)4471 mode = S_IFREG |0644;4472if(create_one_file(state, path, mode, buf, size))4473return-1;44744475if(patch->conflicted_threeway)4476returnadd_conflicted_stages_file(state, patch);4477else4478returnadd_index_file(state, path, mode, buf, size);4479}44804481/* phase zero is to remove, phase one is to create */4482static intwrite_out_one_result(struct apply_state *state,4483struct patch *patch,4484int phase)4485{4486if(patch->is_delete >0) {4487if(phase ==0)4488returnremove_file(state, patch,1);4489return0;4490}4491if(patch->is_new >0|| patch->is_copy) {4492if(phase ==1)4493returncreate_file(state, patch);4494return0;4495}4496/*4497 * Rename or modification boils down to the same4498 * thing: remove the old, write the new4499 */4500if(phase ==0)4501returnremove_file(state, patch, patch->is_rename);4502if(phase ==1)4503returncreate_file(state, patch);4504return0;4505}45064507static intwrite_out_one_reject(struct apply_state *state,struct patch *patch)4508{4509FILE*rej;4510char namebuf[PATH_MAX];4511struct fragment *frag;4512int cnt =0;4513struct strbuf sb = STRBUF_INIT;45144515for(cnt =0, frag = patch->fragments; frag; frag = frag->next) {4516if(!frag->rejected)4517continue;4518 cnt++;4519}45204521if(!cnt) {4522if(state->apply_verbosity > verbosity_normal)4523say_patch_name(stderr,4524_("Applied patch%scleanly."), patch);4525return0;4526}45274528/* This should not happen, because a removal patch that leaves4529 * contents are marked "rejected" at the patch level.4530 */4531if(!patch->new_name)4532die(_("internal error"));45334534/* Say this even without --verbose */4535strbuf_addf(&sb,Q_("Applying patch %%swith%dreject...",4536"Applying patch %%swith%drejects...",4537 cnt),4538 cnt);4539if(state->apply_verbosity > verbosity_silent)4540say_patch_name(stderr, sb.buf, patch);4541strbuf_release(&sb);45424543 cnt =strlen(patch->new_name);4544if(ARRAY_SIZE(namebuf) <= cnt +5) {4545 cnt =ARRAY_SIZE(namebuf) -5;4546warning(_("truncating .rej filename to %.*s.rej"),4547 cnt -1, patch->new_name);4548}4549memcpy(namebuf, patch->new_name, cnt);4550memcpy(namebuf + cnt,".rej",5);45514552 rej =fopen(namebuf,"w");4553if(!rej)4554returnerror_errno(_("cannot open%s"), namebuf);45554556/* Normal git tools never deal with .rej, so do not pretend4557 * this is a git patch by saying --git or giving extended4558 * headers. While at it, maybe please "kompare" that wants4559 * the trailing TAB and some garbage at the end of line ;-).4560 */4561fprintf(rej,"diff a/%sb/%s\t(rejected hunks)\n",4562 patch->new_name, patch->new_name);4563for(cnt =1, frag = patch->fragments;4564 frag;4565 cnt++, frag = frag->next) {4566if(!frag->rejected) {4567if(state->apply_verbosity > verbosity_silent)4568fprintf_ln(stderr,_("Hunk #%dapplied cleanly."), cnt);4569continue;4570}4571if(state->apply_verbosity > verbosity_silent)4572fprintf_ln(stderr,_("Rejected hunk #%d."), cnt);4573fprintf(rej,"%.*s", frag->size, frag->patch);4574if(frag->patch[frag->size-1] !='\n')4575fputc('\n', rej);4576}4577fclose(rej);4578return-1;4579}45804581/*4582 * Returns:4583 * -1 if an error happened4584 * 0 if the patch applied cleanly4585 * 1 if the patch did not apply cleanly4586 */4587static intwrite_out_results(struct apply_state *state,struct patch *list)4588{4589int phase;4590int errs =0;4591struct patch *l;4592struct string_list cpath = STRING_LIST_INIT_DUP;45934594for(phase =0; phase <2; phase++) {4595 l = list;4596while(l) {4597if(l->rejected)4598 errs =1;4599else{4600if(write_out_one_result(state, l, phase)) {4601string_list_clear(&cpath,0);4602return-1;4603}4604if(phase ==1) {4605if(write_out_one_reject(state, l))4606 errs =1;4607if(l->conflicted_threeway) {4608string_list_append(&cpath, l->new_name);4609 errs =1;4610}4611}4612}4613 l = l->next;4614}4615}46164617if(cpath.nr) {4618struct string_list_item *item;46194620string_list_sort(&cpath);4621if(state->apply_verbosity > verbosity_silent) {4622for_each_string_list_item(item, &cpath)4623fprintf(stderr,"U%s\n", item->string);4624}4625string_list_clear(&cpath,0);46264627rerere(0);4628}46294630return errs;4631}46324633/*4634 * Try to apply a patch.4635 *4636 * Returns:4637 * -128 if a bad error happened (like patch unreadable)4638 * -1 if patch did not apply and user cannot deal with it4639 * 0 if the patch applied4640 * 1 if the patch did not apply but user might fix it4641 */4642static intapply_patch(struct apply_state *state,4643int fd,4644const char*filename,4645int options)4646{4647size_t offset;4648struct strbuf buf = STRBUF_INIT;/* owns the patch text */4649struct patch *list = NULL, **listp = &list;4650int skipped_patch =0;4651int res =0;46524653 state->patch_input_file = filename;4654if(read_patch_file(&buf, fd) <0)4655return-128;4656 offset =0;4657while(offset < buf.len) {4658struct patch *patch;4659int nr;46604661 patch =xcalloc(1,sizeof(*patch));4662 patch->inaccurate_eof = !!(options & APPLY_OPT_INACCURATE_EOF);4663 patch->recount = !!(options & APPLY_OPT_RECOUNT);4664 nr =parse_chunk(state, buf.buf + offset, buf.len - offset, patch);4665if(nr <0) {4666free_patch(patch);4667if(nr == -128) {4668 res = -128;4669goto end;4670}4671break;4672}4673if(state->apply_in_reverse)4674reverse_patches(patch);4675if(use_patch(state, patch)) {4676patch_stats(state, patch);4677*listp = patch;4678 listp = &patch->next;4679}4680else{4681if(state->apply_verbosity > verbosity_normal)4682say_patch_name(stderr,_("Skipped patch '%s'."), patch);4683free_patch(patch);4684 skipped_patch++;4685}4686 offset += nr;4687}46884689if(!list && !skipped_patch) {4690error(_("unrecognized input"));4691 res = -128;4692goto end;4693}46944695if(state->whitespace_error && (state->ws_error_action == die_on_ws_error))4696 state->apply =0;46974698 state->update_index = state->check_index && state->apply;4699if(state->update_index && state->newfd <0) {4700if(state->index_file)4701 state->newfd =hold_lock_file_for_update(state->lock_file,4702 state->index_file,4703 LOCK_DIE_ON_ERROR);4704else4705 state->newfd =hold_locked_index(state->lock_file, LOCK_DIE_ON_ERROR);4706}47074708if(state->check_index &&read_apply_cache(state) <0) {4709error(_("unable to read index file"));4710 res = -128;4711goto end;4712}47134714if(state->check || state->apply) {4715int r =check_patch_list(state, list);4716if(r == -128) {4717 res = -128;4718goto end;4719}4720if(r <0&& !state->apply_with_reject) {4721 res = -1;4722goto end;4723}4724}47254726if(state->apply) {4727int write_res =write_out_results(state, list);4728if(write_res <0) {4729 res = -128;4730goto end;4731}4732if(write_res >0) {4733/* with --3way, we still need to write the index out */4734 res = state->apply_with_reject ? -1:1;4735goto end;4736}4737}47384739if(state->fake_ancestor &&4740build_fake_ancestor(state, list)) {4741 res = -128;4742goto end;4743}47444745if(state->diffstat && state->apply_verbosity > verbosity_silent)4746stat_patch_list(state, list);47474748if(state->numstat && state->apply_verbosity > verbosity_silent)4749numstat_patch_list(state, list);47504751if(state->summary && state->apply_verbosity > verbosity_silent)4752summary_patch_list(list);47534754end:4755free_patch_list(list);4756strbuf_release(&buf);4757string_list_clear(&state->fn_table,0);4758return res;4759}47604761static intapply_option_parse_exclude(const struct option *opt,4762const char*arg,int unset)4763{4764struct apply_state *state = opt->value;4765add_name_limit(state, arg,1);4766return0;4767}47684769static intapply_option_parse_include(const struct option *opt,4770const char*arg,int unset)4771{4772struct apply_state *state = opt->value;4773add_name_limit(state, arg,0);4774 state->has_include =1;4775return0;4776}47774778static intapply_option_parse_p(const struct option *opt,4779const char*arg,4780int unset)4781{4782struct apply_state *state = opt->value;4783 state->p_value =atoi(arg);4784 state->p_value_known =1;4785return0;4786}47874788static intapply_option_parse_space_change(const struct option *opt,4789const char*arg,int unset)4790{4791struct apply_state *state = opt->value;4792if(unset)4793 state->ws_ignore_action = ignore_ws_none;4794else4795 state->ws_ignore_action = ignore_ws_change;4796return0;4797}47984799static intapply_option_parse_whitespace(const struct option *opt,4800const char*arg,int unset)4801{4802struct apply_state *state = opt->value;4803 state->whitespace_option = arg;4804if(parse_whitespace_option(state, arg))4805exit(1);4806return0;4807}48084809static intapply_option_parse_directory(const struct option *opt,4810const char*arg,int unset)4811{4812struct apply_state *state = opt->value;4813strbuf_reset(&state->root);4814strbuf_addstr(&state->root, arg);4815strbuf_complete(&state->root,'/');4816return0;4817}48184819intapply_all_patches(struct apply_state *state,4820int argc,4821const char**argv,4822int options)4823{4824int i;4825int res;4826int errs =0;4827int read_stdin =1;48284829for(i =0; i < argc; i++) {4830const char*arg = argv[i];4831char*to_free = NULL;4832int fd;48334834if(!strcmp(arg,"-")) {4835 res =apply_patch(state,0,"<stdin>", options);4836if(res <0)4837goto end;4838 errs |= res;4839 read_stdin =0;4840continue;4841}else4842 arg = to_free =prefix_filename(state->prefix, arg);48434844 fd =open(arg, O_RDONLY);4845if(fd <0) {4846error(_("can't open patch '%s':%s"), arg,strerror(errno));4847 res = -128;4848free(to_free);4849goto end;4850}4851 read_stdin =0;4852set_default_whitespace_mode(state);4853 res =apply_patch(state, fd, arg, options);4854close(fd);4855free(to_free);4856if(res <0)4857goto end;4858 errs |= res;4859}4860set_default_whitespace_mode(state);4861if(read_stdin) {4862 res =apply_patch(state,0,"<stdin>", options);4863if(res <0)4864goto end;4865 errs |= res;4866}48674868if(state->whitespace_error) {4869if(state->squelch_whitespace_errors &&4870 state->squelch_whitespace_errors < state->whitespace_error) {4871int squelched =4872 state->whitespace_error - state->squelch_whitespace_errors;4873warning(Q_("squelched%dwhitespace error",4874"squelched%dwhitespace errors",4875 squelched),4876 squelched);4877}4878if(state->ws_error_action == die_on_ws_error) {4879error(Q_("%dline adds whitespace errors.",4880"%dlines add whitespace errors.",4881 state->whitespace_error),4882 state->whitespace_error);4883 res = -128;4884goto end;4885}4886if(state->applied_after_fixing_ws && state->apply)4887warning(Q_("%dline applied after"4888" fixing whitespace errors.",4889"%dlines applied after"4890" fixing whitespace errors.",4891 state->applied_after_fixing_ws),4892 state->applied_after_fixing_ws);4893else if(state->whitespace_error)4894warning(Q_("%dline adds whitespace errors.",4895"%dlines add whitespace errors.",4896 state->whitespace_error),4897 state->whitespace_error);4898}48994900if(state->update_index) {4901 res =write_locked_index(&the_index, state->lock_file, COMMIT_LOCK);4902if(res) {4903error(_("Unable to write new index file"));4904 res = -128;4905goto end;4906}4907 state->newfd = -1;4908}49094910 res = !!errs;49114912end:4913if(state->newfd >=0) {4914rollback_lock_file(state->lock_file);4915 state->newfd = -1;4916}49174918if(state->apply_verbosity <= verbosity_silent) {4919set_error_routine(state->saved_error_routine);4920set_warn_routine(state->saved_warn_routine);4921}49224923if(res > -1)4924return res;4925return(res == -1?1:128);4926}49274928intapply_parse_options(int argc,const char**argv,4929struct apply_state *state,4930int*force_apply,int*options,4931const char*const*apply_usage)4932{4933struct option builtin_apply_options[] = {4934{ OPTION_CALLBACK,0,"exclude", state,N_("path"),4935N_("don't apply changes matching the given path"),49360, apply_option_parse_exclude },4937{ OPTION_CALLBACK,0,"include", state,N_("path"),4938N_("apply changes matching the given path"),49390, apply_option_parse_include },4940{ OPTION_CALLBACK,'p', NULL, state,N_("num"),4941N_("remove <num> leading slashes from traditional diff paths"),49420, apply_option_parse_p },4943OPT_BOOL(0,"no-add", &state->no_add,4944N_("ignore additions made by the patch")),4945OPT_BOOL(0,"stat", &state->diffstat,4946N_("instead of applying the patch, output diffstat for the input")),4947OPT_NOOP_NOARG(0,"allow-binary-replacement"),4948OPT_NOOP_NOARG(0,"binary"),4949OPT_BOOL(0,"numstat", &state->numstat,4950N_("show number of added and deleted lines in decimal notation")),4951OPT_BOOL(0,"summary", &state->summary,4952N_("instead of applying the patch, output a summary for the input")),4953OPT_BOOL(0,"check", &state->check,4954N_("instead of applying the patch, see if the patch is applicable")),4955OPT_BOOL(0,"index", &state->check_index,4956N_("make sure the patch is applicable to the current index")),4957OPT_BOOL(0,"cached", &state->cached,4958N_("apply a patch without touching the working tree")),4959OPT_BOOL(0,"unsafe-paths", &state->unsafe_paths,4960N_("accept a patch that touches outside the working area")),4961OPT_BOOL(0,"apply", force_apply,4962N_("also apply the patch (use with --stat/--summary/--check)")),4963OPT_BOOL('3',"3way", &state->threeway,4964N_("attempt three-way merge if a patch does not apply")),4965OPT_FILENAME(0,"build-fake-ancestor", &state->fake_ancestor,4966N_("build a temporary index based on embedded index information")),4967/* Think twice before adding "--nul" synonym to this */4968OPT_SET_INT('z', NULL, &state->line_termination,4969N_("paths are separated with NUL character"),'\0'),4970OPT_INTEGER('C', NULL, &state->p_context,4971N_("ensure at least <n> lines of context match")),4972{ OPTION_CALLBACK,0,"whitespace", state,N_("action"),4973N_("detect new or modified lines that have whitespace errors"),49740, apply_option_parse_whitespace },4975{ OPTION_CALLBACK,0,"ignore-space-change", state, NULL,4976N_("ignore changes in whitespace when finding context"),4977 PARSE_OPT_NOARG, apply_option_parse_space_change },4978{ OPTION_CALLBACK,0,"ignore-whitespace", state, NULL,4979N_("ignore changes in whitespace when finding context"),4980 PARSE_OPT_NOARG, apply_option_parse_space_change },4981OPT_BOOL('R',"reverse", &state->apply_in_reverse,4982N_("apply the patch in reverse")),4983OPT_BOOL(0,"unidiff-zero", &state->unidiff_zero,4984N_("don't expect at least one line of context")),4985OPT_BOOL(0,"reject", &state->apply_with_reject,4986N_("leave the rejected hunks in corresponding *.rej files")),4987OPT_BOOL(0,"allow-overlap", &state->allow_overlap,4988N_("allow overlapping hunks")),4989OPT__VERBOSE(&state->apply_verbosity,N_("be verbose")),4990OPT_BIT(0,"inaccurate-eof", options,4991N_("tolerate incorrectly detected missing new-line at the end of file"),4992 APPLY_OPT_INACCURATE_EOF),4993OPT_BIT(0,"recount", options,4994N_("do not trust the line counts in the hunk headers"),4995 APPLY_OPT_RECOUNT),4996{ OPTION_CALLBACK,0,"directory", state,N_("root"),4997N_("prepend <root> to all filenames"),49980, apply_option_parse_directory },4999OPT_END()5000};50015002returnparse_options(argc, argv, state->prefix, builtin_apply_options, apply_usage,0);5003}