1/* 2 * apply.c 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 * 6 * This applies patches on top of some (arbitrary) version of the SCM. 7 * 8 */ 9#include "cache.h" 10#include "lockfile.h" 11#include "cache-tree.h" 12#include "quote.h" 13#include "blob.h" 14#include "delta.h" 15#include "builtin.h" 16#include "string-list.h" 17#include "dir.h" 18#include "diff.h" 19#include "parse-options.h" 20#include "xdiff-interface.h" 21#include "ll-merge.h" 22#include "rerere.h" 23 24enum ws_error_action { 25 nowarn_ws_error, 26 warn_on_ws_error, 27 die_on_ws_error, 28 correct_ws_error 29}; 30 31 32enum ws_ignore { 33 ignore_ws_none, 34 ignore_ws_change 35}; 36 37struct apply_state { 38 const char *prefix; 39 int prefix_length; 40 41 /* These control what gets looked at and modified */ 42 int apply; /* this is not a dry-run */ 43 int cached; /* apply to the index only */ 44 int check; /* preimage must match working tree, don't actually apply */ 45 int check_index; /* preimage must match the indexed version */ 46 int update_index; /* check_index && apply */ 47 48 /* These control cosmetic aspect of the output */ 49 int diffstat; /* just show a diffstat, and don't actually apply */ 50 int numstat; /* just show a numeric diffstat, and don't actually apply */ 51 int summary; /* just report creation, deletion, etc, and don't actually apply */ 52 53 /* These boolean parameters control how the apply is done */ 54 int allow_overlap; 55 int apply_in_reverse; 56 int apply_with_reject; 57 int apply_verbosely; 58 int no_add; 59 int threeway; 60 int unidiff_zero; 61 int unsafe_paths; 62 63 /* Other non boolean parameters */ 64 const char *fake_ancestor; 65 const char *patch_input_file; 66 int line_termination; 67 struct strbuf root; 68 int p_value; 69 int p_value_known; 70 unsigned int p_context; 71 72 /* Exclude and include path parameters */ 73 struct string_list limit_by_name; 74 int has_include; 75 76 /* Various "current state" */ 77 int linenr; /* current line number */ 78 79 /* 80 * For "diff-stat" like behaviour, we keep track of the biggest change 81 * we've seen, and the longest filename. That allows us to do simple 82 * scaling. 83 */ 84 int max_change; 85 int max_len; 86 87 /* These control whitespace errors */ 88 enum ws_error_action ws_error_action; 89 enum ws_ignore ws_ignore_action; 90 const char *whitespace_option; 91 int whitespace_error; 92 int squelch_whitespace_errors; 93 int applied_after_fixing_ws; 94}; 95 96static int newfd = -1; 97 98static const char * const apply_usage[] = { 99 N_("git apply [<options>] [<patch>...]"), 100 NULL 101}; 102 103static void parse_whitespace_option(struct apply_state *state, const char *option) 104{ 105 if (!option) { 106 state->ws_error_action = warn_on_ws_error; 107 return; 108 } 109 if (!strcmp(option, "warn")) { 110 state->ws_error_action = warn_on_ws_error; 111 return; 112 } 113 if (!strcmp(option, "nowarn")) { 114 state->ws_error_action = nowarn_ws_error; 115 return; 116 } 117 if (!strcmp(option, "error")) { 118 state->ws_error_action = die_on_ws_error; 119 return; 120 } 121 if (!strcmp(option, "error-all")) { 122 state->ws_error_action = die_on_ws_error; 123 state->squelch_whitespace_errors = 0; 124 return; 125 } 126 if (!strcmp(option, "strip") || !strcmp(option, "fix")) { 127 state->ws_error_action = correct_ws_error; 128 return; 129 } 130 die(_("unrecognized whitespace option '%s'"), option); 131} 132 133static void parse_ignorewhitespace_option(struct apply_state *state, 134 const char *option) 135{ 136 if (!option || !strcmp(option, "no") || 137 !strcmp(option, "false") || !strcmp(option, "never") || 138 !strcmp(option, "none")) { 139 state->ws_ignore_action = ignore_ws_none; 140 return; 141 } 142 if (!strcmp(option, "change")) { 143 state->ws_ignore_action = ignore_ws_change; 144 return; 145 } 146 die(_("unrecognized whitespace ignore option '%s'"), option); 147} 148 149static void set_default_whitespace_mode(struct apply_state *state) 150{ 151 if (!state->whitespace_option && !apply_default_whitespace) 152 state->ws_error_action = (state->apply ? warn_on_ws_error : nowarn_ws_error); 153} 154 155/* 156 * This represents one "hunk" from a patch, starting with 157 * "@@ -oldpos,oldlines +newpos,newlines @@" marker. The 158 * patch text is pointed at by patch, and its byte length 159 * is stored in size. leading and trailing are the number 160 * of context lines. 161 */ 162struct fragment { 163 unsigned long leading, trailing; 164 unsigned long oldpos, oldlines; 165 unsigned long newpos, newlines; 166 /* 167 * 'patch' is usually borrowed from buf in apply_patch(), 168 * but some codepaths store an allocated buffer. 169 */ 170 const char *patch; 171 unsigned free_patch:1, 172 rejected:1; 173 int size; 174 int linenr; 175 struct fragment *next; 176}; 177 178/* 179 * When dealing with a binary patch, we reuse "leading" field 180 * to store the type of the binary hunk, either deflated "delta" 181 * or deflated "literal". 182 */ 183#define binary_patch_method leading 184#define BINARY_DELTA_DEFLATED 1 185#define BINARY_LITERAL_DEFLATED 2 186 187/* 188 * This represents a "patch" to a file, both metainfo changes 189 * such as creation/deletion, filemode and content changes represented 190 * as a series of fragments. 191 */ 192struct patch { 193 char *new_name, *old_name, *def_name; 194 unsigned int old_mode, new_mode; 195 int is_new, is_delete; /* -1 = unknown, 0 = false, 1 = true */ 196 int rejected; 197 unsigned ws_rule; 198 int lines_added, lines_deleted; 199 int score; 200 unsigned int is_toplevel_relative:1; 201 unsigned int inaccurate_eof:1; 202 unsigned int is_binary:1; 203 unsigned int is_copy:1; 204 unsigned int is_rename:1; 205 unsigned int recount:1; 206 unsigned int conflicted_threeway:1; 207 unsigned int direct_to_threeway:1; 208 struct fragment *fragments; 209 char *result; 210 size_t resultsize; 211 char old_sha1_prefix[41]; 212 char new_sha1_prefix[41]; 213 struct patch *next; 214 215 /* three-way fallback result */ 216 struct object_id threeway_stage[3]; 217}; 218 219static void free_fragment_list(struct fragment *list) 220{ 221 while (list) { 222 struct fragment *next = list->next; 223 if (list->free_patch) 224 free((char *)list->patch); 225 free(list); 226 list = next; 227 } 228} 229 230static void free_patch(struct patch *patch) 231{ 232 free_fragment_list(patch->fragments); 233 free(patch->def_name); 234 free(patch->old_name); 235 free(patch->new_name); 236 free(patch->result); 237 free(patch); 238} 239 240static void free_patch_list(struct patch *list) 241{ 242 while (list) { 243 struct patch *next = list->next; 244 free_patch(list); 245 list = next; 246 } 247} 248 249/* 250 * A line in a file, len-bytes long (includes the terminating LF, 251 * except for an incomplete line at the end if the file ends with 252 * one), and its contents hashes to 'hash'. 253 */ 254struct line { 255 size_t len; 256 unsigned hash : 24; 257 unsigned flag : 8; 258#define LINE_COMMON 1 259#define LINE_PATCHED 2 260}; 261 262/* 263 * This represents a "file", which is an array of "lines". 264 */ 265struct image { 266 char *buf; 267 size_t len; 268 size_t nr; 269 size_t alloc; 270 struct line *line_allocated; 271 struct line *line; 272}; 273 274/* 275 * Records filenames that have been touched, in order to handle 276 * the case where more than one patches touch the same file. 277 */ 278 279static struct string_list fn_table; 280 281static uint32_t hash_line(const char *cp, size_t len) 282{ 283 size_t i; 284 uint32_t h; 285 for (i = 0, h = 0; i < len; i++) { 286 if (!isspace(cp[i])) { 287 h = h * 3 + (cp[i] & 0xff); 288 } 289 } 290 return h; 291} 292 293/* 294 * Compare lines s1 of length n1 and s2 of length n2, ignoring 295 * whitespace difference. Returns 1 if they match, 0 otherwise 296 */ 297static int fuzzy_matchlines(const char *s1, size_t n1, 298 const char *s2, size_t n2) 299{ 300 const char *last1 = s1 + n1 - 1; 301 const char *last2 = s2 + n2 - 1; 302 int result = 0; 303 304 /* ignore line endings */ 305 while ((*last1 == '\r') || (*last1 == '\n')) 306 last1--; 307 while ((*last2 == '\r') || (*last2 == '\n')) 308 last2--; 309 310 /* skip leading whitespaces, if both begin with whitespace */ 311 if (s1 <= last1 && s2 <= last2 && isspace(*s1) && isspace(*s2)) { 312 while (isspace(*s1) && (s1 <= last1)) 313 s1++; 314 while (isspace(*s2) && (s2 <= last2)) 315 s2++; 316 } 317 /* early return if both lines are empty */ 318 if ((s1 > last1) && (s2 > last2)) 319 return 1; 320 while (!result) { 321 result = *s1++ - *s2++; 322 /* 323 * Skip whitespace inside. We check for whitespace on 324 * both buffers because we don't want "a b" to match 325 * "ab" 326 */ 327 if (isspace(*s1) && isspace(*s2)) { 328 while (isspace(*s1) && s1 <= last1) 329 s1++; 330 while (isspace(*s2) && s2 <= last2) 331 s2++; 332 } 333 /* 334 * If we reached the end on one side only, 335 * lines don't match 336 */ 337 if ( 338 ((s2 > last2) && (s1 <= last1)) || 339 ((s1 > last1) && (s2 <= last2))) 340 return 0; 341 if ((s1 > last1) && (s2 > last2)) 342 break; 343 } 344 345 return !result; 346} 347 348static void add_line_info(struct image *img, const char *bol, size_t len, unsigned flag) 349{ 350 ALLOC_GROW(img->line_allocated, img->nr + 1, img->alloc); 351 img->line_allocated[img->nr].len = len; 352 img->line_allocated[img->nr].hash = hash_line(bol, len); 353 img->line_allocated[img->nr].flag = flag; 354 img->nr++; 355} 356 357/* 358 * "buf" has the file contents to be patched (read from various sources). 359 * attach it to "image" and add line-based index to it. 360 * "image" now owns the "buf". 361 */ 362static void prepare_image(struct image *image, char *buf, size_t len, 363 int prepare_linetable) 364{ 365 const char *cp, *ep; 366 367 memset(image, 0, sizeof(*image)); 368 image->buf = buf; 369 image->len = len; 370 371 if (!prepare_linetable) 372 return; 373 374 ep = image->buf + image->len; 375 cp = image->buf; 376 while (cp < ep) { 377 const char *next; 378 for (next = cp; next < ep && *next != '\n'; next++) 379 ; 380 if (next < ep) 381 next++; 382 add_line_info(image, cp, next - cp, 0); 383 cp = next; 384 } 385 image->line = image->line_allocated; 386} 387 388static void clear_image(struct image *image) 389{ 390 free(image->buf); 391 free(image->line_allocated); 392 memset(image, 0, sizeof(*image)); 393} 394 395/* fmt must contain _one_ %s and no other substitution */ 396static void say_patch_name(FILE *output, const char *fmt, struct patch *patch) 397{ 398 struct strbuf sb = STRBUF_INIT; 399 400 if (patch->old_name && patch->new_name && 401 strcmp(patch->old_name, patch->new_name)) { 402 quote_c_style(patch->old_name, &sb, NULL, 0); 403 strbuf_addstr(&sb, " => "); 404 quote_c_style(patch->new_name, &sb, NULL, 0); 405 } else { 406 const char *n = patch->new_name; 407 if (!n) 408 n = patch->old_name; 409 quote_c_style(n, &sb, NULL, 0); 410 } 411 fprintf(output, fmt, sb.buf); 412 fputc('\n', output); 413 strbuf_release(&sb); 414} 415 416#define SLOP (16) 417 418static void read_patch_file(struct strbuf *sb, int fd) 419{ 420 if (strbuf_read(sb, fd, 0) < 0) 421 die_errno("git apply: failed to read"); 422 423 /* 424 * Make sure that we have some slop in the buffer 425 * so that we can do speculative "memcmp" etc, and 426 * see to it that it is NUL-filled. 427 */ 428 strbuf_grow(sb, SLOP); 429 memset(sb->buf + sb->len, 0, SLOP); 430} 431 432static unsigned long linelen(const char *buffer, unsigned long size) 433{ 434 unsigned long len = 0; 435 while (size--) { 436 len++; 437 if (*buffer++ == '\n') 438 break; 439 } 440 return len; 441} 442 443static int is_dev_null(const char *str) 444{ 445 return skip_prefix(str, "/dev/null", &str) && isspace(*str); 446} 447 448#define TERM_SPACE 1 449#define TERM_TAB 2 450 451static int name_terminate(const char *name, int namelen, int c, int terminate) 452{ 453 if (c == ' ' && !(terminate & TERM_SPACE)) 454 return 0; 455 if (c == '\t' && !(terminate & TERM_TAB)) 456 return 0; 457 458 return 1; 459} 460 461/* remove double slashes to make --index work with such filenames */ 462static char *squash_slash(char *name) 463{ 464 int i = 0, j = 0; 465 466 if (!name) 467 return NULL; 468 469 while (name[i]) { 470 if ((name[j++] = name[i++]) == '/') 471 while (name[i] == '/') 472 i++; 473 } 474 name[j] = '\0'; 475 return name; 476} 477 478static char *find_name_gnu(struct apply_state *state, 479 const char *line, 480 const char *def, 481 int p_value) 482{ 483 struct strbuf name = STRBUF_INIT; 484 char *cp; 485 486 /* 487 * Proposed "new-style" GNU patch/diff format; see 488 * http://marc.info/?l=git&m=112927316408690&w=2 489 */ 490 if (unquote_c_style(&name, line, NULL)) { 491 strbuf_release(&name); 492 return NULL; 493 } 494 495 for (cp = name.buf; p_value; p_value--) { 496 cp = strchr(cp, '/'); 497 if (!cp) { 498 strbuf_release(&name); 499 return NULL; 500 } 501 cp++; 502 } 503 504 strbuf_remove(&name, 0, cp - name.buf); 505 if (state->root.len) 506 strbuf_insert(&name, 0, state->root.buf, state->root.len); 507 return squash_slash(strbuf_detach(&name, NULL)); 508} 509 510static size_t sane_tz_len(const char *line, size_t len) 511{ 512 const char *tz, *p; 513 514 if (len < strlen(" +0500") || line[len-strlen(" +0500")] != ' ') 515 return 0; 516 tz = line + len - strlen(" +0500"); 517 518 if (tz[1] != '+' && tz[1] != '-') 519 return 0; 520 521 for (p = tz + 2; p != line + len; p++) 522 if (!isdigit(*p)) 523 return 0; 524 525 return line + len - tz; 526} 527 528static size_t tz_with_colon_len(const char *line, size_t len) 529{ 530 const char *tz, *p; 531 532 if (len < strlen(" +08:00") || line[len - strlen(":00")] != ':') 533 return 0; 534 tz = line + len - strlen(" +08:00"); 535 536 if (tz[0] != ' ' || (tz[1] != '+' && tz[1] != '-')) 537 return 0; 538 p = tz + 2; 539 if (!isdigit(*p++) || !isdigit(*p++) || *p++ != ':' || 540 !isdigit(*p++) || !isdigit(*p++)) 541 return 0; 542 543 return line + len - tz; 544} 545 546static size_t date_len(const char *line, size_t len) 547{ 548 const char *date, *p; 549 550 if (len < strlen("72-02-05") || line[len-strlen("-05")] != '-') 551 return 0; 552 p = date = line + len - strlen("72-02-05"); 553 554 if (!isdigit(*p++) || !isdigit(*p++) || *p++ != '-' || 555 !isdigit(*p++) || !isdigit(*p++) || *p++ != '-' || 556 !isdigit(*p++) || !isdigit(*p++)) /* Not a date. */ 557 return 0; 558 559 if (date - line >= strlen("19") && 560 isdigit(date[-1]) && isdigit(date[-2])) /* 4-digit year */ 561 date -= strlen("19"); 562 563 return line + len - date; 564} 565 566static size_t short_time_len(const char *line, size_t len) 567{ 568 const char *time, *p; 569 570 if (len < strlen(" 07:01:32") || line[len-strlen(":32")] != ':') 571 return 0; 572 p = time = line + len - strlen(" 07:01:32"); 573 574 /* Permit 1-digit hours? */ 575 if (*p++ != ' ' || 576 !isdigit(*p++) || !isdigit(*p++) || *p++ != ':' || 577 !isdigit(*p++) || !isdigit(*p++) || *p++ != ':' || 578 !isdigit(*p++) || !isdigit(*p++)) /* Not a time. */ 579 return 0; 580 581 return line + len - time; 582} 583 584static size_t fractional_time_len(const char *line, size_t len) 585{ 586 const char *p; 587 size_t n; 588 589 /* Expected format: 19:41:17.620000023 */ 590 if (!len || !isdigit(line[len - 1])) 591 return 0; 592 p = line + len - 1; 593 594 /* Fractional seconds. */ 595 while (p > line && isdigit(*p)) 596 p--; 597 if (*p != '.') 598 return 0; 599 600 /* Hours, minutes, and whole seconds. */ 601 n = short_time_len(line, p - line); 602 if (!n) 603 return 0; 604 605 return line + len - p + n; 606} 607 608static size_t trailing_spaces_len(const char *line, size_t len) 609{ 610 const char *p; 611 612 /* Expected format: ' ' x (1 or more) */ 613 if (!len || line[len - 1] != ' ') 614 return 0; 615 616 p = line + len; 617 while (p != line) { 618 p--; 619 if (*p != ' ') 620 return line + len - (p + 1); 621 } 622 623 /* All spaces! */ 624 return len; 625} 626 627static size_t diff_timestamp_len(const char *line, size_t len) 628{ 629 const char *end = line + len; 630 size_t n; 631 632 /* 633 * Posix: 2010-07-05 19:41:17 634 * GNU: 2010-07-05 19:41:17.620000023 -0500 635 */ 636 637 if (!isdigit(end[-1])) 638 return 0; 639 640 n = sane_tz_len(line, end - line); 641 if (!n) 642 n = tz_with_colon_len(line, end - line); 643 end -= n; 644 645 n = short_time_len(line, end - line); 646 if (!n) 647 n = fractional_time_len(line, end - line); 648 end -= n; 649 650 n = date_len(line, end - line); 651 if (!n) /* No date. Too bad. */ 652 return 0; 653 end -= n; 654 655 if (end == line) /* No space before date. */ 656 return 0; 657 if (end[-1] == '\t') { /* Success! */ 658 end--; 659 return line + len - end; 660 } 661 if (end[-1] != ' ') /* No space before date. */ 662 return 0; 663 664 /* Whitespace damage. */ 665 end -= trailing_spaces_len(line, end - line); 666 return line + len - end; 667} 668 669static char *find_name_common(struct apply_state *state, 670 const char *line, 671 const char *def, 672 int p_value, 673 const char *end, 674 int terminate) 675{ 676 int len; 677 const char *start = NULL; 678 679 if (p_value == 0) 680 start = line; 681 while (line != end) { 682 char c = *line; 683 684 if (!end && isspace(c)) { 685 if (c == '\n') 686 break; 687 if (name_terminate(start, line-start, c, terminate)) 688 break; 689 } 690 line++; 691 if (c == '/' && !--p_value) 692 start = line; 693 } 694 if (!start) 695 return squash_slash(xstrdup_or_null(def)); 696 len = line - start; 697 if (!len) 698 return squash_slash(xstrdup_or_null(def)); 699 700 /* 701 * Generally we prefer the shorter name, especially 702 * if the other one is just a variation of that with 703 * something else tacked on to the end (ie "file.orig" 704 * or "file~"). 705 */ 706 if (def) { 707 int deflen = strlen(def); 708 if (deflen < len && !strncmp(start, def, deflen)) 709 return squash_slash(xstrdup(def)); 710 } 711 712 if (state->root.len) { 713 char *ret = xstrfmt("%s%.*s", state->root.buf, len, start); 714 return squash_slash(ret); 715 } 716 717 return squash_slash(xmemdupz(start, len)); 718} 719 720static char *find_name(struct apply_state *state, 721 const char *line, 722 char *def, 723 int p_value, 724 int terminate) 725{ 726 if (*line == '"') { 727 char *name = find_name_gnu(state, line, def, p_value); 728 if (name) 729 return name; 730 } 731 732 return find_name_common(state, line, def, p_value, NULL, terminate); 733} 734 735static char *find_name_traditional(struct apply_state *state, 736 const char *line, 737 char *def, 738 int p_value) 739{ 740 size_t len; 741 size_t date_len; 742 743 if (*line == '"') { 744 char *name = find_name_gnu(state, line, def, p_value); 745 if (name) 746 return name; 747 } 748 749 len = strchrnul(line, '\n') - line; 750 date_len = diff_timestamp_len(line, len); 751 if (!date_len) 752 return find_name_common(state, line, def, p_value, NULL, TERM_TAB); 753 len -= date_len; 754 755 return find_name_common(state, line, def, p_value, line + len, 0); 756} 757 758static int count_slashes(const char *cp) 759{ 760 int cnt = 0; 761 char ch; 762 763 while ((ch = *cp++)) 764 if (ch == '/') 765 cnt++; 766 return cnt; 767} 768 769/* 770 * Given the string after "--- " or "+++ ", guess the appropriate 771 * p_value for the given patch. 772 */ 773static int guess_p_value(struct apply_state *state, const char *nameline) 774{ 775 char *name, *cp; 776 int val = -1; 777 778 if (is_dev_null(nameline)) 779 return -1; 780 name = find_name_traditional(state, nameline, NULL, 0); 781 if (!name) 782 return -1; 783 cp = strchr(name, '/'); 784 if (!cp) 785 val = 0; 786 else if (state->prefix) { 787 /* 788 * Does it begin with "a/$our-prefix" and such? Then this is 789 * very likely to apply to our directory. 790 */ 791 if (!strncmp(name, state->prefix, state->prefix_length)) 792 val = count_slashes(state->prefix); 793 else { 794 cp++; 795 if (!strncmp(cp, state->prefix, state->prefix_length)) 796 val = count_slashes(state->prefix) + 1; 797 } 798 } 799 free(name); 800 return val; 801} 802 803/* 804 * Does the ---/+++ line have the POSIX timestamp after the last HT? 805 * GNU diff puts epoch there to signal a creation/deletion event. Is 806 * this such a timestamp? 807 */ 808static int has_epoch_timestamp(const char *nameline) 809{ 810 /* 811 * We are only interested in epoch timestamp; any non-zero 812 * fraction cannot be one, hence "(\.0+)?" in the regexp below. 813 * For the same reason, the date must be either 1969-12-31 or 814 * 1970-01-01, and the seconds part must be "00". 815 */ 816 const char stamp_regexp[] = 817 "^(1969-12-31|1970-01-01)" 818 " " 819 "[0-2][0-9]:[0-5][0-9]:00(\\.0+)?" 820 " " 821 "([-+][0-2][0-9]:?[0-5][0-9])\n"; 822 const char *timestamp = NULL, *cp, *colon; 823 static regex_t *stamp; 824 regmatch_t m[10]; 825 int zoneoffset; 826 int hourminute; 827 int status; 828 829 for (cp = nameline; *cp != '\n'; cp++) { 830 if (*cp == '\t') 831 timestamp = cp + 1; 832 } 833 if (!timestamp) 834 return 0; 835 if (!stamp) { 836 stamp = xmalloc(sizeof(*stamp)); 837 if (regcomp(stamp, stamp_regexp, REG_EXTENDED)) { 838 warning(_("Cannot prepare timestamp regexp %s"), 839 stamp_regexp); 840 return 0; 841 } 842 } 843 844 status = regexec(stamp, timestamp, ARRAY_SIZE(m), m, 0); 845 if (status) { 846 if (status != REG_NOMATCH) 847 warning(_("regexec returned %d for input: %s"), 848 status, timestamp); 849 return 0; 850 } 851 852 zoneoffset = strtol(timestamp + m[3].rm_so + 1, (char **) &colon, 10); 853 if (*colon == ':') 854 zoneoffset = zoneoffset * 60 + strtol(colon + 1, NULL, 10); 855 else 856 zoneoffset = (zoneoffset / 100) * 60 + (zoneoffset % 100); 857 if (timestamp[m[3].rm_so] == '-') 858 zoneoffset = -zoneoffset; 859 860 /* 861 * YYYY-MM-DD hh:mm:ss must be from either 1969-12-31 862 * (west of GMT) or 1970-01-01 (east of GMT) 863 */ 864 if ((zoneoffset < 0 && memcmp(timestamp, "1969-12-31", 10)) || 865 (0 <= zoneoffset && memcmp(timestamp, "1970-01-01", 10))) 866 return 0; 867 868 hourminute = (strtol(timestamp + 11, NULL, 10) * 60 + 869 strtol(timestamp + 14, NULL, 10) - 870 zoneoffset); 871 872 return ((zoneoffset < 0 && hourminute == 1440) || 873 (0 <= zoneoffset && !hourminute)); 874} 875 876/* 877 * Get the name etc info from the ---/+++ lines of a traditional patch header 878 * 879 * FIXME! The end-of-filename heuristics are kind of screwy. For existing 880 * files, we can happily check the index for a match, but for creating a 881 * new file we should try to match whatever "patch" does. I have no idea. 882 */ 883static void parse_traditional_patch(struct apply_state *state, 884 const char *first, 885 const char *second, 886 struct patch *patch) 887{ 888 char *name; 889 890 first += 4; /* skip "--- " */ 891 second += 4; /* skip "+++ " */ 892 if (!state->p_value_known) { 893 int p, q; 894 p = guess_p_value(state, first); 895 q = guess_p_value(state, second); 896 if (p < 0) p = q; 897 if (0 <= p && p == q) { 898 state->p_value = p; 899 state->p_value_known = 1; 900 } 901 } 902 if (is_dev_null(first)) { 903 patch->is_new = 1; 904 patch->is_delete = 0; 905 name = find_name_traditional(state, second, NULL, state->p_value); 906 patch->new_name = name; 907 } else if (is_dev_null(second)) { 908 patch->is_new = 0; 909 patch->is_delete = 1; 910 name = find_name_traditional(state, first, NULL, state->p_value); 911 patch->old_name = name; 912 } else { 913 char *first_name; 914 first_name = find_name_traditional(state, first, NULL, state->p_value); 915 name = find_name_traditional(state, second, first_name, state->p_value); 916 free(first_name); 917 if (has_epoch_timestamp(first)) { 918 patch->is_new = 1; 919 patch->is_delete = 0; 920 patch->new_name = name; 921 } else if (has_epoch_timestamp(second)) { 922 patch->is_new = 0; 923 patch->is_delete = 1; 924 patch->old_name = name; 925 } else { 926 patch->old_name = name; 927 patch->new_name = xstrdup_or_null(name); 928 } 929 } 930 if (!name) 931 die(_("unable to find filename in patch at line %d"), state->linenr); 932} 933 934static int gitdiff_hdrend(struct apply_state *state, 935 const char *line, 936 struct patch *patch) 937{ 938 return -1; 939} 940 941/* 942 * We're anal about diff header consistency, to make 943 * sure that we don't end up having strange ambiguous 944 * patches floating around. 945 * 946 * As a result, gitdiff_{old|new}name() will check 947 * their names against any previous information, just 948 * to make sure.. 949 */ 950#define DIFF_OLD_NAME 0 951#define DIFF_NEW_NAME 1 952 953static void gitdiff_verify_name(struct apply_state *state, 954 const char *line, 955 int isnull, 956 char **name, 957 int side) 958{ 959 if (!*name && !isnull) { 960 *name = find_name(state, line, NULL, state->p_value, TERM_TAB); 961 return; 962 } 963 964 if (*name) { 965 int len = strlen(*name); 966 char *another; 967 if (isnull) 968 die(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"), 969 *name, state->linenr); 970 another = find_name(state, line, NULL, state->p_value, TERM_TAB); 971 if (!another || memcmp(another, *name, len + 1)) 972 die((side == DIFF_NEW_NAME) ? 973 _("git apply: bad git-diff - inconsistent new filename on line %d") : 974 _("git apply: bad git-diff - inconsistent old filename on line %d"), state->linenr); 975 free(another); 976 } else { 977 /* expect "/dev/null" */ 978 if (memcmp("/dev/null", line, 9) || line[9] != '\n') 979 die(_("git apply: bad git-diff - expected /dev/null on line %d"), state->linenr); 980 } 981} 982 983static int gitdiff_oldname(struct apply_state *state, 984 const char *line, 985 struct patch *patch) 986{ 987 gitdiff_verify_name(state, line, 988 patch->is_new, &patch->old_name, 989 DIFF_OLD_NAME); 990 return 0; 991} 992 993static int gitdiff_newname(struct apply_state *state, 994 const char *line, 995 struct patch *patch) 996{ 997 gitdiff_verify_name(state, line, 998 patch->is_delete, &patch->new_name, 999 DIFF_NEW_NAME);1000 return 0;1001}10021003static int gitdiff_oldmode(struct apply_state *state,1004 const char *line,1005 struct patch *patch)1006{1007 patch->old_mode = strtoul(line, NULL, 8);1008 return 0;1009}10101011static int gitdiff_newmode(struct apply_state *state,1012 const char *line,1013 struct patch *patch)1014{1015 patch->new_mode = strtoul(line, NULL, 8);1016 return 0;1017}10181019static int gitdiff_delete(struct apply_state *state,1020 const char *line,1021 struct patch *patch)1022{1023 patch->is_delete = 1;1024 free(patch->old_name);1025 patch->old_name = xstrdup_or_null(patch->def_name);1026 return gitdiff_oldmode(state, line, patch);1027}10281029static int gitdiff_newfile(struct apply_state *state,1030 const char *line,1031 struct patch *patch)1032{1033 patch->is_new = 1;1034 free(patch->new_name);1035 patch->new_name = xstrdup_or_null(patch->def_name);1036 return gitdiff_newmode(state, line, patch);1037}10381039static int gitdiff_copysrc(struct apply_state *state,1040 const char *line,1041 struct patch *patch)1042{1043 patch->is_copy = 1;1044 free(patch->old_name);1045 patch->old_name = find_name(state, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);1046 return 0;1047}10481049static int gitdiff_copydst(struct apply_state *state,1050 const char *line,1051 struct patch *patch)1052{1053 patch->is_copy = 1;1054 free(patch->new_name);1055 patch->new_name = find_name(state, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);1056 return 0;1057}10581059static int gitdiff_renamesrc(struct apply_state *state,1060 const char *line,1061 struct patch *patch)1062{1063 patch->is_rename = 1;1064 free(patch->old_name);1065 patch->old_name = find_name(state, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);1066 return 0;1067}10681069static int gitdiff_renamedst(struct apply_state *state,1070 const char *line,1071 struct patch *patch)1072{1073 patch->is_rename = 1;1074 free(patch->new_name);1075 patch->new_name = find_name(state, line, NULL, state->p_value ? state->p_value - 1 : 0, 0);1076 return 0;1077}10781079static int gitdiff_similarity(struct apply_state *state,1080 const char *line,1081 struct patch *patch)1082{1083 unsigned long val = strtoul(line, NULL, 10);1084 if (val <= 100)1085 patch->score = val;1086 return 0;1087}10881089static int gitdiff_dissimilarity(struct apply_state *state,1090 const char *line,1091 struct patch *patch)1092{1093 unsigned long val = strtoul(line, NULL, 10);1094 if (val <= 100)1095 patch->score = val;1096 return 0;1097}10981099static int gitdiff_index(struct apply_state *state,1100 const char *line,1101 struct patch *patch)1102{1103 /*1104 * index line is N hexadecimal, "..", N hexadecimal,1105 * and optional space with octal mode.1106 */1107 const char *ptr, *eol;1108 int len;11091110 ptr = strchr(line, '.');1111 if (!ptr || ptr[1] != '.' || 40 < ptr - line)1112 return 0;1113 len = ptr - line;1114 memcpy(patch->old_sha1_prefix, line, len);1115 patch->old_sha1_prefix[len] = 0;11161117 line = ptr + 2;1118 ptr = strchr(line, ' ');1119 eol = strchrnul(line, '\n');11201121 if (!ptr || eol < ptr)1122 ptr = eol;1123 len = ptr - line;11241125 if (40 < len)1126 return 0;1127 memcpy(patch->new_sha1_prefix, line, len);1128 patch->new_sha1_prefix[len] = 0;1129 if (*ptr == ' ')1130 patch->old_mode = strtoul(ptr+1, NULL, 8);1131 return 0;1132}11331134/*1135 * This is normal for a diff that doesn't change anything: we'll fall through1136 * into the next diff. Tell the parser to break out.1137 */1138static int gitdiff_unrecognized(struct apply_state *state,1139 const char *line,1140 struct patch *patch)1141{1142 return -1;1143}11441145/*1146 * Skip p_value leading components from "line"; as we do not accept1147 * absolute paths, return NULL in that case.1148 */1149static const char *skip_tree_prefix(struct apply_state *state,1150 const char *line,1151 int llen)1152{1153 int nslash;1154 int i;11551156 if (!state->p_value)1157 return (llen && line[0] == '/') ? NULL : line;11581159 nslash = state->p_value;1160 for (i = 0; i < llen; i++) {1161 int ch = line[i];1162 if (ch == '/' && --nslash <= 0)1163 return (i == 0) ? NULL : &line[i + 1];1164 }1165 return NULL;1166}11671168/*1169 * This is to extract the same name that appears on "diff --git"1170 * line. We do not find and return anything if it is a rename1171 * patch, and it is OK because we will find the name elsewhere.1172 * We need to reliably find name only when it is mode-change only,1173 * creation or deletion of an empty file. In any of these cases,1174 * both sides are the same name under a/ and b/ respectively.1175 */1176static char *git_header_name(struct apply_state *state,1177 const char *line,1178 int llen)1179{1180 const char *name;1181 const char *second = NULL;1182 size_t len, line_len;11831184 line += strlen("diff --git ");1185 llen -= strlen("diff --git ");11861187 if (*line == '"') {1188 const char *cp;1189 struct strbuf first = STRBUF_INIT;1190 struct strbuf sp = STRBUF_INIT;11911192 if (unquote_c_style(&first, line, &second))1193 goto free_and_fail1;11941195 /* strip the a/b prefix including trailing slash */1196 cp = skip_tree_prefix(state, first.buf, first.len);1197 if (!cp)1198 goto free_and_fail1;1199 strbuf_remove(&first, 0, cp - first.buf);12001201 /*1202 * second points at one past closing dq of name.1203 * find the second name.1204 */1205 while ((second < line + llen) && isspace(*second))1206 second++;12071208 if (line + llen <= second)1209 goto free_and_fail1;1210 if (*second == '"') {1211 if (unquote_c_style(&sp, second, NULL))1212 goto free_and_fail1;1213 cp = skip_tree_prefix(state, sp.buf, sp.len);1214 if (!cp)1215 goto free_and_fail1;1216 /* They must match, otherwise ignore */1217 if (strcmp(cp, first.buf))1218 goto free_and_fail1;1219 strbuf_release(&sp);1220 return strbuf_detach(&first, NULL);1221 }12221223 /* unquoted second */1224 cp = skip_tree_prefix(state, second, line + llen - second);1225 if (!cp)1226 goto free_and_fail1;1227 if (line + llen - cp != first.len ||1228 memcmp(first.buf, cp, first.len))1229 goto free_and_fail1;1230 return strbuf_detach(&first, NULL);12311232 free_and_fail1:1233 strbuf_release(&first);1234 strbuf_release(&sp);1235 return NULL;1236 }12371238 /* unquoted first name */1239 name = skip_tree_prefix(state, line, llen);1240 if (!name)1241 return NULL;12421243 /*1244 * since the first name is unquoted, a dq if exists must be1245 * the beginning of the second name.1246 */1247 for (second = name; second < line + llen; second++) {1248 if (*second == '"') {1249 struct strbuf sp = STRBUF_INIT;1250 const char *np;12511252 if (unquote_c_style(&sp, second, NULL))1253 goto free_and_fail2;12541255 np = skip_tree_prefix(state, sp.buf, sp.len);1256 if (!np)1257 goto free_and_fail2;12581259 len = sp.buf + sp.len - np;1260 if (len < second - name &&1261 !strncmp(np, name, len) &&1262 isspace(name[len])) {1263 /* Good */1264 strbuf_remove(&sp, 0, np - sp.buf);1265 return strbuf_detach(&sp, NULL);1266 }12671268 free_and_fail2:1269 strbuf_release(&sp);1270 return NULL;1271 }1272 }12731274 /*1275 * Accept a name only if it shows up twice, exactly the same1276 * form.1277 */1278 second = strchr(name, '\n');1279 if (!second)1280 return NULL;1281 line_len = second - name;1282 for (len = 0 ; ; len++) {1283 switch (name[len]) {1284 default:1285 continue;1286 case '\n':1287 return NULL;1288 case '\t': case ' ':1289 /*1290 * Is this the separator between the preimage1291 * and the postimage pathname? Again, we are1292 * only interested in the case where there is1293 * no rename, as this is only to set def_name1294 * and a rename patch has the names elsewhere1295 * in an unambiguous form.1296 */1297 if (!name[len + 1])1298 return NULL; /* no postimage name */1299 second = skip_tree_prefix(state, name + len + 1,1300 line_len - (len + 1));1301 if (!second)1302 return NULL;1303 /*1304 * Does len bytes starting at "name" and "second"1305 * (that are separated by one HT or SP we just1306 * found) exactly match?1307 */1308 if (second[len] == '\n' && !strncmp(name, second, len))1309 return xmemdupz(name, len);1310 }1311 }1312}13131314/* Verify that we recognize the lines following a git header */1315static int parse_git_header(struct apply_state *state,1316 const char *line,1317 int len,1318 unsigned int size,1319 struct patch *patch)1320{1321 unsigned long offset;13221323 /* A git diff has explicit new/delete information, so we don't guess */1324 patch->is_new = 0;1325 patch->is_delete = 0;13261327 /*1328 * Some things may not have the old name in the1329 * rest of the headers anywhere (pure mode changes,1330 * or removing or adding empty files), so we get1331 * the default name from the header.1332 */1333 patch->def_name = git_header_name(state, line, len);1334 if (patch->def_name && state->root.len) {1335 char *s = xstrfmt("%s%s", state->root.buf, patch->def_name);1336 free(patch->def_name);1337 patch->def_name = s;1338 }13391340 line += len;1341 size -= len;1342 state->linenr++;1343 for (offset = len ; size > 0 ; offset += len, size -= len, line += len, state->linenr++) {1344 static const struct opentry {1345 const char *str;1346 int (*fn)(struct apply_state *, const char *, struct patch *);1347 } optable[] = {1348 { "@@ -", gitdiff_hdrend },1349 { "--- ", gitdiff_oldname },1350 { "+++ ", gitdiff_newname },1351 { "old mode ", gitdiff_oldmode },1352 { "new mode ", gitdiff_newmode },1353 { "deleted file mode ", gitdiff_delete },1354 { "new file mode ", gitdiff_newfile },1355 { "copy from ", gitdiff_copysrc },1356 { "copy to ", gitdiff_copydst },1357 { "rename old ", gitdiff_renamesrc },1358 { "rename new ", gitdiff_renamedst },1359 { "rename from ", gitdiff_renamesrc },1360 { "rename to ", gitdiff_renamedst },1361 { "similarity index ", gitdiff_similarity },1362 { "dissimilarity index ", gitdiff_dissimilarity },1363 { "index ", gitdiff_index },1364 { "", gitdiff_unrecognized },1365 };1366 int i;13671368 len = linelen(line, size);1369 if (!len || line[len-1] != '\n')1370 break;1371 for (i = 0; i < ARRAY_SIZE(optable); i++) {1372 const struct opentry *p = optable + i;1373 int oplen = strlen(p->str);1374 if (len < oplen || memcmp(p->str, line, oplen))1375 continue;1376 if (p->fn(state, line + oplen, patch) < 0)1377 return offset;1378 break;1379 }1380 }13811382 return offset;1383}13841385static int parse_num(const char *line, unsigned long *p)1386{1387 char *ptr;13881389 if (!isdigit(*line))1390 return 0;1391 *p = strtoul(line, &ptr, 10);1392 return ptr - line;1393}13941395static int parse_range(const char *line, int len, int offset, const char *expect,1396 unsigned long *p1, unsigned long *p2)1397{1398 int digits, ex;13991400 if (offset < 0 || offset >= len)1401 return -1;1402 line += offset;1403 len -= offset;14041405 digits = parse_num(line, p1);1406 if (!digits)1407 return -1;14081409 offset += digits;1410 line += digits;1411 len -= digits;14121413 *p2 = 1;1414 if (*line == ',') {1415 digits = parse_num(line+1, p2);1416 if (!digits)1417 return -1;14181419 offset += digits+1;1420 line += digits+1;1421 len -= digits+1;1422 }14231424 ex = strlen(expect);1425 if (ex > len)1426 return -1;1427 if (memcmp(line, expect, ex))1428 return -1;14291430 return offset + ex;1431}14321433static void recount_diff(const char *line, int size, struct fragment *fragment)1434{1435 int oldlines = 0, newlines = 0, ret = 0;14361437 if (size < 1) {1438 warning("recount: ignore empty hunk");1439 return;1440 }14411442 for (;;) {1443 int len = linelen(line, size);1444 size -= len;1445 line += len;14461447 if (size < 1)1448 break;14491450 switch (*line) {1451 case ' ': case '\n':1452 newlines++;1453 /* fall through */1454 case '-':1455 oldlines++;1456 continue;1457 case '+':1458 newlines++;1459 continue;1460 case '\\':1461 continue;1462 case '@':1463 ret = size < 3 || !starts_with(line, "@@ ");1464 break;1465 case 'd':1466 ret = size < 5 || !starts_with(line, "diff ");1467 break;1468 default:1469 ret = -1;1470 break;1471 }1472 if (ret) {1473 warning(_("recount: unexpected line: %.*s"),1474 (int)linelen(line, size), line);1475 return;1476 }1477 break;1478 }1479 fragment->oldlines = oldlines;1480 fragment->newlines = newlines;1481}14821483/*1484 * Parse a unified diff fragment header of the1485 * form "@@ -a,b +c,d @@"1486 */1487static int parse_fragment_header(const char *line, int len, struct fragment *fragment)1488{1489 int offset;14901491 if (!len || line[len-1] != '\n')1492 return -1;14931494 /* Figure out the number of lines in a fragment */1495 offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);1496 offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);14971498 return offset;1499}15001501static int find_header(struct apply_state *state,1502 const char *line,1503 unsigned long size,1504 int *hdrsize,1505 struct patch *patch)1506{1507 unsigned long offset, len;15081509 patch->is_toplevel_relative = 0;1510 patch->is_rename = patch->is_copy = 0;1511 patch->is_new = patch->is_delete = -1;1512 patch->old_mode = patch->new_mode = 0;1513 patch->old_name = patch->new_name = NULL;1514 for (offset = 0; size > 0; offset += len, size -= len, line += len, state->linenr++) {1515 unsigned long nextlen;15161517 len = linelen(line, size);1518 if (!len)1519 break;15201521 /* Testing this early allows us to take a few shortcuts.. */1522 if (len < 6)1523 continue;15241525 /*1526 * Make sure we don't find any unconnected patch fragments.1527 * That's a sign that we didn't find a header, and that a1528 * patch has become corrupted/broken up.1529 */1530 if (!memcmp("@@ -", line, 4)) {1531 struct fragment dummy;1532 if (parse_fragment_header(line, len, &dummy) < 0)1533 continue;1534 die(_("patch fragment without header at line %d: %.*s"),1535 state->linenr, (int)len-1, line);1536 }15371538 if (size < len + 6)1539 break;15401541 /*1542 * Git patch? It might not have a real patch, just a rename1543 * or mode change, so we handle that specially1544 */1545 if (!memcmp("diff --git ", line, 11)) {1546 int git_hdr_len = parse_git_header(state, line, len, size, patch);1547 if (git_hdr_len <= len)1548 continue;1549 if (!patch->old_name && !patch->new_name) {1550 if (!patch->def_name)1551 die(Q_("git diff header lacks filename information when removing "1552 "%d leading pathname component (line %d)",1553 "git diff header lacks filename information when removing "1554 "%d leading pathname components (line %d)",1555 state->p_value),1556 state->p_value, state->linenr);1557 patch->old_name = xstrdup(patch->def_name);1558 patch->new_name = xstrdup(patch->def_name);1559 }1560 if (!patch->is_delete && !patch->new_name)1561 die("git diff header lacks filename information "1562 "(line %d)", state->linenr);1563 patch->is_toplevel_relative = 1;1564 *hdrsize = git_hdr_len;1565 return offset;1566 }15671568 /* --- followed by +++ ? */1569 if (memcmp("--- ", line, 4) || memcmp("+++ ", line + len, 4))1570 continue;15711572 /*1573 * We only accept unified patches, so we want it to1574 * at least have "@@ -a,b +c,d @@\n", which is 14 chars1575 * minimum ("@@ -0,0 +1 @@\n" is the shortest).1576 */1577 nextlen = linelen(line + len, size - len);1578 if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))1579 continue;15801581 /* Ok, we'll consider it a patch */1582 parse_traditional_patch(state, line, line+len, patch);1583 *hdrsize = len + nextlen;1584 state->linenr += 2;1585 return offset;1586 }1587 return -1;1588}15891590static void record_ws_error(struct apply_state *state,1591 unsigned result,1592 const char *line,1593 int len,1594 int linenr)1595{1596 char *err;15971598 if (!result)1599 return;16001601 state->whitespace_error++;1602 if (state->squelch_whitespace_errors &&1603 state->squelch_whitespace_errors < state->whitespace_error)1604 return;16051606 err = whitespace_error_string(result);1607 fprintf(stderr, "%s:%d: %s.\n%.*s\n",1608 state->patch_input_file, linenr, err, len, line);1609 free(err);1610}16111612static void check_whitespace(struct apply_state *state,1613 const char *line,1614 int len,1615 unsigned ws_rule)1616{1617 unsigned result = ws_check(line + 1, len - 1, ws_rule);16181619 record_ws_error(state, result, line + 1, len - 2, state->linenr);1620}16211622/*1623 * Parse a unified diff. Note that this really needs to parse each1624 * fragment separately, since the only way to know the difference1625 * between a "---" that is part of a patch, and a "---" that starts1626 * the next patch is to look at the line counts..1627 */1628static int parse_fragment(struct apply_state *state,1629 const char *line,1630 unsigned long size,1631 struct patch *patch,1632 struct fragment *fragment)1633{1634 int added, deleted;1635 int len = linelen(line, size), offset;1636 unsigned long oldlines, newlines;1637 unsigned long leading, trailing;16381639 offset = parse_fragment_header(line, len, fragment);1640 if (offset < 0)1641 return -1;1642 if (offset > 0 && patch->recount)1643 recount_diff(line + offset, size - offset, fragment);1644 oldlines = fragment->oldlines;1645 newlines = fragment->newlines;1646 leading = 0;1647 trailing = 0;16481649 /* Parse the thing.. */1650 line += len;1651 size -= len;1652 state->linenr++;1653 added = deleted = 0;1654 for (offset = len;1655 0 < size;1656 offset += len, size -= len, line += len, state->linenr++) {1657 if (!oldlines && !newlines)1658 break;1659 len = linelen(line, size);1660 if (!len || line[len-1] != '\n')1661 return -1;1662 switch (*line) {1663 default:1664 return -1;1665 case '\n': /* newer GNU diff, an empty context line */1666 case ' ':1667 oldlines--;1668 newlines--;1669 if (!deleted && !added)1670 leading++;1671 trailing++;1672 if (!state->apply_in_reverse &&1673 state->ws_error_action == correct_ws_error)1674 check_whitespace(state, line, len, patch->ws_rule);1675 break;1676 case '-':1677 if (state->apply_in_reverse &&1678 state->ws_error_action != nowarn_ws_error)1679 check_whitespace(state, line, len, patch->ws_rule);1680 deleted++;1681 oldlines--;1682 trailing = 0;1683 break;1684 case '+':1685 if (!state->apply_in_reverse &&1686 state->ws_error_action != nowarn_ws_error)1687 check_whitespace(state, line, len, patch->ws_rule);1688 added++;1689 newlines--;1690 trailing = 0;1691 break;16921693 /*1694 * We allow "\ No newline at end of file". Depending1695 * on locale settings when the patch was produced we1696 * don't know what this line looks like. The only1697 * thing we do know is that it begins with "\ ".1698 * Checking for 12 is just for sanity check -- any1699 * l10n of "\ No newline..." is at least that long.1700 */1701 case '\\':1702 if (len < 12 || memcmp(line, "\\ ", 2))1703 return -1;1704 break;1705 }1706 }1707 if (oldlines || newlines)1708 return -1;1709 if (!deleted && !added)1710 return -1;17111712 fragment->leading = leading;1713 fragment->trailing = trailing;17141715 /*1716 * If a fragment ends with an incomplete line, we failed to include1717 * it in the above loop because we hit oldlines == newlines == 01718 * before seeing it.1719 */1720 if (12 < size && !memcmp(line, "\\ ", 2))1721 offset += linelen(line, size);17221723 patch->lines_added += added;1724 patch->lines_deleted += deleted;17251726 if (0 < patch->is_new && oldlines)1727 return error(_("new file depends on old contents"));1728 if (0 < patch->is_delete && newlines)1729 return error(_("deleted file still has contents"));1730 return offset;1731}17321733/*1734 * We have seen "diff --git a/... b/..." header (or a traditional patch1735 * header). Read hunks that belong to this patch into fragments and hang1736 * them to the given patch structure.1737 *1738 * The (fragment->patch, fragment->size) pair points into the memory given1739 * by the caller, not a copy, when we return.1740 */1741static int parse_single_patch(struct apply_state *state,1742 const char *line,1743 unsigned long size,1744 struct patch *patch)1745{1746 unsigned long offset = 0;1747 unsigned long oldlines = 0, newlines = 0, context = 0;1748 struct fragment **fragp = &patch->fragments;17491750 while (size > 4 && !memcmp(line, "@@ -", 4)) {1751 struct fragment *fragment;1752 int len;17531754 fragment = xcalloc(1, sizeof(*fragment));1755 fragment->linenr = state->linenr;1756 len = parse_fragment(state, line, size, patch, fragment);1757 if (len <= 0)1758 die(_("corrupt patch at line %d"), state->linenr);1759 fragment->patch = line;1760 fragment->size = len;1761 oldlines += fragment->oldlines;1762 newlines += fragment->newlines;1763 context += fragment->leading + fragment->trailing;17641765 *fragp = fragment;1766 fragp = &fragment->next;17671768 offset += len;1769 line += len;1770 size -= len;1771 }17721773 /*1774 * If something was removed (i.e. we have old-lines) it cannot1775 * be creation, and if something was added it cannot be1776 * deletion. However, the reverse is not true; --unified=01777 * patches that only add are not necessarily creation even1778 * though they do not have any old lines, and ones that only1779 * delete are not necessarily deletion.1780 *1781 * Unfortunately, a real creation/deletion patch do _not_ have1782 * any context line by definition, so we cannot safely tell it1783 * apart with --unified=0 insanity. At least if the patch has1784 * more than one hunk it is not creation or deletion.1785 */1786 if (patch->is_new < 0 &&1787 (oldlines || (patch->fragments && patch->fragments->next)))1788 patch->is_new = 0;1789 if (patch->is_delete < 0 &&1790 (newlines || (patch->fragments && patch->fragments->next)))1791 patch->is_delete = 0;17921793 if (0 < patch->is_new && oldlines)1794 die(_("new file %s depends on old contents"), patch->new_name);1795 if (0 < patch->is_delete && newlines)1796 die(_("deleted file %s still has contents"), patch->old_name);1797 if (!patch->is_delete && !newlines && context)1798 fprintf_ln(stderr,1799 _("** warning: "1800 "file %s becomes empty but is not deleted"),1801 patch->new_name);18021803 return offset;1804}18051806static inline int metadata_changes(struct patch *patch)1807{1808 return patch->is_rename > 0 ||1809 patch->is_copy > 0 ||1810 patch->is_new > 0 ||1811 patch->is_delete ||1812 (patch->old_mode && patch->new_mode &&1813 patch->old_mode != patch->new_mode);1814}18151816static char *inflate_it(const void *data, unsigned long size,1817 unsigned long inflated_size)1818{1819 git_zstream stream;1820 void *out;1821 int st;18221823 memset(&stream, 0, sizeof(stream));18241825 stream.next_in = (unsigned char *)data;1826 stream.avail_in = size;1827 stream.next_out = out = xmalloc(inflated_size);1828 stream.avail_out = inflated_size;1829 git_inflate_init(&stream);1830 st = git_inflate(&stream, Z_FINISH);1831 git_inflate_end(&stream);1832 if ((st != Z_STREAM_END) || stream.total_out != inflated_size) {1833 free(out);1834 return NULL;1835 }1836 return out;1837}18381839/*1840 * Read a binary hunk and return a new fragment; fragment->patch1841 * points at an allocated memory that the caller must free, so1842 * it is marked as "->free_patch = 1".1843 */1844static struct fragment *parse_binary_hunk(struct apply_state *state,1845 char **buf_p,1846 unsigned long *sz_p,1847 int *status_p,1848 int *used_p)1849{1850 /*1851 * Expect a line that begins with binary patch method ("literal"1852 * or "delta"), followed by the length of data before deflating.1853 * a sequence of 'length-byte' followed by base-85 encoded data1854 * should follow, terminated by a newline.1855 *1856 * Each 5-byte sequence of base-85 encodes up to 4 bytes,1857 * and we would limit the patch line to 66 characters,1858 * so one line can fit up to 13 groups that would decode1859 * to 52 bytes max. The length byte 'A'-'Z' corresponds1860 * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.1861 */1862 int llen, used;1863 unsigned long size = *sz_p;1864 char *buffer = *buf_p;1865 int patch_method;1866 unsigned long origlen;1867 char *data = NULL;1868 int hunk_size = 0;1869 struct fragment *frag;18701871 llen = linelen(buffer, size);1872 used = llen;18731874 *status_p = 0;18751876 if (starts_with(buffer, "delta ")) {1877 patch_method = BINARY_DELTA_DEFLATED;1878 origlen = strtoul(buffer + 6, NULL, 10);1879 }1880 else if (starts_with(buffer, "literal ")) {1881 patch_method = BINARY_LITERAL_DEFLATED;1882 origlen = strtoul(buffer + 8, NULL, 10);1883 }1884 else1885 return NULL;18861887 state->linenr++;1888 buffer += llen;1889 while (1) {1890 int byte_length, max_byte_length, newsize;1891 llen = linelen(buffer, size);1892 used += llen;1893 state->linenr++;1894 if (llen == 1) {1895 /* consume the blank line */1896 buffer++;1897 size--;1898 break;1899 }1900 /*1901 * Minimum line is "A00000\n" which is 7-byte long,1902 * and the line length must be multiple of 5 plus 2.1903 */1904 if ((llen < 7) || (llen-2) % 5)1905 goto corrupt;1906 max_byte_length = (llen - 2) / 5 * 4;1907 byte_length = *buffer;1908 if ('A' <= byte_length && byte_length <= 'Z')1909 byte_length = byte_length - 'A' + 1;1910 else if ('a' <= byte_length && byte_length <= 'z')1911 byte_length = byte_length - 'a' + 27;1912 else1913 goto corrupt;1914 /* if the input length was not multiple of 4, we would1915 * have filler at the end but the filler should never1916 * exceed 3 bytes1917 */1918 if (max_byte_length < byte_length ||1919 byte_length <= max_byte_length - 4)1920 goto corrupt;1921 newsize = hunk_size + byte_length;1922 data = xrealloc(data, newsize);1923 if (decode_85(data + hunk_size, buffer + 1, byte_length))1924 goto corrupt;1925 hunk_size = newsize;1926 buffer += llen;1927 size -= llen;1928 }19291930 frag = xcalloc(1, sizeof(*frag));1931 frag->patch = inflate_it(data, hunk_size, origlen);1932 frag->free_patch = 1;1933 if (!frag->patch)1934 goto corrupt;1935 free(data);1936 frag->size = origlen;1937 *buf_p = buffer;1938 *sz_p = size;1939 *used_p = used;1940 frag->binary_patch_method = patch_method;1941 return frag;19421943 corrupt:1944 free(data);1945 *status_p = -1;1946 error(_("corrupt binary patch at line %d: %.*s"),1947 state->linenr-1, llen-1, buffer);1948 return NULL;1949}19501951/*1952 * Returns:1953 * -1 in case of error,1954 * the length of the parsed binary patch otherwise1955 */1956static int parse_binary(struct apply_state *state,1957 char *buffer,1958 unsigned long size,1959 struct patch *patch)1960{1961 /*1962 * We have read "GIT binary patch\n"; what follows is a line1963 * that says the patch method (currently, either "literal" or1964 * "delta") and the length of data before deflating; a1965 * sequence of 'length-byte' followed by base-85 encoded data1966 * follows.1967 *1968 * When a binary patch is reversible, there is another binary1969 * hunk in the same format, starting with patch method (either1970 * "literal" or "delta") with the length of data, and a sequence1971 * of length-byte + base-85 encoded data, terminated with another1972 * empty line. This data, when applied to the postimage, produces1973 * the preimage.1974 */1975 struct fragment *forward;1976 struct fragment *reverse;1977 int status;1978 int used, used_1;19791980 forward = parse_binary_hunk(state, &buffer, &size, &status, &used);1981 if (!forward && !status)1982 /* there has to be one hunk (forward hunk) */1983 return error(_("unrecognized binary patch at line %d"), state->linenr-1);1984 if (status)1985 /* otherwise we already gave an error message */1986 return status;19871988 reverse = parse_binary_hunk(state, &buffer, &size, &status, &used_1);1989 if (reverse)1990 used += used_1;1991 else if (status) {1992 /*1993 * Not having reverse hunk is not an error, but having1994 * a corrupt reverse hunk is.1995 */1996 free((void*) forward->patch);1997 free(forward);1998 return status;1999 }2000 forward->next = reverse;2001 patch->fragments = forward;2002 patch->is_binary = 1;2003 return used;2004}20052006static void prefix_one(struct apply_state *state, char **name)2007{2008 char *old_name = *name;2009 if (!old_name)2010 return;2011 *name = xstrdup(prefix_filename(state->prefix, state->prefix_length, *name));2012 free(old_name);2013}20142015static void prefix_patch(struct apply_state *state, struct patch *p)2016{2017 if (!state->prefix || p->is_toplevel_relative)2018 return;2019 prefix_one(state, &p->new_name);2020 prefix_one(state, &p->old_name);2021}20222023/*2024 * include/exclude2025 */20262027static void add_name_limit(struct apply_state *state,2028 const char *name,2029 int exclude)2030{2031 struct string_list_item *it;20322033 it = string_list_append(&state->limit_by_name, name);2034 it->util = exclude ? NULL : (void *) 1;2035}20362037static int use_patch(struct apply_state *state, struct patch *p)2038{2039 const char *pathname = p->new_name ? p->new_name : p->old_name;2040 int i;20412042 /* Paths outside are not touched regardless of "--include" */2043 if (0 < state->prefix_length) {2044 int pathlen = strlen(pathname);2045 if (pathlen <= state->prefix_length ||2046 memcmp(state->prefix, pathname, state->prefix_length))2047 return 0;2048 }20492050 /* See if it matches any of exclude/include rule */2051 for (i = 0; i < state->limit_by_name.nr; i++) {2052 struct string_list_item *it = &state->limit_by_name.items[i];2053 if (!wildmatch(it->string, pathname, 0, NULL))2054 return (it->util != NULL);2055 }20562057 /*2058 * If we had any include, a path that does not match any rule is2059 * not used. Otherwise, we saw bunch of exclude rules (or none)2060 * and such a path is used.2061 */2062 return !state->has_include;2063}206420652066/*2067 * Read the patch text in "buffer" that extends for "size" bytes; stop2068 * reading after seeing a single patch (i.e. changes to a single file).2069 * Create fragments (i.e. patch hunks) and hang them to the given patch.2070 * Return the number of bytes consumed, so that the caller can call us2071 * again for the next patch.2072 */2073static int parse_chunk(struct apply_state *state, char *buffer, unsigned long size, struct patch *patch)2074{2075 int hdrsize, patchsize;2076 int offset = find_header(state, buffer, size, &hdrsize, patch);20772078 if (offset < 0)2079 return offset;20802081 prefix_patch(state, patch);20822083 if (!use_patch(state, patch))2084 patch->ws_rule = 0;2085 else2086 patch->ws_rule = whitespace_rule(patch->new_name2087 ? patch->new_name2088 : patch->old_name);20892090 patchsize = parse_single_patch(state,2091 buffer + offset + hdrsize,2092 size - offset - hdrsize,2093 patch);20942095 if (!patchsize) {2096 static const char git_binary[] = "GIT binary patch\n";2097 int hd = hdrsize + offset;2098 unsigned long llen = linelen(buffer + hd, size - hd);20992100 if (llen == sizeof(git_binary) - 1 &&2101 !memcmp(git_binary, buffer + hd, llen)) {2102 int used;2103 state->linenr++;2104 used = parse_binary(state, buffer + hd + llen,2105 size - hd - llen, patch);2106 if (used < 0)2107 return -1;2108 if (used)2109 patchsize = used + llen;2110 else2111 patchsize = 0;2112 }2113 else if (!memcmp(" differ\n", buffer + hd + llen - 8, 8)) {2114 static const char *binhdr[] = {2115 "Binary files ",2116 "Files ",2117 NULL,2118 };2119 int i;2120 for (i = 0; binhdr[i]; i++) {2121 int len = strlen(binhdr[i]);2122 if (len < size - hd &&2123 !memcmp(binhdr[i], buffer + hd, len)) {2124 state->linenr++;2125 patch->is_binary = 1;2126 patchsize = llen;2127 break;2128 }2129 }2130 }21312132 /* Empty patch cannot be applied if it is a text patch2133 * without metadata change. A binary patch appears2134 * empty to us here.2135 */2136 if ((state->apply || state->check) &&2137 (!patch->is_binary && !metadata_changes(patch)))2138 die(_("patch with only garbage at line %d"), state->linenr);2139 }21402141 return offset + hdrsize + patchsize;2142}21432144#define swap(a,b) myswap((a),(b),sizeof(a))21452146#define myswap(a, b, size) do { \2147 unsigned char mytmp[size]; \2148 memcpy(mytmp, &a, size); \2149 memcpy(&a, &b, size); \2150 memcpy(&b, mytmp, size); \2151} while (0)21522153static void reverse_patches(struct patch *p)2154{2155 for (; p; p = p->next) {2156 struct fragment *frag = p->fragments;21572158 swap(p->new_name, p->old_name);2159 swap(p->new_mode, p->old_mode);2160 swap(p->is_new, p->is_delete);2161 swap(p->lines_added, p->lines_deleted);2162 swap(p->old_sha1_prefix, p->new_sha1_prefix);21632164 for (; frag; frag = frag->next) {2165 swap(frag->newpos, frag->oldpos);2166 swap(frag->newlines, frag->oldlines);2167 }2168 }2169}21702171static const char pluses[] =2172"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";2173static const char minuses[]=2174"----------------------------------------------------------------------";21752176static void show_stats(struct apply_state *state, struct patch *patch)2177{2178 struct strbuf qname = STRBUF_INIT;2179 char *cp = patch->new_name ? patch->new_name : patch->old_name;2180 int max, add, del;21812182 quote_c_style(cp, &qname, NULL, 0);21832184 /*2185 * "scale" the filename2186 */2187 max = state->max_len;2188 if (max > 50)2189 max = 50;21902191 if (qname.len > max) {2192 cp = strchr(qname.buf + qname.len + 3 - max, '/');2193 if (!cp)2194 cp = qname.buf + qname.len + 3 - max;2195 strbuf_splice(&qname, 0, cp - qname.buf, "...", 3);2196 }21972198 if (patch->is_binary) {2199 printf(" %-*s | Bin\n", max, qname.buf);2200 strbuf_release(&qname);2201 return;2202 }22032204 printf(" %-*s |", max, qname.buf);2205 strbuf_release(&qname);22062207 /*2208 * scale the add/delete2209 */2210 max = max + state->max_change > 70 ? 70 - max : state->max_change;2211 add = patch->lines_added;2212 del = patch->lines_deleted;22132214 if (state->max_change > 0) {2215 int total = ((add + del) * max + state->max_change / 2) / state->max_change;2216 add = (add * max + state->max_change / 2) / state->max_change;2217 del = total - add;2218 }2219 printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,2220 add, pluses, del, minuses);2221}22222223static int read_old_data(struct stat *st, const char *path, struct strbuf *buf)2224{2225 switch (st->st_mode & S_IFMT) {2226 case S_IFLNK:2227 if (strbuf_readlink(buf, path, st->st_size) < 0)2228 return error(_("unable to read symlink %s"), path);2229 return 0;2230 case S_IFREG:2231 if (strbuf_read_file(buf, path, st->st_size) != st->st_size)2232 return error(_("unable to open or read %s"), path);2233 convert_to_git(path, buf->buf, buf->len, buf, 0);2234 return 0;2235 default:2236 return -1;2237 }2238}22392240/*2241 * Update the preimage, and the common lines in postimage,2242 * from buffer buf of length len. If postlen is 0 the postimage2243 * is updated in place, otherwise it's updated on a new buffer2244 * of length postlen2245 */22462247static void update_pre_post_images(struct image *preimage,2248 struct image *postimage,2249 char *buf,2250 size_t len, size_t postlen)2251{2252 int i, ctx, reduced;2253 char *new, *old, *fixed;2254 struct image fixed_preimage;22552256 /*2257 * Update the preimage with whitespace fixes. Note that we2258 * are not losing preimage->buf -- apply_one_fragment() will2259 * free "oldlines".2260 */2261 prepare_image(&fixed_preimage, buf, len, 1);2262 assert(postlen2263 ? fixed_preimage.nr == preimage->nr2264 : fixed_preimage.nr <= preimage->nr);2265 for (i = 0; i < fixed_preimage.nr; i++)2266 fixed_preimage.line[i].flag = preimage->line[i].flag;2267 free(preimage->line_allocated);2268 *preimage = fixed_preimage;22692270 /*2271 * Adjust the common context lines in postimage. This can be2272 * done in-place when we are shrinking it with whitespace2273 * fixing, but needs a new buffer when ignoring whitespace or2274 * expanding leading tabs to spaces.2275 *2276 * We trust the caller to tell us if the update can be done2277 * in place (postlen==0) or not.2278 */2279 old = postimage->buf;2280 if (postlen)2281 new = postimage->buf = xmalloc(postlen);2282 else2283 new = old;2284 fixed = preimage->buf;22852286 for (i = reduced = ctx = 0; i < postimage->nr; i++) {2287 size_t l_len = postimage->line[i].len;2288 if (!(postimage->line[i].flag & LINE_COMMON)) {2289 /* an added line -- no counterparts in preimage */2290 memmove(new, old, l_len);2291 old += l_len;2292 new += l_len;2293 continue;2294 }22952296 /* a common context -- skip it in the original postimage */2297 old += l_len;22982299 /* and find the corresponding one in the fixed preimage */2300 while (ctx < preimage->nr &&2301 !(preimage->line[ctx].flag & LINE_COMMON)) {2302 fixed += preimage->line[ctx].len;2303 ctx++;2304 }23052306 /*2307 * preimage is expected to run out, if the caller2308 * fixed addition of trailing blank lines.2309 */2310 if (preimage->nr <= ctx) {2311 reduced++;2312 continue;2313 }23142315 /* and copy it in, while fixing the line length */2316 l_len = preimage->line[ctx].len;2317 memcpy(new, fixed, l_len);2318 new += l_len;2319 fixed += l_len;2320 postimage->line[i].len = l_len;2321 ctx++;2322 }23232324 if (postlen2325 ? postlen < new - postimage->buf2326 : postimage->len < new - postimage->buf)2327 die("BUG: caller miscounted postlen: asked %d, orig = %d, used = %d",2328 (int)postlen, (int) postimage->len, (int)(new - postimage->buf));23292330 /* Fix the length of the whole thing */2331 postimage->len = new - postimage->buf;2332 postimage->nr -= reduced;2333}23342335static int line_by_line_fuzzy_match(struct image *img,2336 struct image *preimage,2337 struct image *postimage,2338 unsigned long try,2339 int try_lno,2340 int preimage_limit)2341{2342 int i;2343 size_t imgoff = 0;2344 size_t preoff = 0;2345 size_t postlen = postimage->len;2346 size_t extra_chars;2347 char *buf;2348 char *preimage_eof;2349 char *preimage_end;2350 struct strbuf fixed;2351 char *fixed_buf;2352 size_t fixed_len;23532354 for (i = 0; i < preimage_limit; i++) {2355 size_t prelen = preimage->line[i].len;2356 size_t imglen = img->line[try_lno+i].len;23572358 if (!fuzzy_matchlines(img->buf + try + imgoff, imglen,2359 preimage->buf + preoff, prelen))2360 return 0;2361 if (preimage->line[i].flag & LINE_COMMON)2362 postlen += imglen - prelen;2363 imgoff += imglen;2364 preoff += prelen;2365 }23662367 /*2368 * Ok, the preimage matches with whitespace fuzz.2369 *2370 * imgoff now holds the true length of the target that2371 * matches the preimage before the end of the file.2372 *2373 * Count the number of characters in the preimage that fall2374 * beyond the end of the file and make sure that all of them2375 * are whitespace characters. (This can only happen if2376 * we are removing blank lines at the end of the file.)2377 */2378 buf = preimage_eof = preimage->buf + preoff;2379 for ( ; i < preimage->nr; i++)2380 preoff += preimage->line[i].len;2381 preimage_end = preimage->buf + preoff;2382 for ( ; buf < preimage_end; buf++)2383 if (!isspace(*buf))2384 return 0;23852386 /*2387 * Update the preimage and the common postimage context2388 * lines to use the same whitespace as the target.2389 * If whitespace is missing in the target (i.e.2390 * if the preimage extends beyond the end of the file),2391 * use the whitespace from the preimage.2392 */2393 extra_chars = preimage_end - preimage_eof;2394 strbuf_init(&fixed, imgoff + extra_chars);2395 strbuf_add(&fixed, img->buf + try, imgoff);2396 strbuf_add(&fixed, preimage_eof, extra_chars);2397 fixed_buf = strbuf_detach(&fixed, &fixed_len);2398 update_pre_post_images(preimage, postimage,2399 fixed_buf, fixed_len, postlen);2400 return 1;2401}24022403static int match_fragment(struct apply_state *state,2404 struct image *img,2405 struct image *preimage,2406 struct image *postimage,2407 unsigned long try,2408 int try_lno,2409 unsigned ws_rule,2410 int match_beginning, int match_end)2411{2412 int i;2413 char *fixed_buf, *buf, *orig, *target;2414 struct strbuf fixed;2415 size_t fixed_len, postlen;2416 int preimage_limit;24172418 if (preimage->nr + try_lno <= img->nr) {2419 /*2420 * The hunk falls within the boundaries of img.2421 */2422 preimage_limit = preimage->nr;2423 if (match_end && (preimage->nr + try_lno != img->nr))2424 return 0;2425 } else if (state->ws_error_action == correct_ws_error &&2426 (ws_rule & WS_BLANK_AT_EOF)) {2427 /*2428 * This hunk extends beyond the end of img, and we are2429 * removing blank lines at the end of the file. This2430 * many lines from the beginning of the preimage must2431 * match with img, and the remainder of the preimage2432 * must be blank.2433 */2434 preimage_limit = img->nr - try_lno;2435 } else {2436 /*2437 * The hunk extends beyond the end of the img and2438 * we are not removing blanks at the end, so we2439 * should reject the hunk at this position.2440 */2441 return 0;2442 }24432444 if (match_beginning && try_lno)2445 return 0;24462447 /* Quick hash check */2448 for (i = 0; i < preimage_limit; i++)2449 if ((img->line[try_lno + i].flag & LINE_PATCHED) ||2450 (preimage->line[i].hash != img->line[try_lno + i].hash))2451 return 0;24522453 if (preimage_limit == preimage->nr) {2454 /*2455 * Do we have an exact match? If we were told to match2456 * at the end, size must be exactly at try+fragsize,2457 * otherwise try+fragsize must be still within the preimage,2458 * and either case, the old piece should match the preimage2459 * exactly.2460 */2461 if ((match_end2462 ? (try + preimage->len == img->len)2463 : (try + preimage->len <= img->len)) &&2464 !memcmp(img->buf + try, preimage->buf, preimage->len))2465 return 1;2466 } else {2467 /*2468 * The preimage extends beyond the end of img, so2469 * there cannot be an exact match.2470 *2471 * There must be one non-blank context line that match2472 * a line before the end of img.2473 */2474 char *buf_end;24752476 buf = preimage->buf;2477 buf_end = buf;2478 for (i = 0; i < preimage_limit; i++)2479 buf_end += preimage->line[i].len;24802481 for ( ; buf < buf_end; buf++)2482 if (!isspace(*buf))2483 break;2484 if (buf == buf_end)2485 return 0;2486 }24872488 /*2489 * No exact match. If we are ignoring whitespace, run a line-by-line2490 * fuzzy matching. We collect all the line length information because2491 * we need it to adjust whitespace if we match.2492 */2493 if (state->ws_ignore_action == ignore_ws_change)2494 return line_by_line_fuzzy_match(img, preimage, postimage,2495 try, try_lno, preimage_limit);24962497 if (state->ws_error_action != correct_ws_error)2498 return 0;24992500 /*2501 * The hunk does not apply byte-by-byte, but the hash says2502 * it might with whitespace fuzz. We weren't asked to2503 * ignore whitespace, we were asked to correct whitespace2504 * errors, so let's try matching after whitespace correction.2505 *2506 * While checking the preimage against the target, whitespace2507 * errors in both fixed, we count how large the corresponding2508 * postimage needs to be. The postimage prepared by2509 * apply_one_fragment() has whitespace errors fixed on added2510 * lines already, but the common lines were propagated as-is,2511 * which may become longer when their whitespace errors are2512 * fixed.2513 */25142515 /* First count added lines in postimage */2516 postlen = 0;2517 for (i = 0; i < postimage->nr; i++) {2518 if (!(postimage->line[i].flag & LINE_COMMON))2519 postlen += postimage->line[i].len;2520 }25212522 /*2523 * The preimage may extend beyond the end of the file,2524 * but in this loop we will only handle the part of the2525 * preimage that falls within the file.2526 */2527 strbuf_init(&fixed, preimage->len + 1);2528 orig = preimage->buf;2529 target = img->buf + try;2530 for (i = 0; i < preimage_limit; i++) {2531 size_t oldlen = preimage->line[i].len;2532 size_t tgtlen = img->line[try_lno + i].len;2533 size_t fixstart = fixed.len;2534 struct strbuf tgtfix;2535 int match;25362537 /* Try fixing the line in the preimage */2538 ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);25392540 /* Try fixing the line in the target */2541 strbuf_init(&tgtfix, tgtlen);2542 ws_fix_copy(&tgtfix, target, tgtlen, ws_rule, NULL);25432544 /*2545 * If they match, either the preimage was based on2546 * a version before our tree fixed whitespace breakage,2547 * or we are lacking a whitespace-fix patch the tree2548 * the preimage was based on already had (i.e. target2549 * has whitespace breakage, the preimage doesn't).2550 * In either case, we are fixing the whitespace breakages2551 * so we might as well take the fix together with their2552 * real change.2553 */2554 match = (tgtfix.len == fixed.len - fixstart &&2555 !memcmp(tgtfix.buf, fixed.buf + fixstart,2556 fixed.len - fixstart));25572558 /* Add the length if this is common with the postimage */2559 if (preimage->line[i].flag & LINE_COMMON)2560 postlen += tgtfix.len;25612562 strbuf_release(&tgtfix);2563 if (!match)2564 goto unmatch_exit;25652566 orig += oldlen;2567 target += tgtlen;2568 }256925702571 /*2572 * Now handle the lines in the preimage that falls beyond the2573 * end of the file (if any). They will only match if they are2574 * empty or only contain whitespace (if WS_BLANK_AT_EOL is2575 * false).2576 */2577 for ( ; i < preimage->nr; i++) {2578 size_t fixstart = fixed.len; /* start of the fixed preimage */2579 size_t oldlen = preimage->line[i].len;2580 int j;25812582 /* Try fixing the line in the preimage */2583 ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);25842585 for (j = fixstart; j < fixed.len; j++)2586 if (!isspace(fixed.buf[j]))2587 goto unmatch_exit;25882589 orig += oldlen;2590 }25912592 /*2593 * Yes, the preimage is based on an older version that still2594 * has whitespace breakages unfixed, and fixing them makes the2595 * hunk match. Update the context lines in the postimage.2596 */2597 fixed_buf = strbuf_detach(&fixed, &fixed_len);2598 if (postlen < postimage->len)2599 postlen = 0;2600 update_pre_post_images(preimage, postimage,2601 fixed_buf, fixed_len, postlen);2602 return 1;26032604 unmatch_exit:2605 strbuf_release(&fixed);2606 return 0;2607}26082609static int find_pos(struct apply_state *state,2610 struct image *img,2611 struct image *preimage,2612 struct image *postimage,2613 int line,2614 unsigned ws_rule,2615 int match_beginning, int match_end)2616{2617 int i;2618 unsigned long backwards, forwards, try;2619 int backwards_lno, forwards_lno, try_lno;26202621 /*2622 * If match_beginning or match_end is specified, there is no2623 * point starting from a wrong line that will never match and2624 * wander around and wait for a match at the specified end.2625 */2626 if (match_beginning)2627 line = 0;2628 else if (match_end)2629 line = img->nr - preimage->nr;26302631 /*2632 * Because the comparison is unsigned, the following test2633 * will also take care of a negative line number that can2634 * result when match_end and preimage is larger than the target.2635 */2636 if ((size_t) line > img->nr)2637 line = img->nr;26382639 try = 0;2640 for (i = 0; i < line; i++)2641 try += img->line[i].len;26422643 /*2644 * There's probably some smart way to do this, but I'll leave2645 * that to the smart and beautiful people. I'm simple and stupid.2646 */2647 backwards = try;2648 backwards_lno = line;2649 forwards = try;2650 forwards_lno = line;2651 try_lno = line;26522653 for (i = 0; ; i++) {2654 if (match_fragment(state, img, preimage, postimage,2655 try, try_lno, ws_rule,2656 match_beginning, match_end))2657 return try_lno;26582659 again:2660 if (backwards_lno == 0 && forwards_lno == img->nr)2661 break;26622663 if (i & 1) {2664 if (backwards_lno == 0) {2665 i++;2666 goto again;2667 }2668 backwards_lno--;2669 backwards -= img->line[backwards_lno].len;2670 try = backwards;2671 try_lno = backwards_lno;2672 } else {2673 if (forwards_lno == img->nr) {2674 i++;2675 goto again;2676 }2677 forwards += img->line[forwards_lno].len;2678 forwards_lno++;2679 try = forwards;2680 try_lno = forwards_lno;2681 }26822683 }2684 return -1;2685}26862687static void remove_first_line(struct image *img)2688{2689 img->buf += img->line[0].len;2690 img->len -= img->line[0].len;2691 img->line++;2692 img->nr--;2693}26942695static void remove_last_line(struct image *img)2696{2697 img->len -= img->line[--img->nr].len;2698}26992700/*2701 * The change from "preimage" and "postimage" has been found to2702 * apply at applied_pos (counts in line numbers) in "img".2703 * Update "img" to remove "preimage" and replace it with "postimage".2704 */2705static void update_image(struct apply_state *state,2706 struct image *img,2707 int applied_pos,2708 struct image *preimage,2709 struct image *postimage)2710{2711 /*2712 * remove the copy of preimage at offset in img2713 * and replace it with postimage2714 */2715 int i, nr;2716 size_t remove_count, insert_count, applied_at = 0;2717 char *result;2718 int preimage_limit;27192720 /*2721 * If we are removing blank lines at the end of img,2722 * the preimage may extend beyond the end.2723 * If that is the case, we must be careful only to2724 * remove the part of the preimage that falls within2725 * the boundaries of img. Initialize preimage_limit2726 * to the number of lines in the preimage that falls2727 * within the boundaries.2728 */2729 preimage_limit = preimage->nr;2730 if (preimage_limit > img->nr - applied_pos)2731 preimage_limit = img->nr - applied_pos;27322733 for (i = 0; i < applied_pos; i++)2734 applied_at += img->line[i].len;27352736 remove_count = 0;2737 for (i = 0; i < preimage_limit; i++)2738 remove_count += img->line[applied_pos + i].len;2739 insert_count = postimage->len;27402741 /* Adjust the contents */2742 result = xmalloc(st_add3(st_sub(img->len, remove_count), insert_count, 1));2743 memcpy(result, img->buf, applied_at);2744 memcpy(result + applied_at, postimage->buf, postimage->len);2745 memcpy(result + applied_at + postimage->len,2746 img->buf + (applied_at + remove_count),2747 img->len - (applied_at + remove_count));2748 free(img->buf);2749 img->buf = result;2750 img->len += insert_count - remove_count;2751 result[img->len] = '\0';27522753 /* Adjust the line table */2754 nr = img->nr + postimage->nr - preimage_limit;2755 if (preimage_limit < postimage->nr) {2756 /*2757 * NOTE: this knows that we never call remove_first_line()2758 * on anything other than pre/post image.2759 */2760 REALLOC_ARRAY(img->line, nr);2761 img->line_allocated = img->line;2762 }2763 if (preimage_limit != postimage->nr)2764 memmove(img->line + applied_pos + postimage->nr,2765 img->line + applied_pos + preimage_limit,2766 (img->nr - (applied_pos + preimage_limit)) *2767 sizeof(*img->line));2768 memcpy(img->line + applied_pos,2769 postimage->line,2770 postimage->nr * sizeof(*img->line));2771 if (!state->allow_overlap)2772 for (i = 0; i < postimage->nr; i++)2773 img->line[applied_pos + i].flag |= LINE_PATCHED;2774 img->nr = nr;2775}27762777/*2778 * Use the patch-hunk text in "frag" to prepare two images (preimage and2779 * postimage) for the hunk. Find lines that match "preimage" in "img" and2780 * replace the part of "img" with "postimage" text.2781 */2782static int apply_one_fragment(struct apply_state *state,2783 struct image *img, struct fragment *frag,2784 int inaccurate_eof, unsigned ws_rule,2785 int nth_fragment)2786{2787 int match_beginning, match_end;2788 const char *patch = frag->patch;2789 int size = frag->size;2790 char *old, *oldlines;2791 struct strbuf newlines;2792 int new_blank_lines_at_end = 0;2793 int found_new_blank_lines_at_end = 0;2794 int hunk_linenr = frag->linenr;2795 unsigned long leading, trailing;2796 int pos, applied_pos;2797 struct image preimage;2798 struct image postimage;27992800 memset(&preimage, 0, sizeof(preimage));2801 memset(&postimage, 0, sizeof(postimage));2802 oldlines = xmalloc(size);2803 strbuf_init(&newlines, size);28042805 old = oldlines;2806 while (size > 0) {2807 char first;2808 int len = linelen(patch, size);2809 int plen;2810 int added_blank_line = 0;2811 int is_blank_context = 0;2812 size_t start;28132814 if (!len)2815 break;28162817 /*2818 * "plen" is how much of the line we should use for2819 * the actual patch data. Normally we just remove the2820 * first character on the line, but if the line is2821 * followed by "\ No newline", then we also remove the2822 * last one (which is the newline, of course).2823 */2824 plen = len - 1;2825 if (len < size && patch[len] == '\\')2826 plen--;2827 first = *patch;2828 if (state->apply_in_reverse) {2829 if (first == '-')2830 first = '+';2831 else if (first == '+')2832 first = '-';2833 }28342835 switch (first) {2836 case '\n':2837 /* Newer GNU diff, empty context line */2838 if (plen < 0)2839 /* ... followed by '\No newline'; nothing */2840 break;2841 *old++ = '\n';2842 strbuf_addch(&newlines, '\n');2843 add_line_info(&preimage, "\n", 1, LINE_COMMON);2844 add_line_info(&postimage, "\n", 1, LINE_COMMON);2845 is_blank_context = 1;2846 break;2847 case ' ':2848 if (plen && (ws_rule & WS_BLANK_AT_EOF) &&2849 ws_blank_line(patch + 1, plen, ws_rule))2850 is_blank_context = 1;2851 case '-':2852 memcpy(old, patch + 1, plen);2853 add_line_info(&preimage, old, plen,2854 (first == ' ' ? LINE_COMMON : 0));2855 old += plen;2856 if (first == '-')2857 break;2858 /* Fall-through for ' ' */2859 case '+':2860 /* --no-add does not add new lines */2861 if (first == '+' && state->no_add)2862 break;28632864 start = newlines.len;2865 if (first != '+' ||2866 !state->whitespace_error ||2867 state->ws_error_action != correct_ws_error) {2868 strbuf_add(&newlines, patch + 1, plen);2869 }2870 else {2871 ws_fix_copy(&newlines, patch + 1, plen, ws_rule, &state->applied_after_fixing_ws);2872 }2873 add_line_info(&postimage, newlines.buf + start, newlines.len - start,2874 (first == '+' ? 0 : LINE_COMMON));2875 if (first == '+' &&2876 (ws_rule & WS_BLANK_AT_EOF) &&2877 ws_blank_line(patch + 1, plen, ws_rule))2878 added_blank_line = 1;2879 break;2880 case '@': case '\\':2881 /* Ignore it, we already handled it */2882 break;2883 default:2884 if (state->apply_verbosely)2885 error(_("invalid start of line: '%c'"), first);2886 applied_pos = -1;2887 goto out;2888 }2889 if (added_blank_line) {2890 if (!new_blank_lines_at_end)2891 found_new_blank_lines_at_end = hunk_linenr;2892 new_blank_lines_at_end++;2893 }2894 else if (is_blank_context)2895 ;2896 else2897 new_blank_lines_at_end = 0;2898 patch += len;2899 size -= len;2900 hunk_linenr++;2901 }2902 if (inaccurate_eof &&2903 old > oldlines && old[-1] == '\n' &&2904 newlines.len > 0 && newlines.buf[newlines.len - 1] == '\n') {2905 old--;2906 strbuf_setlen(&newlines, newlines.len - 1);2907 }29082909 leading = frag->leading;2910 trailing = frag->trailing;29112912 /*2913 * A hunk to change lines at the beginning would begin with2914 * @@ -1,L +N,M @@2915 * but we need to be careful. -U0 that inserts before the second2916 * line also has this pattern.2917 *2918 * And a hunk to add to an empty file would begin with2919 * @@ -0,0 +N,M @@2920 *2921 * In other words, a hunk that is (frag->oldpos <= 1) with or2922 * without leading context must match at the beginning.2923 */2924 match_beginning = (!frag->oldpos ||2925 (frag->oldpos == 1 && !state->unidiff_zero));29262927 /*2928 * A hunk without trailing lines must match at the end.2929 * However, we simply cannot tell if a hunk must match end2930 * from the lack of trailing lines if the patch was generated2931 * with unidiff without any context.2932 */2933 match_end = !state->unidiff_zero && !trailing;29342935 pos = frag->newpos ? (frag->newpos - 1) : 0;2936 preimage.buf = oldlines;2937 preimage.len = old - oldlines;2938 postimage.buf = newlines.buf;2939 postimage.len = newlines.len;2940 preimage.line = preimage.line_allocated;2941 postimage.line = postimage.line_allocated;29422943 for (;;) {29442945 applied_pos = find_pos(state, img, &preimage, &postimage, pos,2946 ws_rule, match_beginning, match_end);29472948 if (applied_pos >= 0)2949 break;29502951 /* Am I at my context limits? */2952 if ((leading <= state->p_context) && (trailing <= state->p_context))2953 break;2954 if (match_beginning || match_end) {2955 match_beginning = match_end = 0;2956 continue;2957 }29582959 /*2960 * Reduce the number of context lines; reduce both2961 * leading and trailing if they are equal otherwise2962 * just reduce the larger context.2963 */2964 if (leading >= trailing) {2965 remove_first_line(&preimage);2966 remove_first_line(&postimage);2967 pos--;2968 leading--;2969 }2970 if (trailing > leading) {2971 remove_last_line(&preimage);2972 remove_last_line(&postimage);2973 trailing--;2974 }2975 }29762977 if (applied_pos >= 0) {2978 if (new_blank_lines_at_end &&2979 preimage.nr + applied_pos >= img->nr &&2980 (ws_rule & WS_BLANK_AT_EOF) &&2981 state->ws_error_action != nowarn_ws_error) {2982 record_ws_error(state, WS_BLANK_AT_EOF, "+", 1,2983 found_new_blank_lines_at_end);2984 if (state->ws_error_action == correct_ws_error) {2985 while (new_blank_lines_at_end--)2986 remove_last_line(&postimage);2987 }2988 /*2989 * We would want to prevent write_out_results()2990 * from taking place in apply_patch() that follows2991 * the callchain led us here, which is:2992 * apply_patch->check_patch_list->check_patch->2993 * apply_data->apply_fragments->apply_one_fragment2994 */2995 if (state->ws_error_action == die_on_ws_error)2996 state->apply = 0;2997 }29982999 if (state->apply_verbosely && applied_pos != pos) {3000 int offset = applied_pos - pos;3001 if (state->apply_in_reverse)3002 offset = 0 - offset;3003 fprintf_ln(stderr,3004 Q_("Hunk #%d succeeded at %d (offset %d line).",3005 "Hunk #%d succeeded at %d (offset %d lines).",3006 offset),3007 nth_fragment, applied_pos + 1, offset);3008 }30093010 /*3011 * Warn if it was necessary to reduce the number3012 * of context lines.3013 */3014 if ((leading != frag->leading) ||3015 (trailing != frag->trailing))3016 fprintf_ln(stderr, _("Context reduced to (%ld/%ld)"3017 " to apply fragment at %d"),3018 leading, trailing, applied_pos+1);3019 update_image(state, img, applied_pos, &preimage, &postimage);3020 } else {3021 if (state->apply_verbosely)3022 error(_("while searching for:\n%.*s"),3023 (int)(old - oldlines), oldlines);3024 }30253026out:3027 free(oldlines);3028 strbuf_release(&newlines);3029 free(preimage.line_allocated);3030 free(postimage.line_allocated);30313032 return (applied_pos < 0);3033}30343035static int apply_binary_fragment(struct apply_state *state,3036 struct image *img,3037 struct patch *patch)3038{3039 struct fragment *fragment = patch->fragments;3040 unsigned long len;3041 void *dst;30423043 if (!fragment)3044 return error(_("missing binary patch data for '%s'"),3045 patch->new_name ?3046 patch->new_name :3047 patch->old_name);30483049 /* Binary patch is irreversible without the optional second hunk */3050 if (state->apply_in_reverse) {3051 if (!fragment->next)3052 return error("cannot reverse-apply a binary patch "3053 "without the reverse hunk to '%s'",3054 patch->new_name3055 ? patch->new_name : patch->old_name);3056 fragment = fragment->next;3057 }3058 switch (fragment->binary_patch_method) {3059 case BINARY_DELTA_DEFLATED:3060 dst = patch_delta(img->buf, img->len, fragment->patch,3061 fragment->size, &len);3062 if (!dst)3063 return -1;3064 clear_image(img);3065 img->buf = dst;3066 img->len = len;3067 return 0;3068 case BINARY_LITERAL_DEFLATED:3069 clear_image(img);3070 img->len = fragment->size;3071 img->buf = xmemdupz(fragment->patch, img->len);3072 return 0;3073 }3074 return -1;3075}30763077/*3078 * Replace "img" with the result of applying the binary patch.3079 * The binary patch data itself in patch->fragment is still kept3080 * but the preimage prepared by the caller in "img" is freed here3081 * or in the helper function apply_binary_fragment() this calls.3082 */3083static int apply_binary(struct apply_state *state,3084 struct image *img,3085 struct patch *patch)3086{3087 const char *name = patch->old_name ? patch->old_name : patch->new_name;3088 unsigned char sha1[20];30893090 /*3091 * For safety, we require patch index line to contain3092 * full 40-byte textual SHA1 for old and new, at least for now.3093 */3094 if (strlen(patch->old_sha1_prefix) != 40 ||3095 strlen(patch->new_sha1_prefix) != 40 ||3096 get_sha1_hex(patch->old_sha1_prefix, sha1) ||3097 get_sha1_hex(patch->new_sha1_prefix, sha1))3098 return error("cannot apply binary patch to '%s' "3099 "without full index line", name);31003101 if (patch->old_name) {3102 /*3103 * See if the old one matches what the patch3104 * applies to.3105 */3106 hash_sha1_file(img->buf, img->len, blob_type, sha1);3107 if (strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))3108 return error("the patch applies to '%s' (%s), "3109 "which does not match the "3110 "current contents.",3111 name, sha1_to_hex(sha1));3112 }3113 else {3114 /* Otherwise, the old one must be empty. */3115 if (img->len)3116 return error("the patch applies to an empty "3117 "'%s' but it is not empty", name);3118 }31193120 get_sha1_hex(patch->new_sha1_prefix, sha1);3121 if (is_null_sha1(sha1)) {3122 clear_image(img);3123 return 0; /* deletion patch */3124 }31253126 if (has_sha1_file(sha1)) {3127 /* We already have the postimage */3128 enum object_type type;3129 unsigned long size;3130 char *result;31313132 result = read_sha1_file(sha1, &type, &size);3133 if (!result)3134 return error("the necessary postimage %s for "3135 "'%s' cannot be read",3136 patch->new_sha1_prefix, name);3137 clear_image(img);3138 img->buf = result;3139 img->len = size;3140 } else {3141 /*3142 * We have verified buf matches the preimage;3143 * apply the patch data to it, which is stored3144 * in the patch->fragments->{patch,size}.3145 */3146 if (apply_binary_fragment(state, img, patch))3147 return error(_("binary patch does not apply to '%s'"),3148 name);31493150 /* verify that the result matches */3151 hash_sha1_file(img->buf, img->len, blob_type, sha1);3152 if (strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))3153 return error(_("binary patch to '%s' creates incorrect result (expecting %s, got %s)"),3154 name, patch->new_sha1_prefix, sha1_to_hex(sha1));3155 }31563157 return 0;3158}31593160static int apply_fragments(struct apply_state *state, struct image *img, struct patch *patch)3161{3162 struct fragment *frag = patch->fragments;3163 const char *name = patch->old_name ? patch->old_name : patch->new_name;3164 unsigned ws_rule = patch->ws_rule;3165 unsigned inaccurate_eof = patch->inaccurate_eof;3166 int nth = 0;31673168 if (patch->is_binary)3169 return apply_binary(state, img, patch);31703171 while (frag) {3172 nth++;3173 if (apply_one_fragment(state, img, frag, inaccurate_eof, ws_rule, nth)) {3174 error(_("patch failed: %s:%ld"), name, frag->oldpos);3175 if (!state->apply_with_reject)3176 return -1;3177 frag->rejected = 1;3178 }3179 frag = frag->next;3180 }3181 return 0;3182}31833184static int read_blob_object(struct strbuf *buf, const unsigned char *sha1, unsigned mode)3185{3186 if (S_ISGITLINK(mode)) {3187 strbuf_grow(buf, 100);3188 strbuf_addf(buf, "Subproject commit %s\n", sha1_to_hex(sha1));3189 } else {3190 enum object_type type;3191 unsigned long sz;3192 char *result;31933194 result = read_sha1_file(sha1, &type, &sz);3195 if (!result)3196 return -1;3197 /* XXX read_sha1_file NUL-terminates */3198 strbuf_attach(buf, result, sz, sz + 1);3199 }3200 return 0;3201}32023203static int read_file_or_gitlink(const struct cache_entry *ce, struct strbuf *buf)3204{3205 if (!ce)3206 return 0;3207 return read_blob_object(buf, ce->sha1, ce->ce_mode);3208}32093210static struct patch *in_fn_table(const char *name)3211{3212 struct string_list_item *item;32133214 if (name == NULL)3215 return NULL;32163217 item = string_list_lookup(&fn_table, name);3218 if (item != NULL)3219 return (struct patch *)item->util;32203221 return NULL;3222}32233224/*3225 * item->util in the filename table records the status of the path.3226 * Usually it points at a patch (whose result records the contents3227 * of it after applying it), but it could be PATH_WAS_DELETED for a3228 * path that a previously applied patch has already removed, or3229 * PATH_TO_BE_DELETED for a path that a later patch would remove.3230 *3231 * The latter is needed to deal with a case where two paths A and B3232 * are swapped by first renaming A to B and then renaming B to A;3233 * moving A to B should not be prevented due to presence of B as we3234 * will remove it in a later patch.3235 */3236#define PATH_TO_BE_DELETED ((struct patch *) -2)3237#define PATH_WAS_DELETED ((struct patch *) -1)32383239static int to_be_deleted(struct patch *patch)3240{3241 return patch == PATH_TO_BE_DELETED;3242}32433244static int was_deleted(struct patch *patch)3245{3246 return patch == PATH_WAS_DELETED;3247}32483249static void add_to_fn_table(struct patch *patch)3250{3251 struct string_list_item *item;32523253 /*3254 * Always add new_name unless patch is a deletion3255 * This should cover the cases for normal diffs,3256 * file creations and copies3257 */3258 if (patch->new_name != NULL) {3259 item = string_list_insert(&fn_table, patch->new_name);3260 item->util = patch;3261 }32623263 /*3264 * store a failure on rename/deletion cases because3265 * later chunks shouldn't patch old names3266 */3267 if ((patch->new_name == NULL) || (patch->is_rename)) {3268 item = string_list_insert(&fn_table, patch->old_name);3269 item->util = PATH_WAS_DELETED;3270 }3271}32723273static void prepare_fn_table(struct patch *patch)3274{3275 /*3276 * store information about incoming file deletion3277 */3278 while (patch) {3279 if ((patch->new_name == NULL) || (patch->is_rename)) {3280 struct string_list_item *item;3281 item = string_list_insert(&fn_table, patch->old_name);3282 item->util = PATH_TO_BE_DELETED;3283 }3284 patch = patch->next;3285 }3286}32873288static int checkout_target(struct index_state *istate,3289 struct cache_entry *ce, struct stat *st)3290{3291 struct checkout costate;32923293 memset(&costate, 0, sizeof(costate));3294 costate.base_dir = "";3295 costate.refresh_cache = 1;3296 costate.istate = istate;3297 if (checkout_entry(ce, &costate, NULL) || lstat(ce->name, st))3298 return error(_("cannot checkout %s"), ce->name);3299 return 0;3300}33013302static struct patch *previous_patch(struct patch *patch, int *gone)3303{3304 struct patch *previous;33053306 *gone = 0;3307 if (patch->is_copy || patch->is_rename)3308 return NULL; /* "git" patches do not depend on the order */33093310 previous = in_fn_table(patch->old_name);3311 if (!previous)3312 return NULL;33133314 if (to_be_deleted(previous))3315 return NULL; /* the deletion hasn't happened yet */33163317 if (was_deleted(previous))3318 *gone = 1;33193320 return previous;3321}33223323static int verify_index_match(const struct cache_entry *ce, struct stat *st)3324{3325 if (S_ISGITLINK(ce->ce_mode)) {3326 if (!S_ISDIR(st->st_mode))3327 return -1;3328 return 0;3329 }3330 return ce_match_stat(ce, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);3331}33323333#define SUBMODULE_PATCH_WITHOUT_INDEX 133343335static int load_patch_target(struct apply_state *state,3336 struct strbuf *buf,3337 const struct cache_entry *ce,3338 struct stat *st,3339 const char *name,3340 unsigned expected_mode)3341{3342 if (state->cached || state->check_index) {3343 if (read_file_or_gitlink(ce, buf))3344 return error(_("read of %s failed"), name);3345 } else if (name) {3346 if (S_ISGITLINK(expected_mode)) {3347 if (ce)3348 return read_file_or_gitlink(ce, buf);3349 else3350 return SUBMODULE_PATCH_WITHOUT_INDEX;3351 } else if (has_symlink_leading_path(name, strlen(name))) {3352 return error(_("reading from '%s' beyond a symbolic link"), name);3353 } else {3354 if (read_old_data(st, name, buf))3355 return error(_("read of %s failed"), name);3356 }3357 }3358 return 0;3359}33603361/*3362 * We are about to apply "patch"; populate the "image" with the3363 * current version we have, from the working tree or from the index,3364 * depending on the situation e.g. --cached/--index. If we are3365 * applying a non-git patch that incrementally updates the tree,3366 * we read from the result of a previous diff.3367 */3368static int load_preimage(struct apply_state *state,3369 struct image *image,3370 struct patch *patch, struct stat *st,3371 const struct cache_entry *ce)3372{3373 struct strbuf buf = STRBUF_INIT;3374 size_t len;3375 char *img;3376 struct patch *previous;3377 int status;33783379 previous = previous_patch(patch, &status);3380 if (status)3381 return error(_("path %s has been renamed/deleted"),3382 patch->old_name);3383 if (previous) {3384 /* We have a patched copy in memory; use that. */3385 strbuf_add(&buf, previous->result, previous->resultsize);3386 } else {3387 status = load_patch_target(state, &buf, ce, st,3388 patch->old_name, patch->old_mode);3389 if (status < 0)3390 return status;3391 else if (status == SUBMODULE_PATCH_WITHOUT_INDEX) {3392 /*3393 * There is no way to apply subproject3394 * patch without looking at the index.3395 * NEEDSWORK: shouldn't this be flagged3396 * as an error???3397 */3398 free_fragment_list(patch->fragments);3399 patch->fragments = NULL;3400 } else if (status) {3401 return error(_("read of %s failed"), patch->old_name);3402 }3403 }34043405 img = strbuf_detach(&buf, &len);3406 prepare_image(image, img, len, !patch->is_binary);3407 return 0;3408}34093410static int three_way_merge(struct image *image,3411 char *path,3412 const unsigned char *base,3413 const unsigned char *ours,3414 const unsigned char *theirs)3415{3416 mmfile_t base_file, our_file, their_file;3417 mmbuffer_t result = { NULL };3418 int status;34193420 read_mmblob(&base_file, base);3421 read_mmblob(&our_file, ours);3422 read_mmblob(&their_file, theirs);3423 status = ll_merge(&result, path,3424 &base_file, "base",3425 &our_file, "ours",3426 &their_file, "theirs", NULL);3427 free(base_file.ptr);3428 free(our_file.ptr);3429 free(their_file.ptr);3430 if (status < 0 || !result.ptr) {3431 free(result.ptr);3432 return -1;3433 }3434 clear_image(image);3435 image->buf = result.ptr;3436 image->len = result.size;34373438 return status;3439}34403441/*3442 * When directly falling back to add/add three-way merge, we read from3443 * the current contents of the new_name. In no cases other than that3444 * this function will be called.3445 */3446static int load_current(struct apply_state *state,3447 struct image *image,3448 struct patch *patch)3449{3450 struct strbuf buf = STRBUF_INIT;3451 int status, pos;3452 size_t len;3453 char *img;3454 struct stat st;3455 struct cache_entry *ce;3456 char *name = patch->new_name;3457 unsigned mode = patch->new_mode;34583459 if (!patch->is_new)3460 die("BUG: patch to %s is not a creation", patch->old_name);34613462 pos = cache_name_pos(name, strlen(name));3463 if (pos < 0)3464 return error(_("%s: does not exist in index"), name);3465 ce = active_cache[pos];3466 if (lstat(name, &st)) {3467 if (errno != ENOENT)3468 return error(_("%s: %s"), name, strerror(errno));3469 if (checkout_target(&the_index, ce, &st))3470 return -1;3471 }3472 if (verify_index_match(ce, &st))3473 return error(_("%s: does not match index"), name);34743475 status = load_patch_target(state, &buf, ce, &st, name, mode);3476 if (status < 0)3477 return status;3478 else if (status)3479 return -1;3480 img = strbuf_detach(&buf, &len);3481 prepare_image(image, img, len, !patch->is_binary);3482 return 0;3483}34843485static int try_threeway(struct apply_state *state,3486 struct image *image,3487 struct patch *patch,3488 struct stat *st,3489 const struct cache_entry *ce)3490{3491 unsigned char pre_sha1[20], post_sha1[20], our_sha1[20];3492 struct strbuf buf = STRBUF_INIT;3493 size_t len;3494 int status;3495 char *img;3496 struct image tmp_image;34973498 /* No point falling back to 3-way merge in these cases */3499 if (patch->is_delete ||3500 S_ISGITLINK(patch->old_mode) || S_ISGITLINK(patch->new_mode))3501 return -1;35023503 /* Preimage the patch was prepared for */3504 if (patch->is_new)3505 write_sha1_file("", 0, blob_type, pre_sha1);3506 else if (get_sha1(patch->old_sha1_prefix, pre_sha1) ||3507 read_blob_object(&buf, pre_sha1, patch->old_mode))3508 return error("repository lacks the necessary blob to fall back on 3-way merge.");35093510 fprintf(stderr, "Falling back to three-way merge...\n");35113512 img = strbuf_detach(&buf, &len);3513 prepare_image(&tmp_image, img, len, 1);3514 /* Apply the patch to get the post image */3515 if (apply_fragments(state, &tmp_image, patch) < 0) {3516 clear_image(&tmp_image);3517 return -1;3518 }3519 /* post_sha1[] is theirs */3520 write_sha1_file(tmp_image.buf, tmp_image.len, blob_type, post_sha1);3521 clear_image(&tmp_image);35223523 /* our_sha1[] is ours */3524 if (patch->is_new) {3525 if (load_current(state, &tmp_image, patch))3526 return error("cannot read the current contents of '%s'",3527 patch->new_name);3528 } else {3529 if (load_preimage(state, &tmp_image, patch, st, ce))3530 return error("cannot read the current contents of '%s'",3531 patch->old_name);3532 }3533 write_sha1_file(tmp_image.buf, tmp_image.len, blob_type, our_sha1);3534 clear_image(&tmp_image);35353536 /* in-core three-way merge between post and our using pre as base */3537 status = three_way_merge(image, patch->new_name,3538 pre_sha1, our_sha1, post_sha1);3539 if (status < 0) {3540 fprintf(stderr, "Failed to fall back on three-way merge...\n");3541 return status;3542 }35433544 if (status) {3545 patch->conflicted_threeway = 1;3546 if (patch->is_new)3547 oidclr(&patch->threeway_stage[0]);3548 else3549 hashcpy(patch->threeway_stage[0].hash, pre_sha1);3550 hashcpy(patch->threeway_stage[1].hash, our_sha1);3551 hashcpy(patch->threeway_stage[2].hash, post_sha1);3552 fprintf(stderr, "Applied patch to '%s' with conflicts.\n", patch->new_name);3553 } else {3554 fprintf(stderr, "Applied patch to '%s' cleanly.\n", patch->new_name);3555 }3556 return 0;3557}35583559static int apply_data(struct apply_state *state, struct patch *patch,3560 struct stat *st, const struct cache_entry *ce)3561{3562 struct image image;35633564 if (load_preimage(state, &image, patch, st, ce) < 0)3565 return -1;35663567 if (patch->direct_to_threeway ||3568 apply_fragments(state, &image, patch) < 0) {3569 /* Note: with --reject, apply_fragments() returns 0 */3570 if (!state->threeway || try_threeway(state, &image, patch, st, ce) < 0)3571 return -1;3572 }3573 patch->result = image.buf;3574 patch->resultsize = image.len;3575 add_to_fn_table(patch);3576 free(image.line_allocated);35773578 if (0 < patch->is_delete && patch->resultsize)3579 return error(_("removal patch leaves file contents"));35803581 return 0;3582}35833584/*3585 * If "patch" that we are looking at modifies or deletes what we have,3586 * we would want it not to lose any local modification we have, either3587 * in the working tree or in the index.3588 *3589 * This also decides if a non-git patch is a creation patch or a3590 * modification to an existing empty file. We do not check the state3591 * of the current tree for a creation patch in this function; the caller3592 * check_patch() separately makes sure (and errors out otherwise) that3593 * the path the patch creates does not exist in the current tree.3594 */3595static int check_preimage(struct apply_state *state,3596 struct patch *patch,3597 struct cache_entry **ce,3598 struct stat *st)3599{3600 const char *old_name = patch->old_name;3601 struct patch *previous = NULL;3602 int stat_ret = 0, status;3603 unsigned st_mode = 0;36043605 if (!old_name)3606 return 0;36073608 assert(patch->is_new <= 0);3609 previous = previous_patch(patch, &status);36103611 if (status)3612 return error(_("path %s has been renamed/deleted"), old_name);3613 if (previous) {3614 st_mode = previous->new_mode;3615 } else if (!state->cached) {3616 stat_ret = lstat(old_name, st);3617 if (stat_ret && errno != ENOENT)3618 return error(_("%s: %s"), old_name, strerror(errno));3619 }36203621 if (state->check_index && !previous) {3622 int pos = cache_name_pos(old_name, strlen(old_name));3623 if (pos < 0) {3624 if (patch->is_new < 0)3625 goto is_new;3626 return error(_("%s: does not exist in index"), old_name);3627 }3628 *ce = active_cache[pos];3629 if (stat_ret < 0) {3630 if (checkout_target(&the_index, *ce, st))3631 return -1;3632 }3633 if (!state->cached && verify_index_match(*ce, st))3634 return error(_("%s: does not match index"), old_name);3635 if (state->cached)3636 st_mode = (*ce)->ce_mode;3637 } else if (stat_ret < 0) {3638 if (patch->is_new < 0)3639 goto is_new;3640 return error(_("%s: %s"), old_name, strerror(errno));3641 }36423643 if (!state->cached && !previous)3644 st_mode = ce_mode_from_stat(*ce, st->st_mode);36453646 if (patch->is_new < 0)3647 patch->is_new = 0;3648 if (!patch->old_mode)3649 patch->old_mode = st_mode;3650 if ((st_mode ^ patch->old_mode) & S_IFMT)3651 return error(_("%s: wrong type"), old_name);3652 if (st_mode != patch->old_mode)3653 warning(_("%s has type %o, expected %o"),3654 old_name, st_mode, patch->old_mode);3655 if (!patch->new_mode && !patch->is_delete)3656 patch->new_mode = st_mode;3657 return 0;36583659 is_new:3660 patch->is_new = 1;3661 patch->is_delete = 0;3662 free(patch->old_name);3663 patch->old_name = NULL;3664 return 0;3665}366636673668#define EXISTS_IN_INDEX 13669#define EXISTS_IN_WORKTREE 236703671static int check_to_create(struct apply_state *state,3672 const char *new_name,3673 int ok_if_exists)3674{3675 struct stat nst;36763677 if (state->check_index &&3678 cache_name_pos(new_name, strlen(new_name)) >= 0 &&3679 !ok_if_exists)3680 return EXISTS_IN_INDEX;3681 if (state->cached)3682 return 0;36833684 if (!lstat(new_name, &nst)) {3685 if (S_ISDIR(nst.st_mode) || ok_if_exists)3686 return 0;3687 /*3688 * A leading component of new_name might be a symlink3689 * that is going to be removed with this patch, but3690 * still pointing at somewhere that has the path.3691 * In such a case, path "new_name" does not exist as3692 * far as git is concerned.3693 */3694 if (has_symlink_leading_path(new_name, strlen(new_name)))3695 return 0;36963697 return EXISTS_IN_WORKTREE;3698 } else if ((errno != ENOENT) && (errno != ENOTDIR)) {3699 return error("%s: %s", new_name, strerror(errno));3700 }3701 return 0;3702}37033704/*3705 * We need to keep track of how symlinks in the preimage are3706 * manipulated by the patches. A patch to add a/b/c where a/b3707 * is a symlink should not be allowed to affect the directory3708 * the symlink points at, but if the same patch removes a/b,3709 * it is perfectly fine, as the patch removes a/b to make room3710 * to create a directory a/b so that a/b/c can be created.3711 */3712static struct string_list symlink_changes;3713#define SYMLINK_GOES_AWAY 013714#define SYMLINK_IN_RESULT 0237153716static uintptr_t register_symlink_changes(const char *path, uintptr_t what)3717{3718 struct string_list_item *ent;37193720 ent = string_list_lookup(&symlink_changes, path);3721 if (!ent) {3722 ent = string_list_insert(&symlink_changes, path);3723 ent->util = (void *)0;3724 }3725 ent->util = (void *)(what | ((uintptr_t)ent->util));3726 return (uintptr_t)ent->util;3727}37283729static uintptr_t check_symlink_changes(const char *path)3730{3731 struct string_list_item *ent;37323733 ent = string_list_lookup(&symlink_changes, path);3734 if (!ent)3735 return 0;3736 return (uintptr_t)ent->util;3737}37383739static void prepare_symlink_changes(struct patch *patch)3740{3741 for ( ; patch; patch = patch->next) {3742 if ((patch->old_name && S_ISLNK(patch->old_mode)) &&3743 (patch->is_rename || patch->is_delete))3744 /* the symlink at patch->old_name is removed */3745 register_symlink_changes(patch->old_name, SYMLINK_GOES_AWAY);37463747 if (patch->new_name && S_ISLNK(patch->new_mode))3748 /* the symlink at patch->new_name is created or remains */3749 register_symlink_changes(patch->new_name, SYMLINK_IN_RESULT);3750 }3751}37523753static int path_is_beyond_symlink_1(struct apply_state *state, struct strbuf *name)3754{3755 do {3756 unsigned int change;37573758 while (--name->len && name->buf[name->len] != '/')3759 ; /* scan backwards */3760 if (!name->len)3761 break;3762 name->buf[name->len] = '\0';3763 change = check_symlink_changes(name->buf);3764 if (change & SYMLINK_IN_RESULT)3765 return 1;3766 if (change & SYMLINK_GOES_AWAY)3767 /*3768 * This cannot be "return 0", because we may3769 * see a new one created at a higher level.3770 */3771 continue;37723773 /* otherwise, check the preimage */3774 if (state->check_index) {3775 struct cache_entry *ce;37763777 ce = cache_file_exists(name->buf, name->len, ignore_case);3778 if (ce && S_ISLNK(ce->ce_mode))3779 return 1;3780 } else {3781 struct stat st;3782 if (!lstat(name->buf, &st) && S_ISLNK(st.st_mode))3783 return 1;3784 }3785 } while (1);3786 return 0;3787}37883789static int path_is_beyond_symlink(struct apply_state *state, const char *name_)3790{3791 int ret;3792 struct strbuf name = STRBUF_INIT;37933794 assert(*name_ != '\0');3795 strbuf_addstr(&name, name_);3796 ret = path_is_beyond_symlink_1(state, &name);3797 strbuf_release(&name);37983799 return ret;3800}38013802static void die_on_unsafe_path(struct patch *patch)3803{3804 const char *old_name = NULL;3805 const char *new_name = NULL;3806 if (patch->is_delete)3807 old_name = patch->old_name;3808 else if (!patch->is_new && !patch->is_copy)3809 old_name = patch->old_name;3810 if (!patch->is_delete)3811 new_name = patch->new_name;38123813 if (old_name && !verify_path(old_name))3814 die(_("invalid path '%s'"), old_name);3815 if (new_name && !verify_path(new_name))3816 die(_("invalid path '%s'"), new_name);3817}38183819/*3820 * Check and apply the patch in-core; leave the result in patch->result3821 * for the caller to write it out to the final destination.3822 */3823static int check_patch(struct apply_state *state, struct patch *patch)3824{3825 struct stat st;3826 const char *old_name = patch->old_name;3827 const char *new_name = patch->new_name;3828 const char *name = old_name ? old_name : new_name;3829 struct cache_entry *ce = NULL;3830 struct patch *tpatch;3831 int ok_if_exists;3832 int status;38333834 patch->rejected = 1; /* we will drop this after we succeed */38353836 status = check_preimage(state, patch, &ce, &st);3837 if (status)3838 return status;3839 old_name = patch->old_name;38403841 /*3842 * A type-change diff is always split into a patch to delete3843 * old, immediately followed by a patch to create new (see3844 * diff.c::run_diff()); in such a case it is Ok that the entry3845 * to be deleted by the previous patch is still in the working3846 * tree and in the index.3847 *3848 * A patch to swap-rename between A and B would first rename A3849 * to B and then rename B to A. While applying the first one,3850 * the presence of B should not stop A from getting renamed to3851 * B; ask to_be_deleted() about the later rename. Removal of3852 * B and rename from A to B is handled the same way by asking3853 * was_deleted().3854 */3855 if ((tpatch = in_fn_table(new_name)) &&3856 (was_deleted(tpatch) || to_be_deleted(tpatch)))3857 ok_if_exists = 1;3858 else3859 ok_if_exists = 0;38603861 if (new_name &&3862 ((0 < patch->is_new) || patch->is_rename || patch->is_copy)) {3863 int err = check_to_create(state, new_name, ok_if_exists);38643865 if (err && state->threeway) {3866 patch->direct_to_threeway = 1;3867 } else switch (err) {3868 case 0:3869 break; /* happy */3870 case EXISTS_IN_INDEX:3871 return error(_("%s: already exists in index"), new_name);3872 break;3873 case EXISTS_IN_WORKTREE:3874 return error(_("%s: already exists in working directory"),3875 new_name);3876 default:3877 return err;3878 }38793880 if (!patch->new_mode) {3881 if (0 < patch->is_new)3882 patch->new_mode = S_IFREG | 0644;3883 else3884 patch->new_mode = patch->old_mode;3885 }3886 }38873888 if (new_name && old_name) {3889 int same = !strcmp(old_name, new_name);3890 if (!patch->new_mode)3891 patch->new_mode = patch->old_mode;3892 if ((patch->old_mode ^ patch->new_mode) & S_IFMT) {3893 if (same)3894 return error(_("new mode (%o) of %s does not "3895 "match old mode (%o)"),3896 patch->new_mode, new_name,3897 patch->old_mode);3898 else3899 return error(_("new mode (%o) of %s does not "3900 "match old mode (%o) of %s"),3901 patch->new_mode, new_name,3902 patch->old_mode, old_name);3903 }3904 }39053906 if (!state->unsafe_paths)3907 die_on_unsafe_path(patch);39083909 /*3910 * An attempt to read from or delete a path that is beyond a3911 * symbolic link will be prevented by load_patch_target() that3912 * is called at the beginning of apply_data() so we do not3913 * have to worry about a patch marked with "is_delete" bit3914 * here. We however need to make sure that the patch result3915 * is not deposited to a path that is beyond a symbolic link3916 * here.3917 */3918 if (!patch->is_delete && path_is_beyond_symlink(state, patch->new_name))3919 return error(_("affected file '%s' is beyond a symbolic link"),3920 patch->new_name);39213922 if (apply_data(state, patch, &st, ce) < 0)3923 return error(_("%s: patch does not apply"), name);3924 patch->rejected = 0;3925 return 0;3926}39273928static int check_patch_list(struct apply_state *state, struct patch *patch)3929{3930 int err = 0;39313932 prepare_symlink_changes(patch);3933 prepare_fn_table(patch);3934 while (patch) {3935 if (state->apply_verbosely)3936 say_patch_name(stderr,3937 _("Checking patch %s..."), patch);3938 err |= check_patch(state, patch);3939 patch = patch->next;3940 }3941 return err;3942}39433944/* This function tries to read the sha1 from the current index */3945static int get_current_sha1(const char *path, unsigned char *sha1)3946{3947 int pos;39483949 if (read_cache() < 0)3950 return -1;3951 pos = cache_name_pos(path, strlen(path));3952 if (pos < 0)3953 return -1;3954 hashcpy(sha1, active_cache[pos]->sha1);3955 return 0;3956}39573958static int preimage_sha1_in_gitlink_patch(struct patch *p, unsigned char sha1[20])3959{3960 /*3961 * A usable gitlink patch has only one fragment (hunk) that looks like:3962 * @@ -1 +1 @@3963 * -Subproject commit <old sha1>3964 * +Subproject commit <new sha1>3965 * or3966 * @@ -1 +0,0 @@3967 * -Subproject commit <old sha1>3968 * for a removal patch.3969 */3970 struct fragment *hunk = p->fragments;3971 static const char heading[] = "-Subproject commit ";3972 char *preimage;39733974 if (/* does the patch have only one hunk? */3975 hunk && !hunk->next &&3976 /* is its preimage one line? */3977 hunk->oldpos == 1 && hunk->oldlines == 1 &&3978 /* does preimage begin with the heading? */3979 (preimage = memchr(hunk->patch, '\n', hunk->size)) != NULL &&3980 starts_with(++preimage, heading) &&3981 /* does it record full SHA-1? */3982 !get_sha1_hex(preimage + sizeof(heading) - 1, sha1) &&3983 preimage[sizeof(heading) + 40 - 1] == '\n' &&3984 /* does the abbreviated name on the index line agree with it? */3985 starts_with(preimage + sizeof(heading) - 1, p->old_sha1_prefix))3986 return 0; /* it all looks fine */39873988 /* we may have full object name on the index line */3989 return get_sha1_hex(p->old_sha1_prefix, sha1);3990}39913992/* Build an index that contains the just the files needed for a 3way merge */3993static void build_fake_ancestor(struct patch *list, const char *filename)3994{3995 struct patch *patch;3996 struct index_state result = { NULL };3997 static struct lock_file lock;39983999 /* Once we start supporting the reverse patch, it may be4000 * worth showing the new sha1 prefix, but until then...4001 */4002 for (patch = list; patch; patch = patch->next) {4003 unsigned char sha1[20];4004 struct cache_entry *ce;4005 const char *name;40064007 name = patch->old_name ? patch->old_name : patch->new_name;4008 if (0 < patch->is_new)4009 continue;40104011 if (S_ISGITLINK(patch->old_mode)) {4012 if (!preimage_sha1_in_gitlink_patch(patch, sha1))4013 ; /* ok, the textual part looks sane */4014 else4015 die("sha1 information is lacking or useless for submodule %s",4016 name);4017 } else if (!get_sha1_blob(patch->old_sha1_prefix, sha1)) {4018 ; /* ok */4019 } else if (!patch->lines_added && !patch->lines_deleted) {4020 /* mode-only change: update the current */4021 if (get_current_sha1(patch->old_name, sha1))4022 die("mode change for %s, which is not "4023 "in current HEAD", name);4024 } else4025 die("sha1 information is lacking or useless "4026 "(%s).", name);40274028 ce = make_cache_entry(patch->old_mode, sha1, name, 0, 0);4029 if (!ce)4030 die(_("make_cache_entry failed for path '%s'"), name);4031 if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))4032 die ("Could not add %s to temporary index", name);4033 }40344035 hold_lock_file_for_update(&lock, filename, LOCK_DIE_ON_ERROR);4036 if (write_locked_index(&result, &lock, COMMIT_LOCK))4037 die ("Could not write temporary index to %s", filename);40384039 discard_index(&result);4040}40414042static void stat_patch_list(struct apply_state *state, struct patch *patch)4043{4044 int files, adds, dels;40454046 for (files = adds = dels = 0 ; patch ; patch = patch->next) {4047 files++;4048 adds += patch->lines_added;4049 dels += patch->lines_deleted;4050 show_stats(state, patch);4051 }40524053 print_stat_summary(stdout, files, adds, dels);4054}40554056static void numstat_patch_list(struct apply_state *state,4057 struct patch *patch)4058{4059 for ( ; patch; patch = patch->next) {4060 const char *name;4061 name = patch->new_name ? patch->new_name : patch->old_name;4062 if (patch->is_binary)4063 printf("-\t-\t");4064 else4065 printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);4066 write_name_quoted(name, stdout, state->line_termination);4067 }4068}40694070static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)4071{4072 if (mode)4073 printf(" %s mode %06o %s\n", newdelete, mode, name);4074 else4075 printf(" %s %s\n", newdelete, name);4076}40774078static void show_mode_change(struct patch *p, int show_name)4079{4080 if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {4081 if (show_name)4082 printf(" mode change %06o => %06o %s\n",4083 p->old_mode, p->new_mode, p->new_name);4084 else4085 printf(" mode change %06o => %06o\n",4086 p->old_mode, p->new_mode);4087 }4088}40894090static void show_rename_copy(struct patch *p)4091{4092 const char *renamecopy = p->is_rename ? "rename" : "copy";4093 const char *old, *new;40944095 /* Find common prefix */4096 old = p->old_name;4097 new = p->new_name;4098 while (1) {4099 const char *slash_old, *slash_new;4100 slash_old = strchr(old, '/');4101 slash_new = strchr(new, '/');4102 if (!slash_old ||4103 !slash_new ||4104 slash_old - old != slash_new - new ||4105 memcmp(old, new, slash_new - new))4106 break;4107 old = slash_old + 1;4108 new = slash_new + 1;4109 }4110 /* p->old_name thru old is the common prefix, and old and new4111 * through the end of names are renames4112 */4113 if (old != p->old_name)4114 printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,4115 (int)(old - p->old_name), p->old_name,4116 old, new, p->score);4117 else4118 printf(" %s %s => %s (%d%%)\n", renamecopy,4119 p->old_name, p->new_name, p->score);4120 show_mode_change(p, 0);4121}41224123static void summary_patch_list(struct patch *patch)4124{4125 struct patch *p;41264127 for (p = patch; p; p = p->next) {4128 if (p->is_new)4129 show_file_mode_name("create", p->new_mode, p->new_name);4130 else if (p->is_delete)4131 show_file_mode_name("delete", p->old_mode, p->old_name);4132 else {4133 if (p->is_rename || p->is_copy)4134 show_rename_copy(p);4135 else {4136 if (p->score) {4137 printf(" rewrite %s (%d%%)\n",4138 p->new_name, p->score);4139 show_mode_change(p, 0);4140 }4141 else4142 show_mode_change(p, 1);4143 }4144 }4145 }4146}41474148static void patch_stats(struct apply_state *state, struct patch *patch)4149{4150 int lines = patch->lines_added + patch->lines_deleted;41514152 if (lines > state->max_change)4153 state->max_change = lines;4154 if (patch->old_name) {4155 int len = quote_c_style(patch->old_name, NULL, NULL, 0);4156 if (!len)4157 len = strlen(patch->old_name);4158 if (len > state->max_len)4159 state->max_len = len;4160 }4161 if (patch->new_name) {4162 int len = quote_c_style(patch->new_name, NULL, NULL, 0);4163 if (!len)4164 len = strlen(patch->new_name);4165 if (len > state->max_len)4166 state->max_len = len;4167 }4168}41694170static void remove_file(struct apply_state *state, struct patch *patch, int rmdir_empty)4171{4172 if (state->update_index) {4173 if (remove_file_from_cache(patch->old_name) < 0)4174 die(_("unable to remove %s from index"), patch->old_name);4175 }4176 if (!state->cached) {4177 if (!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) {4178 remove_path(patch->old_name);4179 }4180 }4181}41824183static void add_index_file(struct apply_state *state,4184 const char *path,4185 unsigned mode,4186 void *buf,4187 unsigned long size)4188{4189 struct stat st;4190 struct cache_entry *ce;4191 int namelen = strlen(path);4192 unsigned ce_size = cache_entry_size(namelen);41934194 if (!state->update_index)4195 return;41964197 ce = xcalloc(1, ce_size);4198 memcpy(ce->name, path, namelen);4199 ce->ce_mode = create_ce_mode(mode);4200 ce->ce_flags = create_ce_flags(0);4201 ce->ce_namelen = namelen;4202 if (S_ISGITLINK(mode)) {4203 const char *s;42044205 if (!skip_prefix(buf, "Subproject commit ", &s) ||4206 get_sha1_hex(s, ce->sha1))4207 die(_("corrupt patch for submodule %s"), path);4208 } else {4209 if (!state->cached) {4210 if (lstat(path, &st) < 0)4211 die_errno(_("unable to stat newly created file '%s'"),4212 path);4213 fill_stat_cache_info(ce, &st);4214 }4215 if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0)4216 die(_("unable to create backing store for newly created file %s"), path);4217 }4218 if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)4219 die(_("unable to add cache entry for %s"), path);4220}42214222static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)4223{4224 int fd;4225 struct strbuf nbuf = STRBUF_INIT;42264227 if (S_ISGITLINK(mode)) {4228 struct stat st;4229 if (!lstat(path, &st) && S_ISDIR(st.st_mode))4230 return 0;4231 return mkdir(path, 0777);4232 }42334234 if (has_symlinks && S_ISLNK(mode))4235 /* Although buf:size is counted string, it also is NUL4236 * terminated.4237 */4238 return symlink(buf, path);42394240 fd = open(path, O_CREAT | O_EXCL | O_WRONLY, (mode & 0100) ? 0777 : 0666);4241 if (fd < 0)4242 return -1;42434244 if (convert_to_working_tree(path, buf, size, &nbuf)) {4245 size = nbuf.len;4246 buf = nbuf.buf;4247 }4248 write_or_die(fd, buf, size);4249 strbuf_release(&nbuf);42504251 if (close(fd) < 0)4252 die_errno(_("closing file '%s'"), path);4253 return 0;4254}42554256/*4257 * We optimistically assume that the directories exist,4258 * which is true 99% of the time anyway. If they don't,4259 * we create them and try again.4260 */4261static void create_one_file(struct apply_state *state,4262 char *path,4263 unsigned mode,4264 const char *buf,4265 unsigned long size)4266{4267 if (state->cached)4268 return;4269 if (!try_create_file(path, mode, buf, size))4270 return;42714272 if (errno == ENOENT) {4273 if (safe_create_leading_directories(path))4274 return;4275 if (!try_create_file(path, mode, buf, size))4276 return;4277 }42784279 if (errno == EEXIST || errno == EACCES) {4280 /* We may be trying to create a file where a directory4281 * used to be.4282 */4283 struct stat st;4284 if (!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))4285 errno = EEXIST;4286 }42874288 if (errno == EEXIST) {4289 unsigned int nr = getpid();42904291 for (;;) {4292 char newpath[PATH_MAX];4293 mksnpath(newpath, sizeof(newpath), "%s~%u", path, nr);4294 if (!try_create_file(newpath, mode, buf, size)) {4295 if (!rename(newpath, path))4296 return;4297 unlink_or_warn(newpath);4298 break;4299 }4300 if (errno != EEXIST)4301 break;4302 ++nr;4303 }4304 }4305 die_errno(_("unable to write file '%s' mode %o"), path, mode);4306}43074308static void add_conflicted_stages_file(struct apply_state *state,4309 struct patch *patch)4310{4311 int stage, namelen;4312 unsigned ce_size, mode;4313 struct cache_entry *ce;43144315 if (!state->update_index)4316 return;4317 namelen = strlen(patch->new_name);4318 ce_size = cache_entry_size(namelen);4319 mode = patch->new_mode ? patch->new_mode : (S_IFREG | 0644);43204321 remove_file_from_cache(patch->new_name);4322 for (stage = 1; stage < 4; stage++) {4323 if (is_null_oid(&patch->threeway_stage[stage - 1]))4324 continue;4325 ce = xcalloc(1, ce_size);4326 memcpy(ce->name, patch->new_name, namelen);4327 ce->ce_mode = create_ce_mode(mode);4328 ce->ce_flags = create_ce_flags(stage);4329 ce->ce_namelen = namelen;4330 hashcpy(ce->sha1, patch->threeway_stage[stage - 1].hash);4331 if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)4332 die(_("unable to add cache entry for %s"), patch->new_name);4333 }4334}43354336static void create_file(struct apply_state *state, struct patch *patch)4337{4338 char *path = patch->new_name;4339 unsigned mode = patch->new_mode;4340 unsigned long size = patch->resultsize;4341 char *buf = patch->result;43424343 if (!mode)4344 mode = S_IFREG | 0644;4345 create_one_file(state, path, mode, buf, size);43464347 if (patch->conflicted_threeway)4348 add_conflicted_stages_file(state, patch);4349 else4350 add_index_file(state, path, mode, buf, size);4351}43524353/* phase zero is to remove, phase one is to create */4354static void write_out_one_result(struct apply_state *state,4355 struct patch *patch,4356 int phase)4357{4358 if (patch->is_delete > 0) {4359 if (phase == 0)4360 remove_file(state, patch, 1);4361 return;4362 }4363 if (patch->is_new > 0 || patch->is_copy) {4364 if (phase == 1)4365 create_file(state, patch);4366 return;4367 }4368 /*4369 * Rename or modification boils down to the same4370 * thing: remove the old, write the new4371 */4372 if (phase == 0)4373 remove_file(state, patch, patch->is_rename);4374 if (phase == 1)4375 create_file(state, patch);4376}43774378static int write_out_one_reject(struct apply_state *state, struct patch *patch)4379{4380 FILE *rej;4381 char namebuf[PATH_MAX];4382 struct fragment *frag;4383 int cnt = 0;4384 struct strbuf sb = STRBUF_INIT;43854386 for (cnt = 0, frag = patch->fragments; frag; frag = frag->next) {4387 if (!frag->rejected)4388 continue;4389 cnt++;4390 }43914392 if (!cnt) {4393 if (state->apply_verbosely)4394 say_patch_name(stderr,4395 _("Applied patch %s cleanly."), patch);4396 return 0;4397 }43984399 /* This should not happen, because a removal patch that leaves4400 * contents are marked "rejected" at the patch level.4401 */4402 if (!patch->new_name)4403 die(_("internal error"));44044405 /* Say this even without --verbose */4406 strbuf_addf(&sb, Q_("Applying patch %%s with %d reject...",4407 "Applying patch %%s with %d rejects...",4408 cnt),4409 cnt);4410 say_patch_name(stderr, sb.buf, patch);4411 strbuf_release(&sb);44124413 cnt = strlen(patch->new_name);4414 if (ARRAY_SIZE(namebuf) <= cnt + 5) {4415 cnt = ARRAY_SIZE(namebuf) - 5;4416 warning(_("truncating .rej filename to %.*s.rej"),4417 cnt - 1, patch->new_name);4418 }4419 memcpy(namebuf, patch->new_name, cnt);4420 memcpy(namebuf + cnt, ".rej", 5);44214422 rej = fopen(namebuf, "w");4423 if (!rej)4424 return error(_("cannot open %s: %s"), namebuf, strerror(errno));44254426 /* Normal git tools never deal with .rej, so do not pretend4427 * this is a git patch by saying --git or giving extended4428 * headers. While at it, maybe please "kompare" that wants4429 * the trailing TAB and some garbage at the end of line ;-).4430 */4431 fprintf(rej, "diff a/%s b/%s\t(rejected hunks)\n",4432 patch->new_name, patch->new_name);4433 for (cnt = 1, frag = patch->fragments;4434 frag;4435 cnt++, frag = frag->next) {4436 if (!frag->rejected) {4437 fprintf_ln(stderr, _("Hunk #%d applied cleanly."), cnt);4438 continue;4439 }4440 fprintf_ln(stderr, _("Rejected hunk #%d."), cnt);4441 fprintf(rej, "%.*s", frag->size, frag->patch);4442 if (frag->patch[frag->size-1] != '\n')4443 fputc('\n', rej);4444 }4445 fclose(rej);4446 return -1;4447}44484449static int write_out_results(struct apply_state *state, struct patch *list)4450{4451 int phase;4452 int errs = 0;4453 struct patch *l;4454 struct string_list cpath = STRING_LIST_INIT_DUP;44554456 for (phase = 0; phase < 2; phase++) {4457 l = list;4458 while (l) {4459 if (l->rejected)4460 errs = 1;4461 else {4462 write_out_one_result(state, l, phase);4463 if (phase == 1) {4464 if (write_out_one_reject(state, l))4465 errs = 1;4466 if (l->conflicted_threeway) {4467 string_list_append(&cpath, l->new_name);4468 errs = 1;4469 }4470 }4471 }4472 l = l->next;4473 }4474 }44754476 if (cpath.nr) {4477 struct string_list_item *item;44784479 string_list_sort(&cpath);4480 for_each_string_list_item(item, &cpath)4481 fprintf(stderr, "U %s\n", item->string);4482 string_list_clear(&cpath, 0);44834484 rerere(0);4485 }44864487 return errs;4488}44894490static struct lock_file lock_file;44914492#define INACCURATE_EOF (1<<0)4493#define RECOUNT (1<<1)44944495static int apply_patch(struct apply_state *state,4496 int fd,4497 const char *filename,4498 int options)4499{4500 size_t offset;4501 struct strbuf buf = STRBUF_INIT; /* owns the patch text */4502 struct patch *list = NULL, **listp = &list;4503 int skipped_patch = 0;45044505 state->patch_input_file = filename;4506 read_patch_file(&buf, fd);4507 offset = 0;4508 while (offset < buf.len) {4509 struct patch *patch;4510 int nr;45114512 patch = xcalloc(1, sizeof(*patch));4513 patch->inaccurate_eof = !!(options & INACCURATE_EOF);4514 patch->recount = !!(options & RECOUNT);4515 nr = parse_chunk(state, buf.buf + offset, buf.len - offset, patch);4516 if (nr < 0) {4517 free_patch(patch);4518 break;4519 }4520 if (state->apply_in_reverse)4521 reverse_patches(patch);4522 if (use_patch(state, patch)) {4523 patch_stats(state, patch);4524 *listp = patch;4525 listp = &patch->next;4526 }4527 else {4528 if (state->apply_verbosely)4529 say_patch_name(stderr, _("Skipped patch '%s'."), patch);4530 free_patch(patch);4531 skipped_patch++;4532 }4533 offset += nr;4534 }45354536 if (!list && !skipped_patch)4537 die(_("unrecognized input"));45384539 if (state->whitespace_error && (state->ws_error_action == die_on_ws_error))4540 state->apply = 0;45414542 state->update_index = state->check_index && state->apply;4543 if (state->update_index && newfd < 0)4544 newfd = hold_locked_index(&lock_file, 1);45454546 if (state->check_index) {4547 if (read_cache() < 0)4548 die(_("unable to read index file"));4549 }45504551 if ((state->check || state->apply) &&4552 check_patch_list(state, list) < 0 &&4553 !state->apply_with_reject)4554 exit(1);45554556 if (state->apply && write_out_results(state, list)) {4557 if (state->apply_with_reject)4558 exit(1);4559 /* with --3way, we still need to write the index out */4560 return 1;4561 }45624563 if (state->fake_ancestor)4564 build_fake_ancestor(list, state->fake_ancestor);45654566 if (state->diffstat)4567 stat_patch_list(state, list);45684569 if (state->numstat)4570 numstat_patch_list(state, list);45714572 if (state->summary)4573 summary_patch_list(list);45744575 free_patch_list(list);4576 strbuf_release(&buf);4577 string_list_clear(&fn_table, 0);4578 return 0;4579}45804581static void git_apply_config(void)4582{4583 git_config_get_string_const("apply.whitespace", &apply_default_whitespace);4584 git_config_get_string_const("apply.ignorewhitespace", &apply_default_ignorewhitespace);4585 git_config(git_default_config, NULL);4586}45874588static int option_parse_exclude(const struct option *opt,4589 const char *arg, int unset)4590{4591 struct apply_state *state = opt->value;4592 add_name_limit(state, arg, 1);4593 return 0;4594}45954596static int option_parse_include(const struct option *opt,4597 const char *arg, int unset)4598{4599 struct apply_state *state = opt->value;4600 add_name_limit(state, arg, 0);4601 state->has_include = 1;4602 return 0;4603}46044605static int option_parse_p(const struct option *opt,4606 const char *arg,4607 int unset)4608{4609 struct apply_state *state = opt->value;4610 state->p_value = atoi(arg);4611 state->p_value_known = 1;4612 return 0;4613}46144615static int option_parse_space_change(const struct option *opt,4616 const char *arg, int unset)4617{4618 struct apply_state *state = opt->value;4619 if (unset)4620 state->ws_ignore_action = ignore_ws_none;4621 else4622 state->ws_ignore_action = ignore_ws_change;4623 return 0;4624}46254626static int option_parse_whitespace(const struct option *opt,4627 const char *arg, int unset)4628{4629 struct apply_state *state = opt->value;4630 state->whitespace_option = arg;4631 parse_whitespace_option(state, arg);4632 return 0;4633}46344635static int option_parse_directory(const struct option *opt,4636 const char *arg, int unset)4637{4638 struct apply_state *state = opt->value;4639 strbuf_reset(&state->root);4640 strbuf_addstr(&state->root, arg);4641 strbuf_complete(&state->root, '/');4642 return 0;4643}46444645static void init_apply_state(struct apply_state *state, const char *prefix)4646{4647 memset(state, 0, sizeof(*state));4648 state->prefix = prefix;4649 state->prefix_length = state->prefix ? strlen(state->prefix) : 0;4650 state->apply = 1;4651 state->line_termination = '\n';4652 state->p_value = 1;4653 state->p_context = UINT_MAX;4654 state->squelch_whitespace_errors = 5;4655 state->ws_error_action = warn_on_ws_error;4656 state->ws_ignore_action = ignore_ws_none;4657 state->linenr = 1;4658 strbuf_init(&state->root, 0);46594660 git_apply_config();4661 if (apply_default_whitespace)4662 parse_whitespace_option(state, apply_default_whitespace);4663 if (apply_default_ignorewhitespace)4664 parse_ignorewhitespace_option(state, apply_default_ignorewhitespace);4665}46664667static void clear_apply_state(struct apply_state *state)4668{4669 string_list_clear(&state->limit_by_name, 0);4670 strbuf_release(&state->root);4671}46724673int cmd_apply(int argc, const char **argv, const char *prefix)4674{4675 int i;4676 int errs = 0;4677 int is_not_gitdir = !startup_info->have_repository;4678 int force_apply = 0;4679 int options = 0;4680 int read_stdin = 1;4681 struct apply_state state;46824683 struct option builtin_apply_options[] = {4684 { OPTION_CALLBACK, 0, "exclude", &state, N_("path"),4685 N_("don't apply changes matching the given path"),4686 0, option_parse_exclude },4687 { OPTION_CALLBACK, 0, "include", &state, N_("path"),4688 N_("apply changes matching the given path"),4689 0, option_parse_include },4690 { OPTION_CALLBACK, 'p', NULL, &state, N_("num"),4691 N_("remove <num> leading slashes from traditional diff paths"),4692 0, option_parse_p },4693 OPT_BOOL(0, "no-add", &state.no_add,4694 N_("ignore additions made by the patch")),4695 OPT_BOOL(0, "stat", &state.diffstat,4696 N_("instead of applying the patch, output diffstat for the input")),4697 OPT_NOOP_NOARG(0, "allow-binary-replacement"),4698 OPT_NOOP_NOARG(0, "binary"),4699 OPT_BOOL(0, "numstat", &state.numstat,4700 N_("show number of added and deleted lines in decimal notation")),4701 OPT_BOOL(0, "summary", &state.summary,4702 N_("instead of applying the patch, output a summary for the input")),4703 OPT_BOOL(0, "check", &state.check,4704 N_("instead of applying the patch, see if the patch is applicable")),4705 OPT_BOOL(0, "index", &state.check_index,4706 N_("make sure the patch is applicable to the current index")),4707 OPT_BOOL(0, "cached", &state.cached,4708 N_("apply a patch without touching the working tree")),4709 OPT_BOOL(0, "unsafe-paths", &state.unsafe_paths,4710 N_("accept a patch that touches outside the working area")),4711 OPT_BOOL(0, "apply", &force_apply,4712 N_("also apply the patch (use with --stat/--summary/--check)")),4713 OPT_BOOL('3', "3way", &state.threeway,4714 N_( "attempt three-way merge if a patch does not apply")),4715 OPT_FILENAME(0, "build-fake-ancestor", &state.fake_ancestor,4716 N_("build a temporary index based on embedded index information")),4717 /* Think twice before adding "--nul" synonym to this */4718 OPT_SET_INT('z', NULL, &state.line_termination,4719 N_("paths are separated with NUL character"), '\0'),4720 OPT_INTEGER('C', NULL, &state.p_context,4721 N_("ensure at least <n> lines of context match")),4722 { OPTION_CALLBACK, 0, "whitespace", &state, N_("action"),4723 N_("detect new or modified lines that have whitespace errors"),4724 0, option_parse_whitespace },4725 { OPTION_CALLBACK, 0, "ignore-space-change", &state, NULL,4726 N_("ignore changes in whitespace when finding context"),4727 PARSE_OPT_NOARG, option_parse_space_change },4728 { OPTION_CALLBACK, 0, "ignore-whitespace", &state, NULL,4729 N_("ignore changes in whitespace when finding context"),4730 PARSE_OPT_NOARG, option_parse_space_change },4731 OPT_BOOL('R', "reverse", &state.apply_in_reverse,4732 N_("apply the patch in reverse")),4733 OPT_BOOL(0, "unidiff-zero", &state.unidiff_zero,4734 N_("don't expect at least one line of context")),4735 OPT_BOOL(0, "reject", &state.apply_with_reject,4736 N_("leave the rejected hunks in corresponding *.rej files")),4737 OPT_BOOL(0, "allow-overlap", &state.allow_overlap,4738 N_("allow overlapping hunks")),4739 OPT__VERBOSE(&state.apply_verbosely, N_("be verbose")),4740 OPT_BIT(0, "inaccurate-eof", &options,4741 N_("tolerate incorrectly detected missing new-line at the end of file"),4742 INACCURATE_EOF),4743 OPT_BIT(0, "recount", &options,4744 N_("do not trust the line counts in the hunk headers"),4745 RECOUNT),4746 { OPTION_CALLBACK, 0, "directory", &state, N_("root"),4747 N_("prepend <root> to all filenames"),4748 0, option_parse_directory },4749 OPT_END()4750 };47514752 init_apply_state(&state, prefix);47534754 argc = parse_options(argc, argv, state.prefix, builtin_apply_options,4755 apply_usage, 0);47564757 if (state.apply_with_reject && state.threeway)4758 die("--reject and --3way cannot be used together.");4759 if (state.cached && state.threeway)4760 die("--cached and --3way cannot be used together.");4761 if (state.threeway) {4762 if (is_not_gitdir)4763 die(_("--3way outside a repository"));4764 state.check_index = 1;4765 }4766 if (state.apply_with_reject)4767 state.apply = state.apply_verbosely = 1;4768 if (!force_apply && (state.diffstat || state.numstat || state.summary || state.check || state.fake_ancestor))4769 state.apply = 0;4770 if (state.check_index && is_not_gitdir)4771 die(_("--index outside a repository"));4772 if (state.cached) {4773 if (is_not_gitdir)4774 die(_("--cached outside a repository"));4775 state.check_index = 1;4776 }4777 if (state.check_index)4778 state.unsafe_paths = 0;47794780 for (i = 0; i < argc; i++) {4781 const char *arg = argv[i];4782 int fd;47834784 if (!strcmp(arg, "-")) {4785 errs |= apply_patch(&state, 0, "<stdin>", options);4786 read_stdin = 0;4787 continue;4788 } else if (0 < state.prefix_length)4789 arg = prefix_filename(state.prefix,4790 state.prefix_length,4791 arg);47924793 fd = open(arg, O_RDONLY);4794 if (fd < 0)4795 die_errno(_("can't open patch '%s'"), arg);4796 read_stdin = 0;4797 set_default_whitespace_mode(&state);4798 errs |= apply_patch(&state, fd, arg, options);4799 close(fd);4800 }4801 set_default_whitespace_mode(&state);4802 if (read_stdin)4803 errs |= apply_patch(&state, 0, "<stdin>", options);4804 if (state.whitespace_error) {4805 if (state.squelch_whitespace_errors &&4806 state.squelch_whitespace_errors < state.whitespace_error) {4807 int squelched =4808 state.whitespace_error - state.squelch_whitespace_errors;4809 warning(Q_("squelched %d whitespace error",4810 "squelched %d whitespace errors",4811 squelched),4812 squelched);4813 }4814 if (state.ws_error_action == die_on_ws_error)4815 die(Q_("%d line adds whitespace errors.",4816 "%d lines add whitespace errors.",4817 state.whitespace_error),4818 state.whitespace_error);4819 if (state.applied_after_fixing_ws && state.apply)4820 warning("%d line%s applied after"4821 " fixing whitespace errors.",4822 state.applied_after_fixing_ws,4823 state.applied_after_fixing_ws == 1 ? "" : "s");4824 else if (state.whitespace_error)4825 warning(Q_("%d line adds whitespace errors.",4826 "%d lines add whitespace errors.",4827 state.whitespace_error),4828 state.whitespace_error);4829 }48304831 if (state.update_index) {4832 if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK))4833 die(_("Unable to write new index file"));4834 }48354836 clear_apply_state(&state);48374838 return !!errs;4839}