builtin / apply.con commit Merge branch 'jk/repack-ref-racefix' (229096a)
   1/*
   2 * apply.c
   3 *
   4 * Copyright (C) Linus Torvalds, 2005
   5 *
   6 * This applies patches on top of some (arbitrary) version of the SCM.
   7 *
   8 */
   9#include "cache.h"
  10#include "cache-tree.h"
  11#include "quote.h"
  12#include "blob.h"
  13#include "delta.h"
  14#include "builtin.h"
  15#include "string-list.h"
  16#include "dir.h"
  17#include "diff.h"
  18#include "parse-options.h"
  19#include "xdiff-interface.h"
  20#include "ll-merge.h"
  21#include "rerere.h"
  22
  23/*
  24 *  --check turns on checking that the working tree matches the
  25 *    files that are being modified, but doesn't apply the patch
  26 *  --stat does just a diffstat, and doesn't actually apply
  27 *  --numstat does numeric diffstat, and doesn't actually apply
  28 *  --index-info shows the old and new index info for paths if available.
  29 *  --index updates the cache as well.
  30 *  --cached updates only the cache without ever touching the working tree.
  31 */
  32static const char *prefix;
  33static int prefix_length = -1;
  34static int newfd = -1;
  35
  36static int unidiff_zero;
  37static int p_value = 1;
  38static int p_value_known;
  39static int check_index;
  40static int update_index;
  41static int cached;
  42static int diffstat;
  43static int numstat;
  44static int summary;
  45static int check;
  46static int apply = 1;
  47static int apply_in_reverse;
  48static int apply_with_reject;
  49static int apply_verbosely;
  50static int allow_overlap;
  51static int no_add;
  52static int threeway;
  53static const char *fake_ancestor;
  54static int line_termination = '\n';
  55static unsigned int p_context = UINT_MAX;
  56static const char * const apply_usage[] = {
  57        N_("git apply [options] [<patch>...]"),
  58        NULL
  59};
  60
  61static enum ws_error_action {
  62        nowarn_ws_error,
  63        warn_on_ws_error,
  64        die_on_ws_error,
  65        correct_ws_error
  66} ws_error_action = warn_on_ws_error;
  67static int whitespace_error;
  68static int squelch_whitespace_errors = 5;
  69static int applied_after_fixing_ws;
  70
  71static enum ws_ignore {
  72        ignore_ws_none,
  73        ignore_ws_change
  74} ws_ignore_action = ignore_ws_none;
  75
  76
  77static const char *patch_input_file;
  78static const char *root;
  79static int root_len;
  80static int read_stdin = 1;
  81static int options;
  82
  83static void parse_whitespace_option(const char *option)
  84{
  85        if (!option) {
  86                ws_error_action = warn_on_ws_error;
  87                return;
  88        }
  89        if (!strcmp(option, "warn")) {
  90                ws_error_action = warn_on_ws_error;
  91                return;
  92        }
  93        if (!strcmp(option, "nowarn")) {
  94                ws_error_action = nowarn_ws_error;
  95                return;
  96        }
  97        if (!strcmp(option, "error")) {
  98                ws_error_action = die_on_ws_error;
  99                return;
 100        }
 101        if (!strcmp(option, "error-all")) {
 102                ws_error_action = die_on_ws_error;
 103                squelch_whitespace_errors = 0;
 104                return;
 105        }
 106        if (!strcmp(option, "strip") || !strcmp(option, "fix")) {
 107                ws_error_action = correct_ws_error;
 108                return;
 109        }
 110        die(_("unrecognized whitespace option '%s'"), option);
 111}
 112
 113static void parse_ignorewhitespace_option(const char *option)
 114{
 115        if (!option || !strcmp(option, "no") ||
 116            !strcmp(option, "false") || !strcmp(option, "never") ||
 117            !strcmp(option, "none")) {
 118                ws_ignore_action = ignore_ws_none;
 119                return;
 120        }
 121        if (!strcmp(option, "change")) {
 122                ws_ignore_action = ignore_ws_change;
 123                return;
 124        }
 125        die(_("unrecognized whitespace ignore option '%s'"), option);
 126}
 127
 128static void set_default_whitespace_mode(const char *whitespace_option)
 129{
 130        if (!whitespace_option && !apply_default_whitespace)
 131                ws_error_action = (apply ? warn_on_ws_error : nowarn_ws_error);
 132}
 133
 134/*
 135 * For "diff-stat" like behaviour, we keep track of the biggest change
 136 * we've seen, and the longest filename. That allows us to do simple
 137 * scaling.
 138 */
 139static int max_change, max_len;
 140
 141/*
 142 * Various "current state", notably line numbers and what
 143 * file (and how) we're patching right now.. The "is_xxxx"
 144 * things are flags, where -1 means "don't know yet".
 145 */
 146static int linenr = 1;
 147
 148/*
 149 * This represents one "hunk" from a patch, starting with
 150 * "@@ -oldpos,oldlines +newpos,newlines @@" marker.  The
 151 * patch text is pointed at by patch, and its byte length
 152 * is stored in size.  leading and trailing are the number
 153 * of context lines.
 154 */
 155struct fragment {
 156        unsigned long leading, trailing;
 157        unsigned long oldpos, oldlines;
 158        unsigned long newpos, newlines;
 159        /*
 160         * 'patch' is usually borrowed from buf in apply_patch(),
 161         * but some codepaths store an allocated buffer.
 162         */
 163        const char *patch;
 164        unsigned free_patch:1,
 165                rejected:1;
 166        int size;
 167        int linenr;
 168        struct fragment *next;
 169};
 170
 171/*
 172 * When dealing with a binary patch, we reuse "leading" field
 173 * to store the type of the binary hunk, either deflated "delta"
 174 * or deflated "literal".
 175 */
 176#define binary_patch_method leading
 177#define BINARY_DELTA_DEFLATED   1
 178#define BINARY_LITERAL_DEFLATED 2
 179
 180/*
 181 * This represents a "patch" to a file, both metainfo changes
 182 * such as creation/deletion, filemode and content changes represented
 183 * as a series of fragments.
 184 */
 185struct patch {
 186        char *new_name, *old_name, *def_name;
 187        unsigned int old_mode, new_mode;
 188        int is_new, is_delete;  /* -1 = unknown, 0 = false, 1 = true */
 189        int rejected;
 190        unsigned ws_rule;
 191        int lines_added, lines_deleted;
 192        int score;
 193        unsigned int is_toplevel_relative:1;
 194        unsigned int inaccurate_eof:1;
 195        unsigned int is_binary:1;
 196        unsigned int is_copy:1;
 197        unsigned int is_rename:1;
 198        unsigned int recount:1;
 199        unsigned int conflicted_threeway:1;
 200        unsigned int direct_to_threeway:1;
 201        struct fragment *fragments;
 202        char *result;
 203        size_t resultsize;
 204        char old_sha1_prefix[41];
 205        char new_sha1_prefix[41];
 206        struct patch *next;
 207
 208        /* three-way fallback result */
 209        unsigned char threeway_stage[3][20];
 210};
 211
 212static void free_fragment_list(struct fragment *list)
 213{
 214        while (list) {
 215                struct fragment *next = list->next;
 216                if (list->free_patch)
 217                        free((char *)list->patch);
 218                free(list);
 219                list = next;
 220        }
 221}
 222
 223static void free_patch(struct patch *patch)
 224{
 225        free_fragment_list(patch->fragments);
 226        free(patch->def_name);
 227        free(patch->old_name);
 228        free(patch->new_name);
 229        free(patch->result);
 230        free(patch);
 231}
 232
 233static void free_patch_list(struct patch *list)
 234{
 235        while (list) {
 236                struct patch *next = list->next;
 237                free_patch(list);
 238                list = next;
 239        }
 240}
 241
 242/*
 243 * A line in a file, len-bytes long (includes the terminating LF,
 244 * except for an incomplete line at the end if the file ends with
 245 * one), and its contents hashes to 'hash'.
 246 */
 247struct line {
 248        size_t len;
 249        unsigned hash : 24;
 250        unsigned flag : 8;
 251#define LINE_COMMON     1
 252#define LINE_PATCHED    2
 253};
 254
 255/*
 256 * This represents a "file", which is an array of "lines".
 257 */
 258struct image {
 259        char *buf;
 260        size_t len;
 261        size_t nr;
 262        size_t alloc;
 263        struct line *line_allocated;
 264        struct line *line;
 265};
 266
 267/*
 268 * Records filenames that have been touched, in order to handle
 269 * the case where more than one patches touch the same file.
 270 */
 271
 272static struct string_list fn_table;
 273
 274static uint32_t hash_line(const char *cp, size_t len)
 275{
 276        size_t i;
 277        uint32_t h;
 278        for (i = 0, h = 0; i < len; i++) {
 279                if (!isspace(cp[i])) {
 280                        h = h * 3 + (cp[i] & 0xff);
 281                }
 282        }
 283        return h;
 284}
 285
 286/*
 287 * Compare lines s1 of length n1 and s2 of length n2, ignoring
 288 * whitespace difference. Returns 1 if they match, 0 otherwise
 289 */
 290static int fuzzy_matchlines(const char *s1, size_t n1,
 291                            const char *s2, size_t n2)
 292{
 293        const char *last1 = s1 + n1 - 1;
 294        const char *last2 = s2 + n2 - 1;
 295        int result = 0;
 296
 297        /* ignore line endings */
 298        while ((*last1 == '\r') || (*last1 == '\n'))
 299                last1--;
 300        while ((*last2 == '\r') || (*last2 == '\n'))
 301                last2--;
 302
 303        /* skip leading whitespace */
 304        while (isspace(*s1) && (s1 <= last1))
 305                s1++;
 306        while (isspace(*s2) && (s2 <= last2))
 307                s2++;
 308        /* early return if both lines are empty */
 309        if ((s1 > last1) && (s2 > last2))
 310                return 1;
 311        while (!result) {
 312                result = *s1++ - *s2++;
 313                /*
 314                 * Skip whitespace inside. We check for whitespace on
 315                 * both buffers because we don't want "a b" to match
 316                 * "ab"
 317                 */
 318                if (isspace(*s1) && isspace(*s2)) {
 319                        while (isspace(*s1) && s1 <= last1)
 320                                s1++;
 321                        while (isspace(*s2) && s2 <= last2)
 322                                s2++;
 323                }
 324                /*
 325                 * If we reached the end on one side only,
 326                 * lines don't match
 327                 */
 328                if (
 329                    ((s2 > last2) && (s1 <= last1)) ||
 330                    ((s1 > last1) && (s2 <= last2)))
 331                        return 0;
 332                if ((s1 > last1) && (s2 > last2))
 333                        break;
 334        }
 335
 336        return !result;
 337}
 338
 339static void add_line_info(struct image *img, const char *bol, size_t len, unsigned flag)
 340{
 341        ALLOC_GROW(img->line_allocated, img->nr + 1, img->alloc);
 342        img->line_allocated[img->nr].len = len;
 343        img->line_allocated[img->nr].hash = hash_line(bol, len);
 344        img->line_allocated[img->nr].flag = flag;
 345        img->nr++;
 346}
 347
 348/*
 349 * "buf" has the file contents to be patched (read from various sources).
 350 * attach it to "image" and add line-based index to it.
 351 * "image" now owns the "buf".
 352 */
 353static void prepare_image(struct image *image, char *buf, size_t len,
 354                          int prepare_linetable)
 355{
 356        const char *cp, *ep;
 357
 358        memset(image, 0, sizeof(*image));
 359        image->buf = buf;
 360        image->len = len;
 361
 362        if (!prepare_linetable)
 363                return;
 364
 365        ep = image->buf + image->len;
 366        cp = image->buf;
 367        while (cp < ep) {
 368                const char *next;
 369                for (next = cp; next < ep && *next != '\n'; next++)
 370                        ;
 371                if (next < ep)
 372                        next++;
 373                add_line_info(image, cp, next - cp, 0);
 374                cp = next;
 375        }
 376        image->line = image->line_allocated;
 377}
 378
 379static void clear_image(struct image *image)
 380{
 381        free(image->buf);
 382        free(image->line_allocated);
 383        memset(image, 0, sizeof(*image));
 384}
 385
 386/* fmt must contain _one_ %s and no other substitution */
 387static void say_patch_name(FILE *output, const char *fmt, struct patch *patch)
 388{
 389        struct strbuf sb = STRBUF_INIT;
 390
 391        if (patch->old_name && patch->new_name &&
 392            strcmp(patch->old_name, patch->new_name)) {
 393                quote_c_style(patch->old_name, &sb, NULL, 0);
 394                strbuf_addstr(&sb, " => ");
 395                quote_c_style(patch->new_name, &sb, NULL, 0);
 396        } else {
 397                const char *n = patch->new_name;
 398                if (!n)
 399                        n = patch->old_name;
 400                quote_c_style(n, &sb, NULL, 0);
 401        }
 402        fprintf(output, fmt, sb.buf);
 403        fputc('\n', output);
 404        strbuf_release(&sb);
 405}
 406
 407#define SLOP (16)
 408
 409static void read_patch_file(struct strbuf *sb, int fd)
 410{
 411        if (strbuf_read(sb, fd, 0) < 0)
 412                die_errno("git apply: failed to read");
 413
 414        /*
 415         * Make sure that we have some slop in the buffer
 416         * so that we can do speculative "memcmp" etc, and
 417         * see to it that it is NUL-filled.
 418         */
 419        strbuf_grow(sb, SLOP);
 420        memset(sb->buf + sb->len, 0, SLOP);
 421}
 422
 423static unsigned long linelen(const char *buffer, unsigned long size)
 424{
 425        unsigned long len = 0;
 426        while (size--) {
 427                len++;
 428                if (*buffer++ == '\n')
 429                        break;
 430        }
 431        return len;
 432}
 433
 434static int is_dev_null(const char *str)
 435{
 436        return !memcmp("/dev/null", str, 9) && isspace(str[9]);
 437}
 438
 439#define TERM_SPACE      1
 440#define TERM_TAB        2
 441
 442static int name_terminate(const char *name, int namelen, int c, int terminate)
 443{
 444        if (c == ' ' && !(terminate & TERM_SPACE))
 445                return 0;
 446        if (c == '\t' && !(terminate & TERM_TAB))
 447                return 0;
 448
 449        return 1;
 450}
 451
 452/* remove double slashes to make --index work with such filenames */
 453static char *squash_slash(char *name)
 454{
 455        int i = 0, j = 0;
 456
 457        if (!name)
 458                return NULL;
 459
 460        while (name[i]) {
 461                if ((name[j++] = name[i++]) == '/')
 462                        while (name[i] == '/')
 463                                i++;
 464        }
 465        name[j] = '\0';
 466        return name;
 467}
 468
 469static char *find_name_gnu(const char *line, const char *def, int p_value)
 470{
 471        struct strbuf name = STRBUF_INIT;
 472        char *cp;
 473
 474        /*
 475         * Proposed "new-style" GNU patch/diff format; see
 476         * http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2
 477         */
 478        if (unquote_c_style(&name, line, NULL)) {
 479                strbuf_release(&name);
 480                return NULL;
 481        }
 482
 483        for (cp = name.buf; p_value; p_value--) {
 484                cp = strchr(cp, '/');
 485                if (!cp) {
 486                        strbuf_release(&name);
 487                        return NULL;
 488                }
 489                cp++;
 490        }
 491
 492        strbuf_remove(&name, 0, cp - name.buf);
 493        if (root)
 494                strbuf_insert(&name, 0, root, root_len);
 495        return squash_slash(strbuf_detach(&name, NULL));
 496}
 497
 498static size_t sane_tz_len(const char *line, size_t len)
 499{
 500        const char *tz, *p;
 501
 502        if (len < strlen(" +0500") || line[len-strlen(" +0500")] != ' ')
 503                return 0;
 504        tz = line + len - strlen(" +0500");
 505
 506        if (tz[1] != '+' && tz[1] != '-')
 507                return 0;
 508
 509        for (p = tz + 2; p != line + len; p++)
 510                if (!isdigit(*p))
 511                        return 0;
 512
 513        return line + len - tz;
 514}
 515
 516static size_t tz_with_colon_len(const char *line, size_t len)
 517{
 518        const char *tz, *p;
 519
 520        if (len < strlen(" +08:00") || line[len - strlen(":00")] != ':')
 521                return 0;
 522        tz = line + len - strlen(" +08:00");
 523
 524        if (tz[0] != ' ' || (tz[1] != '+' && tz[1] != '-'))
 525                return 0;
 526        p = tz + 2;
 527        if (!isdigit(*p++) || !isdigit(*p++) || *p++ != ':' ||
 528            !isdigit(*p++) || !isdigit(*p++))
 529                return 0;
 530
 531        return line + len - tz;
 532}
 533
 534static size_t date_len(const char *line, size_t len)
 535{
 536        const char *date, *p;
 537
 538        if (len < strlen("72-02-05") || line[len-strlen("-05")] != '-')
 539                return 0;
 540        p = date = line + len - strlen("72-02-05");
 541
 542        if (!isdigit(*p++) || !isdigit(*p++) || *p++ != '-' ||
 543            !isdigit(*p++) || !isdigit(*p++) || *p++ != '-' ||
 544            !isdigit(*p++) || !isdigit(*p++))   /* Not a date. */
 545                return 0;
 546
 547        if (date - line >= strlen("19") &&
 548            isdigit(date[-1]) && isdigit(date[-2]))     /* 4-digit year */
 549                date -= strlen("19");
 550
 551        return line + len - date;
 552}
 553
 554static size_t short_time_len(const char *line, size_t len)
 555{
 556        const char *time, *p;
 557
 558        if (len < strlen(" 07:01:32") || line[len-strlen(":32")] != ':')
 559                return 0;
 560        p = time = line + len - strlen(" 07:01:32");
 561
 562        /* Permit 1-digit hours? */
 563        if (*p++ != ' ' ||
 564            !isdigit(*p++) || !isdigit(*p++) || *p++ != ':' ||
 565            !isdigit(*p++) || !isdigit(*p++) || *p++ != ':' ||
 566            !isdigit(*p++) || !isdigit(*p++))   /* Not a time. */
 567                return 0;
 568
 569        return line + len - time;
 570}
 571
 572static size_t fractional_time_len(const char *line, size_t len)
 573{
 574        const char *p;
 575        size_t n;
 576
 577        /* Expected format: 19:41:17.620000023 */
 578        if (!len || !isdigit(line[len - 1]))
 579                return 0;
 580        p = line + len - 1;
 581
 582        /* Fractional seconds. */
 583        while (p > line && isdigit(*p))
 584                p--;
 585        if (*p != '.')
 586                return 0;
 587
 588        /* Hours, minutes, and whole seconds. */
 589        n = short_time_len(line, p - line);
 590        if (!n)
 591                return 0;
 592
 593        return line + len - p + n;
 594}
 595
 596static size_t trailing_spaces_len(const char *line, size_t len)
 597{
 598        const char *p;
 599
 600        /* Expected format: ' ' x (1 or more)  */
 601        if (!len || line[len - 1] != ' ')
 602                return 0;
 603
 604        p = line + len;
 605        while (p != line) {
 606                p--;
 607                if (*p != ' ')
 608                        return line + len - (p + 1);
 609        }
 610
 611        /* All spaces! */
 612        return len;
 613}
 614
 615static size_t diff_timestamp_len(const char *line, size_t len)
 616{
 617        const char *end = line + len;
 618        size_t n;
 619
 620        /*
 621         * Posix: 2010-07-05 19:41:17
 622         * GNU: 2010-07-05 19:41:17.620000023 -0500
 623         */
 624
 625        if (!isdigit(end[-1]))
 626                return 0;
 627
 628        n = sane_tz_len(line, end - line);
 629        if (!n)
 630                n = tz_with_colon_len(line, end - line);
 631        end -= n;
 632
 633        n = short_time_len(line, end - line);
 634        if (!n)
 635                n = fractional_time_len(line, end - line);
 636        end -= n;
 637
 638        n = date_len(line, end - line);
 639        if (!n) /* No date.  Too bad. */
 640                return 0;
 641        end -= n;
 642
 643        if (end == line)        /* No space before date. */
 644                return 0;
 645        if (end[-1] == '\t') {  /* Success! */
 646                end--;
 647                return line + len - end;
 648        }
 649        if (end[-1] != ' ')     /* No space before date. */
 650                return 0;
 651
 652        /* Whitespace damage. */
 653        end -= trailing_spaces_len(line, end - line);
 654        return line + len - end;
 655}
 656
 657static char *null_strdup(const char *s)
 658{
 659        return s ? xstrdup(s) : NULL;
 660}
 661
 662static char *find_name_common(const char *line, const char *def,
 663                              int p_value, const char *end, int terminate)
 664{
 665        int len;
 666        const char *start = NULL;
 667
 668        if (p_value == 0)
 669                start = line;
 670        while (line != end) {
 671                char c = *line;
 672
 673                if (!end && isspace(c)) {
 674                        if (c == '\n')
 675                                break;
 676                        if (name_terminate(start, line-start, c, terminate))
 677                                break;
 678                }
 679                line++;
 680                if (c == '/' && !--p_value)
 681                        start = line;
 682        }
 683        if (!start)
 684                return squash_slash(null_strdup(def));
 685        len = line - start;
 686        if (!len)
 687                return squash_slash(null_strdup(def));
 688
 689        /*
 690         * Generally we prefer the shorter name, especially
 691         * if the other one is just a variation of that with
 692         * something else tacked on to the end (ie "file.orig"
 693         * or "file~").
 694         */
 695        if (def) {
 696                int deflen = strlen(def);
 697                if (deflen < len && !strncmp(start, def, deflen))
 698                        return squash_slash(xstrdup(def));
 699        }
 700
 701        if (root) {
 702                char *ret = xmalloc(root_len + len + 1);
 703                strcpy(ret, root);
 704                memcpy(ret + root_len, start, len);
 705                ret[root_len + len] = '\0';
 706                return squash_slash(ret);
 707        }
 708
 709        return squash_slash(xmemdupz(start, len));
 710}
 711
 712static char *find_name(const char *line, char *def, int p_value, int terminate)
 713{
 714        if (*line == '"') {
 715                char *name = find_name_gnu(line, def, p_value);
 716                if (name)
 717                        return name;
 718        }
 719
 720        return find_name_common(line, def, p_value, NULL, terminate);
 721}
 722
 723static char *find_name_traditional(const char *line, char *def, int p_value)
 724{
 725        size_t len = strlen(line);
 726        size_t date_len;
 727
 728        if (*line == '"') {
 729                char *name = find_name_gnu(line, def, p_value);
 730                if (name)
 731                        return name;
 732        }
 733
 734        len = strchrnul(line, '\n') - line;
 735        date_len = diff_timestamp_len(line, len);
 736        if (!date_len)
 737                return find_name_common(line, def, p_value, NULL, TERM_TAB);
 738        len -= date_len;
 739
 740        return find_name_common(line, def, p_value, line + len, 0);
 741}
 742
 743static int count_slashes(const char *cp)
 744{
 745        int cnt = 0;
 746        char ch;
 747
 748        while ((ch = *cp++))
 749                if (ch == '/')
 750                        cnt++;
 751        return cnt;
 752}
 753
 754/*
 755 * Given the string after "--- " or "+++ ", guess the appropriate
 756 * p_value for the given patch.
 757 */
 758static int guess_p_value(const char *nameline)
 759{
 760        char *name, *cp;
 761        int val = -1;
 762
 763        if (is_dev_null(nameline))
 764                return -1;
 765        name = find_name_traditional(nameline, NULL, 0);
 766        if (!name)
 767                return -1;
 768        cp = strchr(name, '/');
 769        if (!cp)
 770                val = 0;
 771        else if (prefix) {
 772                /*
 773                 * Does it begin with "a/$our-prefix" and such?  Then this is
 774                 * very likely to apply to our directory.
 775                 */
 776                if (!strncmp(name, prefix, prefix_length))
 777                        val = count_slashes(prefix);
 778                else {
 779                        cp++;
 780                        if (!strncmp(cp, prefix, prefix_length))
 781                                val = count_slashes(prefix) + 1;
 782                }
 783        }
 784        free(name);
 785        return val;
 786}
 787
 788/*
 789 * Does the ---/+++ line has the POSIX timestamp after the last HT?
 790 * GNU diff puts epoch there to signal a creation/deletion event.  Is
 791 * this such a timestamp?
 792 */
 793static int has_epoch_timestamp(const char *nameline)
 794{
 795        /*
 796         * We are only interested in epoch timestamp; any non-zero
 797         * fraction cannot be one, hence "(\.0+)?" in the regexp below.
 798         * For the same reason, the date must be either 1969-12-31 or
 799         * 1970-01-01, and the seconds part must be "00".
 800         */
 801        const char stamp_regexp[] =
 802                "^(1969-12-31|1970-01-01)"
 803                " "
 804                "[0-2][0-9]:[0-5][0-9]:00(\\.0+)?"
 805                " "
 806                "([-+][0-2][0-9]:?[0-5][0-9])\n";
 807        const char *timestamp = NULL, *cp, *colon;
 808        static regex_t *stamp;
 809        regmatch_t m[10];
 810        int zoneoffset;
 811        int hourminute;
 812        int status;
 813
 814        for (cp = nameline; *cp != '\n'; cp++) {
 815                if (*cp == '\t')
 816                        timestamp = cp + 1;
 817        }
 818        if (!timestamp)
 819                return 0;
 820        if (!stamp) {
 821                stamp = xmalloc(sizeof(*stamp));
 822                if (regcomp(stamp, stamp_regexp, REG_EXTENDED)) {
 823                        warning(_("Cannot prepare timestamp regexp %s"),
 824                                stamp_regexp);
 825                        return 0;
 826                }
 827        }
 828
 829        status = regexec(stamp, timestamp, ARRAY_SIZE(m), m, 0);
 830        if (status) {
 831                if (status != REG_NOMATCH)
 832                        warning(_("regexec returned %d for input: %s"),
 833                                status, timestamp);
 834                return 0;
 835        }
 836
 837        zoneoffset = strtol(timestamp + m[3].rm_so + 1, (char **) &colon, 10);
 838        if (*colon == ':')
 839                zoneoffset = zoneoffset * 60 + strtol(colon + 1, NULL, 10);
 840        else
 841                zoneoffset = (zoneoffset / 100) * 60 + (zoneoffset % 100);
 842        if (timestamp[m[3].rm_so] == '-')
 843                zoneoffset = -zoneoffset;
 844
 845        /*
 846         * YYYY-MM-DD hh:mm:ss must be from either 1969-12-31
 847         * (west of GMT) or 1970-01-01 (east of GMT)
 848         */
 849        if ((zoneoffset < 0 && memcmp(timestamp, "1969-12-31", 10)) ||
 850            (0 <= zoneoffset && memcmp(timestamp, "1970-01-01", 10)))
 851                return 0;
 852
 853        hourminute = (strtol(timestamp + 11, NULL, 10) * 60 +
 854                      strtol(timestamp + 14, NULL, 10) -
 855                      zoneoffset);
 856
 857        return ((zoneoffset < 0 && hourminute == 1440) ||
 858                (0 <= zoneoffset && !hourminute));
 859}
 860
 861/*
 862 * Get the name etc info from the ---/+++ lines of a traditional patch header
 863 *
 864 * FIXME! The end-of-filename heuristics are kind of screwy. For existing
 865 * files, we can happily check the index for a match, but for creating a
 866 * new file we should try to match whatever "patch" does. I have no idea.
 867 */
 868static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)
 869{
 870        char *name;
 871
 872        first += 4;     /* skip "--- " */
 873        second += 4;    /* skip "+++ " */
 874        if (!p_value_known) {
 875                int p, q;
 876                p = guess_p_value(first);
 877                q = guess_p_value(second);
 878                if (p < 0) p = q;
 879                if (0 <= p && p == q) {
 880                        p_value = p;
 881                        p_value_known = 1;
 882                }
 883        }
 884        if (is_dev_null(first)) {
 885                patch->is_new = 1;
 886                patch->is_delete = 0;
 887                name = find_name_traditional(second, NULL, p_value);
 888                patch->new_name = name;
 889        } else if (is_dev_null(second)) {
 890                patch->is_new = 0;
 891                patch->is_delete = 1;
 892                name = find_name_traditional(first, NULL, p_value);
 893                patch->old_name = name;
 894        } else {
 895                char *first_name;
 896                first_name = find_name_traditional(first, NULL, p_value);
 897                name = find_name_traditional(second, first_name, p_value);
 898                free(first_name);
 899                if (has_epoch_timestamp(first)) {
 900                        patch->is_new = 1;
 901                        patch->is_delete = 0;
 902                        patch->new_name = name;
 903                } else if (has_epoch_timestamp(second)) {
 904                        patch->is_new = 0;
 905                        patch->is_delete = 1;
 906                        patch->old_name = name;
 907                } else {
 908                        patch->old_name = name;
 909                        patch->new_name = xstrdup(name);
 910                }
 911        }
 912        if (!name)
 913                die(_("unable to find filename in patch at line %d"), linenr);
 914}
 915
 916static int gitdiff_hdrend(const char *line, struct patch *patch)
 917{
 918        return -1;
 919}
 920
 921/*
 922 * We're anal about diff header consistency, to make
 923 * sure that we don't end up having strange ambiguous
 924 * patches floating around.
 925 *
 926 * As a result, gitdiff_{old|new}name() will check
 927 * their names against any previous information, just
 928 * to make sure..
 929 */
 930#define DIFF_OLD_NAME 0
 931#define DIFF_NEW_NAME 1
 932
 933static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, int side)
 934{
 935        if (!orig_name && !isnull)
 936                return find_name(line, NULL, p_value, TERM_TAB);
 937
 938        if (orig_name) {
 939                int len;
 940                const char *name;
 941                char *another;
 942                name = orig_name;
 943                len = strlen(name);
 944                if (isnull)
 945                        die(_("git apply: bad git-diff - expected /dev/null, got %s on line %d"), name, linenr);
 946                another = find_name(line, NULL, p_value, TERM_TAB);
 947                if (!another || memcmp(another, name, len + 1))
 948                        die((side == DIFF_NEW_NAME) ?
 949                            _("git apply: bad git-diff - inconsistent new filename on line %d") :
 950                            _("git apply: bad git-diff - inconsistent old filename on line %d"), linenr);
 951                free(another);
 952                return orig_name;
 953        }
 954        else {
 955                /* expect "/dev/null" */
 956                if (memcmp("/dev/null", line, 9) || line[9] != '\n')
 957                        die(_("git apply: bad git-diff - expected /dev/null on line %d"), linenr);
 958                return NULL;
 959        }
 960}
 961
 962static int gitdiff_oldname(const char *line, struct patch *patch)
 963{
 964        char *orig = patch->old_name;
 965        patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name,
 966                                              DIFF_OLD_NAME);
 967        if (orig != patch->old_name)
 968                free(orig);
 969        return 0;
 970}
 971
 972static int gitdiff_newname(const char *line, struct patch *patch)
 973{
 974        char *orig = patch->new_name;
 975        patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name,
 976                                              DIFF_NEW_NAME);
 977        if (orig != patch->new_name)
 978                free(orig);
 979        return 0;
 980}
 981
 982static int gitdiff_oldmode(const char *line, struct patch *patch)
 983{
 984        patch->old_mode = strtoul(line, NULL, 8);
 985        return 0;
 986}
 987
 988static int gitdiff_newmode(const char *line, struct patch *patch)
 989{
 990        patch->new_mode = strtoul(line, NULL, 8);
 991        return 0;
 992}
 993
 994static int gitdiff_delete(const char *line, struct patch *patch)
 995{
 996        patch->is_delete = 1;
 997        free(patch->old_name);
 998        patch->old_name = null_strdup(patch->def_name);
 999        return gitdiff_oldmode(line, patch);
1000}
1001
1002static int gitdiff_newfile(const char *line, struct patch *patch)
1003{
1004        patch->is_new = 1;
1005        free(patch->new_name);
1006        patch->new_name = null_strdup(patch->def_name);
1007        return gitdiff_newmode(line, patch);
1008}
1009
1010static int gitdiff_copysrc(const char *line, struct patch *patch)
1011{
1012        patch->is_copy = 1;
1013        free(patch->old_name);
1014        patch->old_name = find_name(line, NULL, p_value ? p_value - 1 : 0, 0);
1015        return 0;
1016}
1017
1018static int gitdiff_copydst(const char *line, struct patch *patch)
1019{
1020        patch->is_copy = 1;
1021        free(patch->new_name);
1022        patch->new_name = find_name(line, NULL, p_value ? p_value - 1 : 0, 0);
1023        return 0;
1024}
1025
1026static int gitdiff_renamesrc(const char *line, struct patch *patch)
1027{
1028        patch->is_rename = 1;
1029        free(patch->old_name);
1030        patch->old_name = find_name(line, NULL, p_value ? p_value - 1 : 0, 0);
1031        return 0;
1032}
1033
1034static int gitdiff_renamedst(const char *line, struct patch *patch)
1035{
1036        patch->is_rename = 1;
1037        free(patch->new_name);
1038        patch->new_name = find_name(line, NULL, p_value ? p_value - 1 : 0, 0);
1039        return 0;
1040}
1041
1042static int gitdiff_similarity(const char *line, struct patch *patch)
1043{
1044        if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
1045                patch->score = 0;
1046        return 0;
1047}
1048
1049static int gitdiff_dissimilarity(const char *line, struct patch *patch)
1050{
1051        if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)
1052                patch->score = 0;
1053        return 0;
1054}
1055
1056static int gitdiff_index(const char *line, struct patch *patch)
1057{
1058        /*
1059         * index line is N hexadecimal, "..", N hexadecimal,
1060         * and optional space with octal mode.
1061         */
1062        const char *ptr, *eol;
1063        int len;
1064
1065        ptr = strchr(line, '.');
1066        if (!ptr || ptr[1] != '.' || 40 < ptr - line)
1067                return 0;
1068        len = ptr - line;
1069        memcpy(patch->old_sha1_prefix, line, len);
1070        patch->old_sha1_prefix[len] = 0;
1071
1072        line = ptr + 2;
1073        ptr = strchr(line, ' ');
1074        eol = strchr(line, '\n');
1075
1076        if (!ptr || eol < ptr)
1077                ptr = eol;
1078        len = ptr - line;
1079
1080        if (40 < len)
1081                return 0;
1082        memcpy(patch->new_sha1_prefix, line, len);
1083        patch->new_sha1_prefix[len] = 0;
1084        if (*ptr == ' ')
1085                patch->old_mode = strtoul(ptr+1, NULL, 8);
1086        return 0;
1087}
1088
1089/*
1090 * This is normal for a diff that doesn't change anything: we'll fall through
1091 * into the next diff. Tell the parser to break out.
1092 */
1093static int gitdiff_unrecognized(const char *line, struct patch *patch)
1094{
1095        return -1;
1096}
1097
1098/*
1099 * Skip p_value leading components from "line"; as we do not accept
1100 * absolute paths, return NULL in that case.
1101 */
1102static const char *skip_tree_prefix(const char *line, int llen)
1103{
1104        int nslash;
1105        int i;
1106
1107        if (!p_value)
1108                return (llen && line[0] == '/') ? NULL : line;
1109
1110        nslash = p_value;
1111        for (i = 0; i < llen; i++) {
1112                int ch = line[i];
1113                if (ch == '/' && --nslash <= 0)
1114                        return (i == 0) ? NULL : &line[i + 1];
1115        }
1116        return NULL;
1117}
1118
1119/*
1120 * This is to extract the same name that appears on "diff --git"
1121 * line.  We do not find and return anything if it is a rename
1122 * patch, and it is OK because we will find the name elsewhere.
1123 * We need to reliably find name only when it is mode-change only,
1124 * creation or deletion of an empty file.  In any of these cases,
1125 * both sides are the same name under a/ and b/ respectively.
1126 */
1127static char *git_header_name(const char *line, int llen)
1128{
1129        const char *name;
1130        const char *second = NULL;
1131        size_t len, line_len;
1132
1133        line += strlen("diff --git ");
1134        llen -= strlen("diff --git ");
1135
1136        if (*line == '"') {
1137                const char *cp;
1138                struct strbuf first = STRBUF_INIT;
1139                struct strbuf sp = STRBUF_INIT;
1140
1141                if (unquote_c_style(&first, line, &second))
1142                        goto free_and_fail1;
1143
1144                /* strip the a/b prefix including trailing slash */
1145                cp = skip_tree_prefix(first.buf, first.len);
1146                if (!cp)
1147                        goto free_and_fail1;
1148                strbuf_remove(&first, 0, cp - first.buf);
1149
1150                /*
1151                 * second points at one past closing dq of name.
1152                 * find the second name.
1153                 */
1154                while ((second < line + llen) && isspace(*second))
1155                        second++;
1156
1157                if (line + llen <= second)
1158                        goto free_and_fail1;
1159                if (*second == '"') {
1160                        if (unquote_c_style(&sp, second, NULL))
1161                                goto free_and_fail1;
1162                        cp = skip_tree_prefix(sp.buf, sp.len);
1163                        if (!cp)
1164                                goto free_and_fail1;
1165                        /* They must match, otherwise ignore */
1166                        if (strcmp(cp, first.buf))
1167                                goto free_and_fail1;
1168                        strbuf_release(&sp);
1169                        return strbuf_detach(&first, NULL);
1170                }
1171
1172                /* unquoted second */
1173                cp = skip_tree_prefix(second, line + llen - second);
1174                if (!cp)
1175                        goto free_and_fail1;
1176                if (line + llen - cp != first.len ||
1177                    memcmp(first.buf, cp, first.len))
1178                        goto free_and_fail1;
1179                return strbuf_detach(&first, NULL);
1180
1181        free_and_fail1:
1182                strbuf_release(&first);
1183                strbuf_release(&sp);
1184                return NULL;
1185        }
1186
1187        /* unquoted first name */
1188        name = skip_tree_prefix(line, llen);
1189        if (!name)
1190                return NULL;
1191
1192        /*
1193         * since the first name is unquoted, a dq if exists must be
1194         * the beginning of the second name.
1195         */
1196        for (second = name; second < line + llen; second++) {
1197                if (*second == '"') {
1198                        struct strbuf sp = STRBUF_INIT;
1199                        const char *np;
1200
1201                        if (unquote_c_style(&sp, second, NULL))
1202                                goto free_and_fail2;
1203
1204                        np = skip_tree_prefix(sp.buf, sp.len);
1205                        if (!np)
1206                                goto free_and_fail2;
1207
1208                        len = sp.buf + sp.len - np;
1209                        if (len < second - name &&
1210                            !strncmp(np, name, len) &&
1211                            isspace(name[len])) {
1212                                /* Good */
1213                                strbuf_remove(&sp, 0, np - sp.buf);
1214                                return strbuf_detach(&sp, NULL);
1215                        }
1216
1217                free_and_fail2:
1218                        strbuf_release(&sp);
1219                        return NULL;
1220                }
1221        }
1222
1223        /*
1224         * Accept a name only if it shows up twice, exactly the same
1225         * form.
1226         */
1227        second = strchr(name, '\n');
1228        if (!second)
1229                return NULL;
1230        line_len = second - name;
1231        for (len = 0 ; ; len++) {
1232                switch (name[len]) {
1233                default:
1234                        continue;
1235                case '\n':
1236                        return NULL;
1237                case '\t': case ' ':
1238                        /*
1239                         * Is this the separator between the preimage
1240                         * and the postimage pathname?  Again, we are
1241                         * only interested in the case where there is
1242                         * no rename, as this is only to set def_name
1243                         * and a rename patch has the names elsewhere
1244                         * in an unambiguous form.
1245                         */
1246                        if (!name[len + 1])
1247                                return NULL; /* no postimage name */
1248                        second = skip_tree_prefix(name + len + 1,
1249                                                  line_len - (len + 1));
1250                        if (!second)
1251                                return NULL;
1252                        /*
1253                         * Does len bytes starting at "name" and "second"
1254                         * (that are separated by one HT or SP we just
1255                         * found) exactly match?
1256                         */
1257                        if (second[len] == '\n' && !strncmp(name, second, len))
1258                                return xmemdupz(name, len);
1259                }
1260        }
1261}
1262
1263/* Verify that we recognize the lines following a git header */
1264static int parse_git_header(const char *line, int len, unsigned int size, struct patch *patch)
1265{
1266        unsigned long offset;
1267
1268        /* A git diff has explicit new/delete information, so we don't guess */
1269        patch->is_new = 0;
1270        patch->is_delete = 0;
1271
1272        /*
1273         * Some things may not have the old name in the
1274         * rest of the headers anywhere (pure mode changes,
1275         * or removing or adding empty files), so we get
1276         * the default name from the header.
1277         */
1278        patch->def_name = git_header_name(line, len);
1279        if (patch->def_name && root) {
1280                char *s = xmalloc(root_len + strlen(patch->def_name) + 1);
1281                strcpy(s, root);
1282                strcpy(s + root_len, patch->def_name);
1283                free(patch->def_name);
1284                patch->def_name = s;
1285        }
1286
1287        line += len;
1288        size -= len;
1289        linenr++;
1290        for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) {
1291                static const struct opentry {
1292                        const char *str;
1293                        int (*fn)(const char *, struct patch *);
1294                } optable[] = {
1295                        { "@@ -", gitdiff_hdrend },
1296                        { "--- ", gitdiff_oldname },
1297                        { "+++ ", gitdiff_newname },
1298                        { "old mode ", gitdiff_oldmode },
1299                        { "new mode ", gitdiff_newmode },
1300                        { "deleted file mode ", gitdiff_delete },
1301                        { "new file mode ", gitdiff_newfile },
1302                        { "copy from ", gitdiff_copysrc },
1303                        { "copy to ", gitdiff_copydst },
1304                        { "rename old ", gitdiff_renamesrc },
1305                        { "rename new ", gitdiff_renamedst },
1306                        { "rename from ", gitdiff_renamesrc },
1307                        { "rename to ", gitdiff_renamedst },
1308                        { "similarity index ", gitdiff_similarity },
1309                        { "dissimilarity index ", gitdiff_dissimilarity },
1310                        { "index ", gitdiff_index },
1311                        { "", gitdiff_unrecognized },
1312                };
1313                int i;
1314
1315                len = linelen(line, size);
1316                if (!len || line[len-1] != '\n')
1317                        break;
1318                for (i = 0; i < ARRAY_SIZE(optable); i++) {
1319                        const struct opentry *p = optable + i;
1320                        int oplen = strlen(p->str);
1321                        if (len < oplen || memcmp(p->str, line, oplen))
1322                                continue;
1323                        if (p->fn(line + oplen, patch) < 0)
1324                                return offset;
1325                        break;
1326                }
1327        }
1328
1329        return offset;
1330}
1331
1332static int parse_num(const char *line, unsigned long *p)
1333{
1334        char *ptr;
1335
1336        if (!isdigit(*line))
1337                return 0;
1338        *p = strtoul(line, &ptr, 10);
1339        return ptr - line;
1340}
1341
1342static int parse_range(const char *line, int len, int offset, const char *expect,
1343                       unsigned long *p1, unsigned long *p2)
1344{
1345        int digits, ex;
1346
1347        if (offset < 0 || offset >= len)
1348                return -1;
1349        line += offset;
1350        len -= offset;
1351
1352        digits = parse_num(line, p1);
1353        if (!digits)
1354                return -1;
1355
1356        offset += digits;
1357        line += digits;
1358        len -= digits;
1359
1360        *p2 = 1;
1361        if (*line == ',') {
1362                digits = parse_num(line+1, p2);
1363                if (!digits)
1364                        return -1;
1365
1366                offset += digits+1;
1367                line += digits+1;
1368                len -= digits+1;
1369        }
1370
1371        ex = strlen(expect);
1372        if (ex > len)
1373                return -1;
1374        if (memcmp(line, expect, ex))
1375                return -1;
1376
1377        return offset + ex;
1378}
1379
1380static void recount_diff(const char *line, int size, struct fragment *fragment)
1381{
1382        int oldlines = 0, newlines = 0, ret = 0;
1383
1384        if (size < 1) {
1385                warning("recount: ignore empty hunk");
1386                return;
1387        }
1388
1389        for (;;) {
1390                int len = linelen(line, size);
1391                size -= len;
1392                line += len;
1393
1394                if (size < 1)
1395                        break;
1396
1397                switch (*line) {
1398                case ' ': case '\n':
1399                        newlines++;
1400                        /* fall through */
1401                case '-':
1402                        oldlines++;
1403                        continue;
1404                case '+':
1405                        newlines++;
1406                        continue;
1407                case '\\':
1408                        continue;
1409                case '@':
1410                        ret = size < 3 || prefixcmp(line, "@@ ");
1411                        break;
1412                case 'd':
1413                        ret = size < 5 || prefixcmp(line, "diff ");
1414                        break;
1415                default:
1416                        ret = -1;
1417                        break;
1418                }
1419                if (ret) {
1420                        warning(_("recount: unexpected line: %.*s"),
1421                                (int)linelen(line, size), line);
1422                        return;
1423                }
1424                break;
1425        }
1426        fragment->oldlines = oldlines;
1427        fragment->newlines = newlines;
1428}
1429
1430/*
1431 * Parse a unified diff fragment header of the
1432 * form "@@ -a,b +c,d @@"
1433 */
1434static int parse_fragment_header(const char *line, int len, struct fragment *fragment)
1435{
1436        int offset;
1437
1438        if (!len || line[len-1] != '\n')
1439                return -1;
1440
1441        /* Figure out the number of lines in a fragment */
1442        offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);
1443        offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);
1444
1445        return offset;
1446}
1447
1448static int find_header(const char *line, unsigned long size, int *hdrsize, struct patch *patch)
1449{
1450        unsigned long offset, len;
1451
1452        patch->is_toplevel_relative = 0;
1453        patch->is_rename = patch->is_copy = 0;
1454        patch->is_new = patch->is_delete = -1;
1455        patch->old_mode = patch->new_mode = 0;
1456        patch->old_name = patch->new_name = NULL;
1457        for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {
1458                unsigned long nextlen;
1459
1460                len = linelen(line, size);
1461                if (!len)
1462                        break;
1463
1464                /* Testing this early allows us to take a few shortcuts.. */
1465                if (len < 6)
1466                        continue;
1467
1468                /*
1469                 * Make sure we don't find any unconnected patch fragments.
1470                 * That's a sign that we didn't find a header, and that a
1471                 * patch has become corrupted/broken up.
1472                 */
1473                if (!memcmp("@@ -", line, 4)) {
1474                        struct fragment dummy;
1475                        if (parse_fragment_header(line, len, &dummy) < 0)
1476                                continue;
1477                        die(_("patch fragment without header at line %d: %.*s"),
1478                            linenr, (int)len-1, line);
1479                }
1480
1481                if (size < len + 6)
1482                        break;
1483
1484                /*
1485                 * Git patch? It might not have a real patch, just a rename
1486                 * or mode change, so we handle that specially
1487                 */
1488                if (!memcmp("diff --git ", line, 11)) {
1489                        int git_hdr_len = parse_git_header(line, len, size, patch);
1490                        if (git_hdr_len <= len)
1491                                continue;
1492                        if (!patch->old_name && !patch->new_name) {
1493                                if (!patch->def_name)
1494                                        die(Q_("git diff header lacks filename information when removing "
1495                                               "%d leading pathname component (line %d)",
1496                                               "git diff header lacks filename information when removing "
1497                                               "%d leading pathname components (line %d)",
1498                                               p_value),
1499                                            p_value, linenr);
1500                                patch->old_name = xstrdup(patch->def_name);
1501                                patch->new_name = xstrdup(patch->def_name);
1502                        }
1503                        if (!patch->is_delete && !patch->new_name)
1504                                die("git diff header lacks filename information "
1505                                    "(line %d)", linenr);
1506                        patch->is_toplevel_relative = 1;
1507                        *hdrsize = git_hdr_len;
1508                        return offset;
1509                }
1510
1511                /* --- followed by +++ ? */
1512                if (memcmp("--- ", line,  4) || memcmp("+++ ", line + len, 4))
1513                        continue;
1514
1515                /*
1516                 * We only accept unified patches, so we want it to
1517                 * at least have "@@ -a,b +c,d @@\n", which is 14 chars
1518                 * minimum ("@@ -0,0 +1 @@\n" is the shortest).
1519                 */
1520                nextlen = linelen(line + len, size - len);
1521                if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))
1522                        continue;
1523
1524                /* Ok, we'll consider it a patch */
1525                parse_traditional_patch(line, line+len, patch);
1526                *hdrsize = len + nextlen;
1527                linenr += 2;
1528                return offset;
1529        }
1530        return -1;
1531}
1532
1533static void record_ws_error(unsigned result, const char *line, int len, int linenr)
1534{
1535        char *err;
1536
1537        if (!result)
1538                return;
1539
1540        whitespace_error++;
1541        if (squelch_whitespace_errors &&
1542            squelch_whitespace_errors < whitespace_error)
1543                return;
1544
1545        err = whitespace_error_string(result);
1546        fprintf(stderr, "%s:%d: %s.\n%.*s\n",
1547                patch_input_file, linenr, err, len, line);
1548        free(err);
1549}
1550
1551static void check_whitespace(const char *line, int len, unsigned ws_rule)
1552{
1553        unsigned result = ws_check(line + 1, len - 1, ws_rule);
1554
1555        record_ws_error(result, line + 1, len - 2, linenr);
1556}
1557
1558/*
1559 * Parse a unified diff. Note that this really needs to parse each
1560 * fragment separately, since the only way to know the difference
1561 * between a "---" that is part of a patch, and a "---" that starts
1562 * the next patch is to look at the line counts..
1563 */
1564static int parse_fragment(const char *line, unsigned long size,
1565                          struct patch *patch, struct fragment *fragment)
1566{
1567        int added, deleted;
1568        int len = linelen(line, size), offset;
1569        unsigned long oldlines, newlines;
1570        unsigned long leading, trailing;
1571
1572        offset = parse_fragment_header(line, len, fragment);
1573        if (offset < 0)
1574                return -1;
1575        if (offset > 0 && patch->recount)
1576                recount_diff(line + offset, size - offset, fragment);
1577        oldlines = fragment->oldlines;
1578        newlines = fragment->newlines;
1579        leading = 0;
1580        trailing = 0;
1581
1582        /* Parse the thing.. */
1583        line += len;
1584        size -= len;
1585        linenr++;
1586        added = deleted = 0;
1587        for (offset = len;
1588             0 < size;
1589             offset += len, size -= len, line += len, linenr++) {
1590                if (!oldlines && !newlines)
1591                        break;
1592                len = linelen(line, size);
1593                if (!len || line[len-1] != '\n')
1594                        return -1;
1595                switch (*line) {
1596                default:
1597                        return -1;
1598                case '\n': /* newer GNU diff, an empty context line */
1599                case ' ':
1600                        oldlines--;
1601                        newlines--;
1602                        if (!deleted && !added)
1603                                leading++;
1604                        trailing++;
1605                        break;
1606                case '-':
1607                        if (apply_in_reverse &&
1608                            ws_error_action != nowarn_ws_error)
1609                                check_whitespace(line, len, patch->ws_rule);
1610                        deleted++;
1611                        oldlines--;
1612                        trailing = 0;
1613                        break;
1614                case '+':
1615                        if (!apply_in_reverse &&
1616                            ws_error_action != nowarn_ws_error)
1617                                check_whitespace(line, len, patch->ws_rule);
1618                        added++;
1619                        newlines--;
1620                        trailing = 0;
1621                        break;
1622
1623                /*
1624                 * We allow "\ No newline at end of file". Depending
1625                 * on locale settings when the patch was produced we
1626                 * don't know what this line looks like. The only
1627                 * thing we do know is that it begins with "\ ".
1628                 * Checking for 12 is just for sanity check -- any
1629                 * l10n of "\ No newline..." is at least that long.
1630                 */
1631                case '\\':
1632                        if (len < 12 || memcmp(line, "\\ ", 2))
1633                                return -1;
1634                        break;
1635                }
1636        }
1637        if (oldlines || newlines)
1638                return -1;
1639        fragment->leading = leading;
1640        fragment->trailing = trailing;
1641
1642        /*
1643         * If a fragment ends with an incomplete line, we failed to include
1644         * it in the above loop because we hit oldlines == newlines == 0
1645         * before seeing it.
1646         */
1647        if (12 < size && !memcmp(line, "\\ ", 2))
1648                offset += linelen(line, size);
1649
1650        patch->lines_added += added;
1651        patch->lines_deleted += deleted;
1652
1653        if (0 < patch->is_new && oldlines)
1654                return error(_("new file depends on old contents"));
1655        if (0 < patch->is_delete && newlines)
1656                return error(_("deleted file still has contents"));
1657        return offset;
1658}
1659
1660/*
1661 * We have seen "diff --git a/... b/..." header (or a traditional patch
1662 * header).  Read hunks that belong to this patch into fragments and hang
1663 * them to the given patch structure.
1664 *
1665 * The (fragment->patch, fragment->size) pair points into the memory given
1666 * by the caller, not a copy, when we return.
1667 */
1668static int parse_single_patch(const char *line, unsigned long size, struct patch *patch)
1669{
1670        unsigned long offset = 0;
1671        unsigned long oldlines = 0, newlines = 0, context = 0;
1672        struct fragment **fragp = &patch->fragments;
1673
1674        while (size > 4 && !memcmp(line, "@@ -", 4)) {
1675                struct fragment *fragment;
1676                int len;
1677
1678                fragment = xcalloc(1, sizeof(*fragment));
1679                fragment->linenr = linenr;
1680                len = parse_fragment(line, size, patch, fragment);
1681                if (len <= 0)
1682                        die(_("corrupt patch at line %d"), linenr);
1683                fragment->patch = line;
1684                fragment->size = len;
1685                oldlines += fragment->oldlines;
1686                newlines += fragment->newlines;
1687                context += fragment->leading + fragment->trailing;
1688
1689                *fragp = fragment;
1690                fragp = &fragment->next;
1691
1692                offset += len;
1693                line += len;
1694                size -= len;
1695        }
1696
1697        /*
1698         * If something was removed (i.e. we have old-lines) it cannot
1699         * be creation, and if something was added it cannot be
1700         * deletion.  However, the reverse is not true; --unified=0
1701         * patches that only add are not necessarily creation even
1702         * though they do not have any old lines, and ones that only
1703         * delete are not necessarily deletion.
1704         *
1705         * Unfortunately, a real creation/deletion patch do _not_ have
1706         * any context line by definition, so we cannot safely tell it
1707         * apart with --unified=0 insanity.  At least if the patch has
1708         * more than one hunk it is not creation or deletion.
1709         */
1710        if (patch->is_new < 0 &&
1711            (oldlines || (patch->fragments && patch->fragments->next)))
1712                patch->is_new = 0;
1713        if (patch->is_delete < 0 &&
1714            (newlines || (patch->fragments && patch->fragments->next)))
1715                patch->is_delete = 0;
1716
1717        if (0 < patch->is_new && oldlines)
1718                die(_("new file %s depends on old contents"), patch->new_name);
1719        if (0 < patch->is_delete && newlines)
1720                die(_("deleted file %s still has contents"), patch->old_name);
1721        if (!patch->is_delete && !newlines && context)
1722                fprintf_ln(stderr,
1723                           _("** warning: "
1724                             "file %s becomes empty but is not deleted"),
1725                           patch->new_name);
1726
1727        return offset;
1728}
1729
1730static inline int metadata_changes(struct patch *patch)
1731{
1732        return  patch->is_rename > 0 ||
1733                patch->is_copy > 0 ||
1734                patch->is_new > 0 ||
1735                patch->is_delete ||
1736                (patch->old_mode && patch->new_mode &&
1737                 patch->old_mode != patch->new_mode);
1738}
1739
1740static char *inflate_it(const void *data, unsigned long size,
1741                        unsigned long inflated_size)
1742{
1743        git_zstream stream;
1744        void *out;
1745        int st;
1746
1747        memset(&stream, 0, sizeof(stream));
1748
1749        stream.next_in = (unsigned char *)data;
1750        stream.avail_in = size;
1751        stream.next_out = out = xmalloc(inflated_size);
1752        stream.avail_out = inflated_size;
1753        git_inflate_init(&stream);
1754        st = git_inflate(&stream, Z_FINISH);
1755        git_inflate_end(&stream);
1756        if ((st != Z_STREAM_END) || stream.total_out != inflated_size) {
1757                free(out);
1758                return NULL;
1759        }
1760        return out;
1761}
1762
1763/*
1764 * Read a binary hunk and return a new fragment; fragment->patch
1765 * points at an allocated memory that the caller must free, so
1766 * it is marked as "->free_patch = 1".
1767 */
1768static struct fragment *parse_binary_hunk(char **buf_p,
1769                                          unsigned long *sz_p,
1770                                          int *status_p,
1771                                          int *used_p)
1772{
1773        /*
1774         * Expect a line that begins with binary patch method ("literal"
1775         * or "delta"), followed by the length of data before deflating.
1776         * a sequence of 'length-byte' followed by base-85 encoded data
1777         * should follow, terminated by a newline.
1778         *
1779         * Each 5-byte sequence of base-85 encodes up to 4 bytes,
1780         * and we would limit the patch line to 66 characters,
1781         * so one line can fit up to 13 groups that would decode
1782         * to 52 bytes max.  The length byte 'A'-'Z' corresponds
1783         * to 1-26 bytes, and 'a'-'z' corresponds to 27-52 bytes.
1784         */
1785        int llen, used;
1786        unsigned long size = *sz_p;
1787        char *buffer = *buf_p;
1788        int patch_method;
1789        unsigned long origlen;
1790        char *data = NULL;
1791        int hunk_size = 0;
1792        struct fragment *frag;
1793
1794        llen = linelen(buffer, size);
1795        used = llen;
1796
1797        *status_p = 0;
1798
1799        if (!prefixcmp(buffer, "delta ")) {
1800                patch_method = BINARY_DELTA_DEFLATED;
1801                origlen = strtoul(buffer + 6, NULL, 10);
1802        }
1803        else if (!prefixcmp(buffer, "literal ")) {
1804                patch_method = BINARY_LITERAL_DEFLATED;
1805                origlen = strtoul(buffer + 8, NULL, 10);
1806        }
1807        else
1808                return NULL;
1809
1810        linenr++;
1811        buffer += llen;
1812        while (1) {
1813                int byte_length, max_byte_length, newsize;
1814                llen = linelen(buffer, size);
1815                used += llen;
1816                linenr++;
1817                if (llen == 1) {
1818                        /* consume the blank line */
1819                        buffer++;
1820                        size--;
1821                        break;
1822                }
1823                /*
1824                 * Minimum line is "A00000\n" which is 7-byte long,
1825                 * and the line length must be multiple of 5 plus 2.
1826                 */
1827                if ((llen < 7) || (llen-2) % 5)
1828                        goto corrupt;
1829                max_byte_length = (llen - 2) / 5 * 4;
1830                byte_length = *buffer;
1831                if ('A' <= byte_length && byte_length <= 'Z')
1832                        byte_length = byte_length - 'A' + 1;
1833                else if ('a' <= byte_length && byte_length <= 'z')
1834                        byte_length = byte_length - 'a' + 27;
1835                else
1836                        goto corrupt;
1837                /* if the input length was not multiple of 4, we would
1838                 * have filler at the end but the filler should never
1839                 * exceed 3 bytes
1840                 */
1841                if (max_byte_length < byte_length ||
1842                    byte_length <= max_byte_length - 4)
1843                        goto corrupt;
1844                newsize = hunk_size + byte_length;
1845                data = xrealloc(data, newsize);
1846                if (decode_85(data + hunk_size, buffer + 1, byte_length))
1847                        goto corrupt;
1848                hunk_size = newsize;
1849                buffer += llen;
1850                size -= llen;
1851        }
1852
1853        frag = xcalloc(1, sizeof(*frag));
1854        frag->patch = inflate_it(data, hunk_size, origlen);
1855        frag->free_patch = 1;
1856        if (!frag->patch)
1857                goto corrupt;
1858        free(data);
1859        frag->size = origlen;
1860        *buf_p = buffer;
1861        *sz_p = size;
1862        *used_p = used;
1863        frag->binary_patch_method = patch_method;
1864        return frag;
1865
1866 corrupt:
1867        free(data);
1868        *status_p = -1;
1869        error(_("corrupt binary patch at line %d: %.*s"),
1870              linenr-1, llen-1, buffer);
1871        return NULL;
1872}
1873
1874static int parse_binary(char *buffer, unsigned long size, struct patch *patch)
1875{
1876        /*
1877         * We have read "GIT binary patch\n"; what follows is a line
1878         * that says the patch method (currently, either "literal" or
1879         * "delta") and the length of data before deflating; a
1880         * sequence of 'length-byte' followed by base-85 encoded data
1881         * follows.
1882         *
1883         * When a binary patch is reversible, there is another binary
1884         * hunk in the same format, starting with patch method (either
1885         * "literal" or "delta") with the length of data, and a sequence
1886         * of length-byte + base-85 encoded data, terminated with another
1887         * empty line.  This data, when applied to the postimage, produces
1888         * the preimage.
1889         */
1890        struct fragment *forward;
1891        struct fragment *reverse;
1892        int status;
1893        int used, used_1;
1894
1895        forward = parse_binary_hunk(&buffer, &size, &status, &used);
1896        if (!forward && !status)
1897                /* there has to be one hunk (forward hunk) */
1898                return error(_("unrecognized binary patch at line %d"), linenr-1);
1899        if (status)
1900                /* otherwise we already gave an error message */
1901                return status;
1902
1903        reverse = parse_binary_hunk(&buffer, &size, &status, &used_1);
1904        if (reverse)
1905                used += used_1;
1906        else if (status) {
1907                /*
1908                 * Not having reverse hunk is not an error, but having
1909                 * a corrupt reverse hunk is.
1910                 */
1911                free((void*) forward->patch);
1912                free(forward);
1913                return status;
1914        }
1915        forward->next = reverse;
1916        patch->fragments = forward;
1917        patch->is_binary = 1;
1918        return used;
1919}
1920
1921/*
1922 * Read the patch text in "buffer" taht extends for "size" bytes; stop
1923 * reading after seeing a single patch (i.e. changes to a single file).
1924 * Create fragments (i.e. patch hunks) and hang them to the given patch.
1925 * Return the number of bytes consumed, so that the caller can call us
1926 * again for the next patch.
1927 */
1928static int parse_chunk(char *buffer, unsigned long size, struct patch *patch)
1929{
1930        int hdrsize, patchsize;
1931        int offset = find_header(buffer, size, &hdrsize, patch);
1932
1933        if (offset < 0)
1934                return offset;
1935
1936        patch->ws_rule = whitespace_rule(patch->new_name
1937                                         ? patch->new_name
1938                                         : patch->old_name);
1939
1940        patchsize = parse_single_patch(buffer + offset + hdrsize,
1941                                       size - offset - hdrsize, patch);
1942
1943        if (!patchsize) {
1944                static const char *binhdr[] = {
1945                        "Binary files ",
1946                        "Files ",
1947                        NULL,
1948                };
1949                static const char git_binary[] = "GIT binary patch\n";
1950                int i;
1951                int hd = hdrsize + offset;
1952                unsigned long llen = linelen(buffer + hd, size - hd);
1953
1954                if (llen == sizeof(git_binary) - 1 &&
1955                    !memcmp(git_binary, buffer + hd, llen)) {
1956                        int used;
1957                        linenr++;
1958                        used = parse_binary(buffer + hd + llen,
1959                                            size - hd - llen, patch);
1960                        if (used)
1961                                patchsize = used + llen;
1962                        else
1963                                patchsize = 0;
1964                }
1965                else if (!memcmp(" differ\n", buffer + hd + llen - 8, 8)) {
1966                        for (i = 0; binhdr[i]; i++) {
1967                                int len = strlen(binhdr[i]);
1968                                if (len < size - hd &&
1969                                    !memcmp(binhdr[i], buffer + hd, len)) {
1970                                        linenr++;
1971                                        patch->is_binary = 1;
1972                                        patchsize = llen;
1973                                        break;
1974                                }
1975                        }
1976                }
1977
1978                /* Empty patch cannot be applied if it is a text patch
1979                 * without metadata change.  A binary patch appears
1980                 * empty to us here.
1981                 */
1982                if ((apply || check) &&
1983                    (!patch->is_binary && !metadata_changes(patch)))
1984                        die(_("patch with only garbage at line %d"), linenr);
1985        }
1986
1987        return offset + hdrsize + patchsize;
1988}
1989
1990#define swap(a,b) myswap((a),(b),sizeof(a))
1991
1992#define myswap(a, b, size) do {         \
1993        unsigned char mytmp[size];      \
1994        memcpy(mytmp, &a, size);                \
1995        memcpy(&a, &b, size);           \
1996        memcpy(&b, mytmp, size);                \
1997} while (0)
1998
1999static void reverse_patches(struct patch *p)
2000{
2001        for (; p; p = p->next) {
2002                struct fragment *frag = p->fragments;
2003
2004                swap(p->new_name, p->old_name);
2005                swap(p->new_mode, p->old_mode);
2006                swap(p->is_new, p->is_delete);
2007                swap(p->lines_added, p->lines_deleted);
2008                swap(p->old_sha1_prefix, p->new_sha1_prefix);
2009
2010                for (; frag; frag = frag->next) {
2011                        swap(frag->newpos, frag->oldpos);
2012                        swap(frag->newlines, frag->oldlines);
2013                }
2014        }
2015}
2016
2017static const char pluses[] =
2018"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
2019static const char minuses[]=
2020"----------------------------------------------------------------------";
2021
2022static void show_stats(struct patch *patch)
2023{
2024        struct strbuf qname = STRBUF_INIT;
2025        char *cp = patch->new_name ? patch->new_name : patch->old_name;
2026        int max, add, del;
2027
2028        quote_c_style(cp, &qname, NULL, 0);
2029
2030        /*
2031         * "scale" the filename
2032         */
2033        max = max_len;
2034        if (max > 50)
2035                max = 50;
2036
2037        if (qname.len > max) {
2038                cp = strchr(qname.buf + qname.len + 3 - max, '/');
2039                if (!cp)
2040                        cp = qname.buf + qname.len + 3 - max;
2041                strbuf_splice(&qname, 0, cp - qname.buf, "...", 3);
2042        }
2043
2044        if (patch->is_binary) {
2045                printf(" %-*s |  Bin\n", max, qname.buf);
2046                strbuf_release(&qname);
2047                return;
2048        }
2049
2050        printf(" %-*s |", max, qname.buf);
2051        strbuf_release(&qname);
2052
2053        /*
2054         * scale the add/delete
2055         */
2056        max = max + max_change > 70 ? 70 - max : max_change;
2057        add = patch->lines_added;
2058        del = patch->lines_deleted;
2059
2060        if (max_change > 0) {
2061                int total = ((add + del) * max + max_change / 2) / max_change;
2062                add = (add * max + max_change / 2) / max_change;
2063                del = total - add;
2064        }
2065        printf("%5d %.*s%.*s\n", patch->lines_added + patch->lines_deleted,
2066                add, pluses, del, minuses);
2067}
2068
2069static int read_old_data(struct stat *st, const char *path, struct strbuf *buf)
2070{
2071        switch (st->st_mode & S_IFMT) {
2072        case S_IFLNK:
2073                if (strbuf_readlink(buf, path, st->st_size) < 0)
2074                        return error(_("unable to read symlink %s"), path);
2075                return 0;
2076        case S_IFREG:
2077                if (strbuf_read_file(buf, path, st->st_size) != st->st_size)
2078                        return error(_("unable to open or read %s"), path);
2079                convert_to_git(path, buf->buf, buf->len, buf, 0);
2080                return 0;
2081        default:
2082                return -1;
2083        }
2084}
2085
2086/*
2087 * Update the preimage, and the common lines in postimage,
2088 * from buffer buf of length len. If postlen is 0 the postimage
2089 * is updated in place, otherwise it's updated on a new buffer
2090 * of length postlen
2091 */
2092
2093static void update_pre_post_images(struct image *preimage,
2094                                   struct image *postimage,
2095                                   char *buf,
2096                                   size_t len, size_t postlen)
2097{
2098        int i, ctx;
2099        char *new, *old, *fixed;
2100        struct image fixed_preimage;
2101
2102        /*
2103         * Update the preimage with whitespace fixes.  Note that we
2104         * are not losing preimage->buf -- apply_one_fragment() will
2105         * free "oldlines".
2106         */
2107        prepare_image(&fixed_preimage, buf, len, 1);
2108        assert(fixed_preimage.nr == preimage->nr);
2109        for (i = 0; i < preimage->nr; i++)
2110                fixed_preimage.line[i].flag = preimage->line[i].flag;
2111        free(preimage->line_allocated);
2112        *preimage = fixed_preimage;
2113
2114        /*
2115         * Adjust the common context lines in postimage. This can be
2116         * done in-place when we are just doing whitespace fixing,
2117         * which does not make the string grow, but needs a new buffer
2118         * when ignoring whitespace causes the update, since in this case
2119         * we could have e.g. tabs converted to multiple spaces.
2120         * We trust the caller to tell us if the update can be done
2121         * in place (postlen==0) or not.
2122         */
2123        old = postimage->buf;
2124        if (postlen)
2125                new = postimage->buf = xmalloc(postlen);
2126        else
2127                new = old;
2128        fixed = preimage->buf;
2129        for (i = ctx = 0; i < postimage->nr; i++) {
2130                size_t len = postimage->line[i].len;
2131                if (!(postimage->line[i].flag & LINE_COMMON)) {
2132                        /* an added line -- no counterparts in preimage */
2133                        memmove(new, old, len);
2134                        old += len;
2135                        new += len;
2136                        continue;
2137                }
2138
2139                /* a common context -- skip it in the original postimage */
2140                old += len;
2141
2142                /* and find the corresponding one in the fixed preimage */
2143                while (ctx < preimage->nr &&
2144                       !(preimage->line[ctx].flag & LINE_COMMON)) {
2145                        fixed += preimage->line[ctx].len;
2146                        ctx++;
2147                }
2148                if (preimage->nr <= ctx)
2149                        die(_("oops"));
2150
2151                /* and copy it in, while fixing the line length */
2152                len = preimage->line[ctx].len;
2153                memcpy(new, fixed, len);
2154                new += len;
2155                fixed += len;
2156                postimage->line[i].len = len;
2157                ctx++;
2158        }
2159
2160        /* Fix the length of the whole thing */
2161        postimage->len = new - postimage->buf;
2162}
2163
2164static int match_fragment(struct image *img,
2165                          struct image *preimage,
2166                          struct image *postimage,
2167                          unsigned long try,
2168                          int try_lno,
2169                          unsigned ws_rule,
2170                          int match_beginning, int match_end)
2171{
2172        int i;
2173        char *fixed_buf, *buf, *orig, *target;
2174        struct strbuf fixed;
2175        size_t fixed_len;
2176        int preimage_limit;
2177
2178        if (preimage->nr + try_lno <= img->nr) {
2179                /*
2180                 * The hunk falls within the boundaries of img.
2181                 */
2182                preimage_limit = preimage->nr;
2183                if (match_end && (preimage->nr + try_lno != img->nr))
2184                        return 0;
2185        } else if (ws_error_action == correct_ws_error &&
2186                   (ws_rule & WS_BLANK_AT_EOF)) {
2187                /*
2188                 * This hunk extends beyond the end of img, and we are
2189                 * removing blank lines at the end of the file.  This
2190                 * many lines from the beginning of the preimage must
2191                 * match with img, and the remainder of the preimage
2192                 * must be blank.
2193                 */
2194                preimage_limit = img->nr - try_lno;
2195        } else {
2196                /*
2197                 * The hunk extends beyond the end of the img and
2198                 * we are not removing blanks at the end, so we
2199                 * should reject the hunk at this position.
2200                 */
2201                return 0;
2202        }
2203
2204        if (match_beginning && try_lno)
2205                return 0;
2206
2207        /* Quick hash check */
2208        for (i = 0; i < preimage_limit; i++)
2209                if ((img->line[try_lno + i].flag & LINE_PATCHED) ||
2210                    (preimage->line[i].hash != img->line[try_lno + i].hash))
2211                        return 0;
2212
2213        if (preimage_limit == preimage->nr) {
2214                /*
2215                 * Do we have an exact match?  If we were told to match
2216                 * at the end, size must be exactly at try+fragsize,
2217                 * otherwise try+fragsize must be still within the preimage,
2218                 * and either case, the old piece should match the preimage
2219                 * exactly.
2220                 */
2221                if ((match_end
2222                     ? (try + preimage->len == img->len)
2223                     : (try + preimage->len <= img->len)) &&
2224                    !memcmp(img->buf + try, preimage->buf, preimage->len))
2225                        return 1;
2226        } else {
2227                /*
2228                 * The preimage extends beyond the end of img, so
2229                 * there cannot be an exact match.
2230                 *
2231                 * There must be one non-blank context line that match
2232                 * a line before the end of img.
2233                 */
2234                char *buf_end;
2235
2236                buf = preimage->buf;
2237                buf_end = buf;
2238                for (i = 0; i < preimage_limit; i++)
2239                        buf_end += preimage->line[i].len;
2240
2241                for ( ; buf < buf_end; buf++)
2242                        if (!isspace(*buf))
2243                                break;
2244                if (buf == buf_end)
2245                        return 0;
2246        }
2247
2248        /*
2249         * No exact match. If we are ignoring whitespace, run a line-by-line
2250         * fuzzy matching. We collect all the line length information because
2251         * we need it to adjust whitespace if we match.
2252         */
2253        if (ws_ignore_action == ignore_ws_change) {
2254                size_t imgoff = 0;
2255                size_t preoff = 0;
2256                size_t postlen = postimage->len;
2257                size_t extra_chars;
2258                char *preimage_eof;
2259                char *preimage_end;
2260                for (i = 0; i < preimage_limit; i++) {
2261                        size_t prelen = preimage->line[i].len;
2262                        size_t imglen = img->line[try_lno+i].len;
2263
2264                        if (!fuzzy_matchlines(img->buf + try + imgoff, imglen,
2265                                              preimage->buf + preoff, prelen))
2266                                return 0;
2267                        if (preimage->line[i].flag & LINE_COMMON)
2268                                postlen += imglen - prelen;
2269                        imgoff += imglen;
2270                        preoff += prelen;
2271                }
2272
2273                /*
2274                 * Ok, the preimage matches with whitespace fuzz.
2275                 *
2276                 * imgoff now holds the true length of the target that
2277                 * matches the preimage before the end of the file.
2278                 *
2279                 * Count the number of characters in the preimage that fall
2280                 * beyond the end of the file and make sure that all of them
2281                 * are whitespace characters. (This can only happen if
2282                 * we are removing blank lines at the end of the file.)
2283                 */
2284                buf = preimage_eof = preimage->buf + preoff;
2285                for ( ; i < preimage->nr; i++)
2286                        preoff += preimage->line[i].len;
2287                preimage_end = preimage->buf + preoff;
2288                for ( ; buf < preimage_end; buf++)
2289                        if (!isspace(*buf))
2290                                return 0;
2291
2292                /*
2293                 * Update the preimage and the common postimage context
2294                 * lines to use the same whitespace as the target.
2295                 * If whitespace is missing in the target (i.e.
2296                 * if the preimage extends beyond the end of the file),
2297                 * use the whitespace from the preimage.
2298                 */
2299                extra_chars = preimage_end - preimage_eof;
2300                strbuf_init(&fixed, imgoff + extra_chars);
2301                strbuf_add(&fixed, img->buf + try, imgoff);
2302                strbuf_add(&fixed, preimage_eof, extra_chars);
2303                fixed_buf = strbuf_detach(&fixed, &fixed_len);
2304                update_pre_post_images(preimage, postimage,
2305                                fixed_buf, fixed_len, postlen);
2306                return 1;
2307        }
2308
2309        if (ws_error_action != correct_ws_error)
2310                return 0;
2311
2312        /*
2313         * The hunk does not apply byte-by-byte, but the hash says
2314         * it might with whitespace fuzz. We haven't been asked to
2315         * ignore whitespace, we were asked to correct whitespace
2316         * errors, so let's try matching after whitespace correction.
2317         *
2318         * The preimage may extend beyond the end of the file,
2319         * but in this loop we will only handle the part of the
2320         * preimage that falls within the file.
2321         */
2322        strbuf_init(&fixed, preimage->len + 1);
2323        orig = preimage->buf;
2324        target = img->buf + try;
2325        for (i = 0; i < preimage_limit; i++) {
2326                size_t oldlen = preimage->line[i].len;
2327                size_t tgtlen = img->line[try_lno + i].len;
2328                size_t fixstart = fixed.len;
2329                struct strbuf tgtfix;
2330                int match;
2331
2332                /* Try fixing the line in the preimage */
2333                ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);
2334
2335                /* Try fixing the line in the target */
2336                strbuf_init(&tgtfix, tgtlen);
2337                ws_fix_copy(&tgtfix, target, tgtlen, ws_rule, NULL);
2338
2339                /*
2340                 * If they match, either the preimage was based on
2341                 * a version before our tree fixed whitespace breakage,
2342                 * or we are lacking a whitespace-fix patch the tree
2343                 * the preimage was based on already had (i.e. target
2344                 * has whitespace breakage, the preimage doesn't).
2345                 * In either case, we are fixing the whitespace breakages
2346                 * so we might as well take the fix together with their
2347                 * real change.
2348                 */
2349                match = (tgtfix.len == fixed.len - fixstart &&
2350                         !memcmp(tgtfix.buf, fixed.buf + fixstart,
2351                                             fixed.len - fixstart));
2352
2353                strbuf_release(&tgtfix);
2354                if (!match)
2355                        goto unmatch_exit;
2356
2357                orig += oldlen;
2358                target += tgtlen;
2359        }
2360
2361
2362        /*
2363         * Now handle the lines in the preimage that falls beyond the
2364         * end of the file (if any). They will only match if they are
2365         * empty or only contain whitespace (if WS_BLANK_AT_EOL is
2366         * false).
2367         */
2368        for ( ; i < preimage->nr; i++) {
2369                size_t fixstart = fixed.len; /* start of the fixed preimage */
2370                size_t oldlen = preimage->line[i].len;
2371                int j;
2372
2373                /* Try fixing the line in the preimage */
2374                ws_fix_copy(&fixed, orig, oldlen, ws_rule, NULL);
2375
2376                for (j = fixstart; j < fixed.len; j++)
2377                        if (!isspace(fixed.buf[j]))
2378                                goto unmatch_exit;
2379
2380                orig += oldlen;
2381        }
2382
2383        /*
2384         * Yes, the preimage is based on an older version that still
2385         * has whitespace breakages unfixed, and fixing them makes the
2386         * hunk match.  Update the context lines in the postimage.
2387         */
2388        fixed_buf = strbuf_detach(&fixed, &fixed_len);
2389        update_pre_post_images(preimage, postimage,
2390                               fixed_buf, fixed_len, 0);
2391        return 1;
2392
2393 unmatch_exit:
2394        strbuf_release(&fixed);
2395        return 0;
2396}
2397
2398static int find_pos(struct image *img,
2399                    struct image *preimage,
2400                    struct image *postimage,
2401                    int line,
2402                    unsigned ws_rule,
2403                    int match_beginning, int match_end)
2404{
2405        int i;
2406        unsigned long backwards, forwards, try;
2407        int backwards_lno, forwards_lno, try_lno;
2408
2409        /*
2410         * If match_beginning or match_end is specified, there is no
2411         * point starting from a wrong line that will never match and
2412         * wander around and wait for a match at the specified end.
2413         */
2414        if (match_beginning)
2415                line = 0;
2416        else if (match_end)
2417                line = img->nr - preimage->nr;
2418
2419        /*
2420         * Because the comparison is unsigned, the following test
2421         * will also take care of a negative line number that can
2422         * result when match_end and preimage is larger than the target.
2423         */
2424        if ((size_t) line > img->nr)
2425                line = img->nr;
2426
2427        try = 0;
2428        for (i = 0; i < line; i++)
2429                try += img->line[i].len;
2430
2431        /*
2432         * There's probably some smart way to do this, but I'll leave
2433         * that to the smart and beautiful people. I'm simple and stupid.
2434         */
2435        backwards = try;
2436        backwards_lno = line;
2437        forwards = try;
2438        forwards_lno = line;
2439        try_lno = line;
2440
2441        for (i = 0; ; i++) {
2442                if (match_fragment(img, preimage, postimage,
2443                                   try, try_lno, ws_rule,
2444                                   match_beginning, match_end))
2445                        return try_lno;
2446
2447        again:
2448                if (backwards_lno == 0 && forwards_lno == img->nr)
2449                        break;
2450
2451                if (i & 1) {
2452                        if (backwards_lno == 0) {
2453                                i++;
2454                                goto again;
2455                        }
2456                        backwards_lno--;
2457                        backwards -= img->line[backwards_lno].len;
2458                        try = backwards;
2459                        try_lno = backwards_lno;
2460                } else {
2461                        if (forwards_lno == img->nr) {
2462                                i++;
2463                                goto again;
2464                        }
2465                        forwards += img->line[forwards_lno].len;
2466                        forwards_lno++;
2467                        try = forwards;
2468                        try_lno = forwards_lno;
2469                }
2470
2471        }
2472        return -1;
2473}
2474
2475static void remove_first_line(struct image *img)
2476{
2477        img->buf += img->line[0].len;
2478        img->len -= img->line[0].len;
2479        img->line++;
2480        img->nr--;
2481}
2482
2483static void remove_last_line(struct image *img)
2484{
2485        img->len -= img->line[--img->nr].len;
2486}
2487
2488/*
2489 * The change from "preimage" and "postimage" has been found to
2490 * apply at applied_pos (counts in line numbers) in "img".
2491 * Update "img" to remove "preimage" and replace it with "postimage".
2492 */
2493static void update_image(struct image *img,
2494                         int applied_pos,
2495                         struct image *preimage,
2496                         struct image *postimage)
2497{
2498        /*
2499         * remove the copy of preimage at offset in img
2500         * and replace it with postimage
2501         */
2502        int i, nr;
2503        size_t remove_count, insert_count, applied_at = 0;
2504        char *result;
2505        int preimage_limit;
2506
2507        /*
2508         * If we are removing blank lines at the end of img,
2509         * the preimage may extend beyond the end.
2510         * If that is the case, we must be careful only to
2511         * remove the part of the preimage that falls within
2512         * the boundaries of img. Initialize preimage_limit
2513         * to the number of lines in the preimage that falls
2514         * within the boundaries.
2515         */
2516        preimage_limit = preimage->nr;
2517        if (preimage_limit > img->nr - applied_pos)
2518                preimage_limit = img->nr - applied_pos;
2519
2520        for (i = 0; i < applied_pos; i++)
2521                applied_at += img->line[i].len;
2522
2523        remove_count = 0;
2524        for (i = 0; i < preimage_limit; i++)
2525                remove_count += img->line[applied_pos + i].len;
2526        insert_count = postimage->len;
2527
2528        /* Adjust the contents */
2529        result = xmalloc(img->len + insert_count - remove_count + 1);
2530        memcpy(result, img->buf, applied_at);
2531        memcpy(result + applied_at, postimage->buf, postimage->len);
2532        memcpy(result + applied_at + postimage->len,
2533               img->buf + (applied_at + remove_count),
2534               img->len - (applied_at + remove_count));
2535        free(img->buf);
2536        img->buf = result;
2537        img->len += insert_count - remove_count;
2538        result[img->len] = '\0';
2539
2540        /* Adjust the line table */
2541        nr = img->nr + postimage->nr - preimage_limit;
2542        if (preimage_limit < postimage->nr) {
2543                /*
2544                 * NOTE: this knows that we never call remove_first_line()
2545                 * on anything other than pre/post image.
2546                 */
2547                img->line = xrealloc(img->line, nr * sizeof(*img->line));
2548                img->line_allocated = img->line;
2549        }
2550        if (preimage_limit != postimage->nr)
2551                memmove(img->line + applied_pos + postimage->nr,
2552                        img->line + applied_pos + preimage_limit,
2553                        (img->nr - (applied_pos + preimage_limit)) *
2554                        sizeof(*img->line));
2555        memcpy(img->line + applied_pos,
2556               postimage->line,
2557               postimage->nr * sizeof(*img->line));
2558        if (!allow_overlap)
2559                for (i = 0; i < postimage->nr; i++)
2560                        img->line[applied_pos + i].flag |= LINE_PATCHED;
2561        img->nr = nr;
2562}
2563
2564/*
2565 * Use the patch-hunk text in "frag" to prepare two images (preimage and
2566 * postimage) for the hunk.  Find lines that match "preimage" in "img" and
2567 * replace the part of "img" with "postimage" text.
2568 */
2569static int apply_one_fragment(struct image *img, struct fragment *frag,
2570                              int inaccurate_eof, unsigned ws_rule,
2571                              int nth_fragment)
2572{
2573        int match_beginning, match_end;
2574        const char *patch = frag->patch;
2575        int size = frag->size;
2576        char *old, *oldlines;
2577        struct strbuf newlines;
2578        int new_blank_lines_at_end = 0;
2579        int found_new_blank_lines_at_end = 0;
2580        int hunk_linenr = frag->linenr;
2581        unsigned long leading, trailing;
2582        int pos, applied_pos;
2583        struct image preimage;
2584        struct image postimage;
2585
2586        memset(&preimage, 0, sizeof(preimage));
2587        memset(&postimage, 0, sizeof(postimage));
2588        oldlines = xmalloc(size);
2589        strbuf_init(&newlines, size);
2590
2591        old = oldlines;
2592        while (size > 0) {
2593                char first;
2594                int len = linelen(patch, size);
2595                int plen;
2596                int added_blank_line = 0;
2597                int is_blank_context = 0;
2598                size_t start;
2599
2600                if (!len)
2601                        break;
2602
2603                /*
2604                 * "plen" is how much of the line we should use for
2605                 * the actual patch data. Normally we just remove the
2606                 * first character on the line, but if the line is
2607                 * followed by "\ No newline", then we also remove the
2608                 * last one (which is the newline, of course).
2609                 */
2610                plen = len - 1;
2611                if (len < size && patch[len] == '\\')
2612                        plen--;
2613                first = *patch;
2614                if (apply_in_reverse) {
2615                        if (first == '-')
2616                                first = '+';
2617                        else if (first == '+')
2618                                first = '-';
2619                }
2620
2621                switch (first) {
2622                case '\n':
2623                        /* Newer GNU diff, empty context line */
2624                        if (plen < 0)
2625                                /* ... followed by '\No newline'; nothing */
2626                                break;
2627                        *old++ = '\n';
2628                        strbuf_addch(&newlines, '\n');
2629                        add_line_info(&preimage, "\n", 1, LINE_COMMON);
2630                        add_line_info(&postimage, "\n", 1, LINE_COMMON);
2631                        is_blank_context = 1;
2632                        break;
2633                case ' ':
2634                        if (plen && (ws_rule & WS_BLANK_AT_EOF) &&
2635                            ws_blank_line(patch + 1, plen, ws_rule))
2636                                is_blank_context = 1;
2637                case '-':
2638                        memcpy(old, patch + 1, plen);
2639                        add_line_info(&preimage, old, plen,
2640                                      (first == ' ' ? LINE_COMMON : 0));
2641                        old += plen;
2642                        if (first == '-')
2643                                break;
2644                /* Fall-through for ' ' */
2645                case '+':
2646                        /* --no-add does not add new lines */
2647                        if (first == '+' && no_add)
2648                                break;
2649
2650                        start = newlines.len;
2651                        if (first != '+' ||
2652                            !whitespace_error ||
2653                            ws_error_action != correct_ws_error) {
2654                                strbuf_add(&newlines, patch + 1, plen);
2655                        }
2656                        else {
2657                                ws_fix_copy(&newlines, patch + 1, plen, ws_rule, &applied_after_fixing_ws);
2658                        }
2659                        add_line_info(&postimage, newlines.buf + start, newlines.len - start,
2660                                      (first == '+' ? 0 : LINE_COMMON));
2661                        if (first == '+' &&
2662                            (ws_rule & WS_BLANK_AT_EOF) &&
2663                            ws_blank_line(patch + 1, plen, ws_rule))
2664                                added_blank_line = 1;
2665                        break;
2666                case '@': case '\\':
2667                        /* Ignore it, we already handled it */
2668                        break;
2669                default:
2670                        if (apply_verbosely)
2671                                error(_("invalid start of line: '%c'"), first);
2672                        return -1;
2673                }
2674                if (added_blank_line) {
2675                        if (!new_blank_lines_at_end)
2676                                found_new_blank_lines_at_end = hunk_linenr;
2677                        new_blank_lines_at_end++;
2678                }
2679                else if (is_blank_context)
2680                        ;
2681                else
2682                        new_blank_lines_at_end = 0;
2683                patch += len;
2684                size -= len;
2685                hunk_linenr++;
2686        }
2687        if (inaccurate_eof &&
2688            old > oldlines && old[-1] == '\n' &&
2689            newlines.len > 0 && newlines.buf[newlines.len - 1] == '\n') {
2690                old--;
2691                strbuf_setlen(&newlines, newlines.len - 1);
2692        }
2693
2694        leading = frag->leading;
2695        trailing = frag->trailing;
2696
2697        /*
2698         * A hunk to change lines at the beginning would begin with
2699         * @@ -1,L +N,M @@
2700         * but we need to be careful.  -U0 that inserts before the second
2701         * line also has this pattern.
2702         *
2703         * And a hunk to add to an empty file would begin with
2704         * @@ -0,0 +N,M @@
2705         *
2706         * In other words, a hunk that is (frag->oldpos <= 1) with or
2707         * without leading context must match at the beginning.
2708         */
2709        match_beginning = (!frag->oldpos ||
2710                           (frag->oldpos == 1 && !unidiff_zero));
2711
2712        /*
2713         * A hunk without trailing lines must match at the end.
2714         * However, we simply cannot tell if a hunk must match end
2715         * from the lack of trailing lines if the patch was generated
2716         * with unidiff without any context.
2717         */
2718        match_end = !unidiff_zero && !trailing;
2719
2720        pos = frag->newpos ? (frag->newpos - 1) : 0;
2721        preimage.buf = oldlines;
2722        preimage.len = old - oldlines;
2723        postimage.buf = newlines.buf;
2724        postimage.len = newlines.len;
2725        preimage.line = preimage.line_allocated;
2726        postimage.line = postimage.line_allocated;
2727
2728        for (;;) {
2729
2730                applied_pos = find_pos(img, &preimage, &postimage, pos,
2731                                       ws_rule, match_beginning, match_end);
2732
2733                if (applied_pos >= 0)
2734                        break;
2735
2736                /* Am I at my context limits? */
2737                if ((leading <= p_context) && (trailing <= p_context))
2738                        break;
2739                if (match_beginning || match_end) {
2740                        match_beginning = match_end = 0;
2741                        continue;
2742                }
2743
2744                /*
2745                 * Reduce the number of context lines; reduce both
2746                 * leading and trailing if they are equal otherwise
2747                 * just reduce the larger context.
2748                 */
2749                if (leading >= trailing) {
2750                        remove_first_line(&preimage);
2751                        remove_first_line(&postimage);
2752                        pos--;
2753                        leading--;
2754                }
2755                if (trailing > leading) {
2756                        remove_last_line(&preimage);
2757                        remove_last_line(&postimage);
2758                        trailing--;
2759                }
2760        }
2761
2762        if (applied_pos >= 0) {
2763                if (new_blank_lines_at_end &&
2764                    preimage.nr + applied_pos >= img->nr &&
2765                    (ws_rule & WS_BLANK_AT_EOF) &&
2766                    ws_error_action != nowarn_ws_error) {
2767                        record_ws_error(WS_BLANK_AT_EOF, "+", 1,
2768                                        found_new_blank_lines_at_end);
2769                        if (ws_error_action == correct_ws_error) {
2770                                while (new_blank_lines_at_end--)
2771                                        remove_last_line(&postimage);
2772                        }
2773                        /*
2774                         * We would want to prevent write_out_results()
2775                         * from taking place in apply_patch() that follows
2776                         * the callchain led us here, which is:
2777                         * apply_patch->check_patch_list->check_patch->
2778                         * apply_data->apply_fragments->apply_one_fragment
2779                         */
2780                        if (ws_error_action == die_on_ws_error)
2781                                apply = 0;
2782                }
2783
2784                if (apply_verbosely && applied_pos != pos) {
2785                        int offset = applied_pos - pos;
2786                        if (apply_in_reverse)
2787                                offset = 0 - offset;
2788                        fprintf_ln(stderr,
2789                                   Q_("Hunk #%d succeeded at %d (offset %d line).",
2790                                      "Hunk #%d succeeded at %d (offset %d lines).",
2791                                      offset),
2792                                   nth_fragment, applied_pos + 1, offset);
2793                }
2794
2795                /*
2796                 * Warn if it was necessary to reduce the number
2797                 * of context lines.
2798                 */
2799                if ((leading != frag->leading) ||
2800                    (trailing != frag->trailing))
2801                        fprintf_ln(stderr, _("Context reduced to (%ld/%ld)"
2802                                             " to apply fragment at %d"),
2803                                   leading, trailing, applied_pos+1);
2804                update_image(img, applied_pos, &preimage, &postimage);
2805        } else {
2806                if (apply_verbosely)
2807                        error(_("while searching for:\n%.*s"),
2808                              (int)(old - oldlines), oldlines);
2809        }
2810
2811        free(oldlines);
2812        strbuf_release(&newlines);
2813        free(preimage.line_allocated);
2814        free(postimage.line_allocated);
2815
2816        return (applied_pos < 0);
2817}
2818
2819static int apply_binary_fragment(struct image *img, struct patch *patch)
2820{
2821        struct fragment *fragment = patch->fragments;
2822        unsigned long len;
2823        void *dst;
2824
2825        if (!fragment)
2826                return error(_("missing binary patch data for '%s'"),
2827                             patch->new_name ?
2828                             patch->new_name :
2829                             patch->old_name);
2830
2831        /* Binary patch is irreversible without the optional second hunk */
2832        if (apply_in_reverse) {
2833                if (!fragment->next)
2834                        return error("cannot reverse-apply a binary patch "
2835                                     "without the reverse hunk to '%s'",
2836                                     patch->new_name
2837                                     ? patch->new_name : patch->old_name);
2838                fragment = fragment->next;
2839        }
2840        switch (fragment->binary_patch_method) {
2841        case BINARY_DELTA_DEFLATED:
2842                dst = patch_delta(img->buf, img->len, fragment->patch,
2843                                  fragment->size, &len);
2844                if (!dst)
2845                        return -1;
2846                clear_image(img);
2847                img->buf = dst;
2848                img->len = len;
2849                return 0;
2850        case BINARY_LITERAL_DEFLATED:
2851                clear_image(img);
2852                img->len = fragment->size;
2853                img->buf = xmalloc(img->len+1);
2854                memcpy(img->buf, fragment->patch, img->len);
2855                img->buf[img->len] = '\0';
2856                return 0;
2857        }
2858        return -1;
2859}
2860
2861/*
2862 * Replace "img" with the result of applying the binary patch.
2863 * The binary patch data itself in patch->fragment is still kept
2864 * but the preimage prepared by the caller in "img" is freed here
2865 * or in the helper function apply_binary_fragment() this calls.
2866 */
2867static int apply_binary(struct image *img, struct patch *patch)
2868{
2869        const char *name = patch->old_name ? patch->old_name : patch->new_name;
2870        unsigned char sha1[20];
2871
2872        /*
2873         * For safety, we require patch index line to contain
2874         * full 40-byte textual SHA1 for old and new, at least for now.
2875         */
2876        if (strlen(patch->old_sha1_prefix) != 40 ||
2877            strlen(patch->new_sha1_prefix) != 40 ||
2878            get_sha1_hex(patch->old_sha1_prefix, sha1) ||
2879            get_sha1_hex(patch->new_sha1_prefix, sha1))
2880                return error("cannot apply binary patch to '%s' "
2881                             "without full index line", name);
2882
2883        if (patch->old_name) {
2884                /*
2885                 * See if the old one matches what the patch
2886                 * applies to.
2887                 */
2888                hash_sha1_file(img->buf, img->len, blob_type, sha1);
2889                if (strcmp(sha1_to_hex(sha1), patch->old_sha1_prefix))
2890                        return error("the patch applies to '%s' (%s), "
2891                                     "which does not match the "
2892                                     "current contents.",
2893                                     name, sha1_to_hex(sha1));
2894        }
2895        else {
2896                /* Otherwise, the old one must be empty. */
2897                if (img->len)
2898                        return error("the patch applies to an empty "
2899                                     "'%s' but it is not empty", name);
2900        }
2901
2902        get_sha1_hex(patch->new_sha1_prefix, sha1);
2903        if (is_null_sha1(sha1)) {
2904                clear_image(img);
2905                return 0; /* deletion patch */
2906        }
2907
2908        if (has_sha1_file(sha1)) {
2909                /* We already have the postimage */
2910                enum object_type type;
2911                unsigned long size;
2912                char *result;
2913
2914                result = read_sha1_file(sha1, &type, &size);
2915                if (!result)
2916                        return error("the necessary postimage %s for "
2917                                     "'%s' cannot be read",
2918                                     patch->new_sha1_prefix, name);
2919                clear_image(img);
2920                img->buf = result;
2921                img->len = size;
2922        } else {
2923                /*
2924                 * We have verified buf matches the preimage;
2925                 * apply the patch data to it, which is stored
2926                 * in the patch->fragments->{patch,size}.
2927                 */
2928                if (apply_binary_fragment(img, patch))
2929                        return error(_("binary patch does not apply to '%s'"),
2930                                     name);
2931
2932                /* verify that the result matches */
2933                hash_sha1_file(img->buf, img->len, blob_type, sha1);
2934                if (strcmp(sha1_to_hex(sha1), patch->new_sha1_prefix))
2935                        return error(_("binary patch to '%s' creates incorrect result (expecting %s, got %s)"),
2936                                name, patch->new_sha1_prefix, sha1_to_hex(sha1));
2937        }
2938
2939        return 0;
2940}
2941
2942static int apply_fragments(struct image *img, struct patch *patch)
2943{
2944        struct fragment *frag = patch->fragments;
2945        const char *name = patch->old_name ? patch->old_name : patch->new_name;
2946        unsigned ws_rule = patch->ws_rule;
2947        unsigned inaccurate_eof = patch->inaccurate_eof;
2948        int nth = 0;
2949
2950        if (patch->is_binary)
2951                return apply_binary(img, patch);
2952
2953        while (frag) {
2954                nth++;
2955                if (apply_one_fragment(img, frag, inaccurate_eof, ws_rule, nth)) {
2956                        error(_("patch failed: %s:%ld"), name, frag->oldpos);
2957                        if (!apply_with_reject)
2958                                return -1;
2959                        frag->rejected = 1;
2960                }
2961                frag = frag->next;
2962        }
2963        return 0;
2964}
2965
2966static int read_blob_object(struct strbuf *buf, const unsigned char *sha1, unsigned mode)
2967{
2968        if (S_ISGITLINK(mode)) {
2969                strbuf_grow(buf, 100);
2970                strbuf_addf(buf, "Subproject commit %s\n", sha1_to_hex(sha1));
2971        } else {
2972                enum object_type type;
2973                unsigned long sz;
2974                char *result;
2975
2976                result = read_sha1_file(sha1, &type, &sz);
2977                if (!result)
2978                        return -1;
2979                /* XXX read_sha1_file NUL-terminates */
2980                strbuf_attach(buf, result, sz, sz + 1);
2981        }
2982        return 0;
2983}
2984
2985static int read_file_or_gitlink(struct cache_entry *ce, struct strbuf *buf)
2986{
2987        if (!ce)
2988                return 0;
2989        return read_blob_object(buf, ce->sha1, ce->ce_mode);
2990}
2991
2992static struct patch *in_fn_table(const char *name)
2993{
2994        struct string_list_item *item;
2995
2996        if (name == NULL)
2997                return NULL;
2998
2999        item = string_list_lookup(&fn_table, name);
3000        if (item != NULL)
3001                return (struct patch *)item->util;
3002
3003        return NULL;
3004}
3005
3006/*
3007 * item->util in the filename table records the status of the path.
3008 * Usually it points at a patch (whose result records the contents
3009 * of it after applying it), but it could be PATH_WAS_DELETED for a
3010 * path that a previously applied patch has already removed, or
3011 * PATH_TO_BE_DELETED for a path that a later patch would remove.
3012 *
3013 * The latter is needed to deal with a case where two paths A and B
3014 * are swapped by first renaming A to B and then renaming B to A;
3015 * moving A to B should not be prevented due to presense of B as we
3016 * will remove it in a later patch.
3017 */
3018#define PATH_TO_BE_DELETED ((struct patch *) -2)
3019#define PATH_WAS_DELETED ((struct patch *) -1)
3020
3021static int to_be_deleted(struct patch *patch)
3022{
3023        return patch == PATH_TO_BE_DELETED;
3024}
3025
3026static int was_deleted(struct patch *patch)
3027{
3028        return patch == PATH_WAS_DELETED;
3029}
3030
3031static void add_to_fn_table(struct patch *patch)
3032{
3033        struct string_list_item *item;
3034
3035        /*
3036         * Always add new_name unless patch is a deletion
3037         * This should cover the cases for normal diffs,
3038         * file creations and copies
3039         */
3040        if (patch->new_name != NULL) {
3041                item = string_list_insert(&fn_table, patch->new_name);
3042                item->util = patch;
3043        }
3044
3045        /*
3046         * store a failure on rename/deletion cases because
3047         * later chunks shouldn't patch old names
3048         */
3049        if ((patch->new_name == NULL) || (patch->is_rename)) {
3050                item = string_list_insert(&fn_table, patch->old_name);
3051                item->util = PATH_WAS_DELETED;
3052        }
3053}
3054
3055static void prepare_fn_table(struct patch *patch)
3056{
3057        /*
3058         * store information about incoming file deletion
3059         */
3060        while (patch) {
3061                if ((patch->new_name == NULL) || (patch->is_rename)) {
3062                        struct string_list_item *item;
3063                        item = string_list_insert(&fn_table, patch->old_name);
3064                        item->util = PATH_TO_BE_DELETED;
3065                }
3066                patch = patch->next;
3067        }
3068}
3069
3070static int checkout_target(struct cache_entry *ce, struct stat *st)
3071{
3072        struct checkout costate;
3073
3074        memset(&costate, 0, sizeof(costate));
3075        costate.base_dir = "";
3076        costate.refresh_cache = 1;
3077        if (checkout_entry(ce, &costate, NULL) || lstat(ce->name, st))
3078                return error(_("cannot checkout %s"), ce->name);
3079        return 0;
3080}
3081
3082static struct patch *previous_patch(struct patch *patch, int *gone)
3083{
3084        struct patch *previous;
3085
3086        *gone = 0;
3087        if (patch->is_copy || patch->is_rename)
3088                return NULL; /* "git" patches do not depend on the order */
3089
3090        previous = in_fn_table(patch->old_name);
3091        if (!previous)
3092                return NULL;
3093
3094        if (to_be_deleted(previous))
3095                return NULL; /* the deletion hasn't happened yet */
3096
3097        if (was_deleted(previous))
3098                *gone = 1;
3099
3100        return previous;
3101}
3102
3103static int verify_index_match(struct cache_entry *ce, struct stat *st)
3104{
3105        if (S_ISGITLINK(ce->ce_mode)) {
3106                if (!S_ISDIR(st->st_mode))
3107                        return -1;
3108                return 0;
3109        }
3110        return ce_match_stat(ce, st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);
3111}
3112
3113#define SUBMODULE_PATCH_WITHOUT_INDEX 1
3114
3115static int load_patch_target(struct strbuf *buf,
3116                             struct cache_entry *ce,
3117                             struct stat *st,
3118                             const char *name,
3119                             unsigned expected_mode)
3120{
3121        if (cached) {
3122                if (read_file_or_gitlink(ce, buf))
3123                        return error(_("read of %s failed"), name);
3124        } else if (name) {
3125                if (S_ISGITLINK(expected_mode)) {
3126                        if (ce)
3127                                return read_file_or_gitlink(ce, buf);
3128                        else
3129                                return SUBMODULE_PATCH_WITHOUT_INDEX;
3130                } else {
3131                        if (read_old_data(st, name, buf))
3132                                return error(_("read of %s failed"), name);
3133                }
3134        }
3135        return 0;
3136}
3137
3138/*
3139 * We are about to apply "patch"; populate the "image" with the
3140 * current version we have, from the working tree or from the index,
3141 * depending on the situation e.g. --cached/--index.  If we are
3142 * applying a non-git patch that incrementally updates the tree,
3143 * we read from the result of a previous diff.
3144 */
3145static int load_preimage(struct image *image,
3146                         struct patch *patch, struct stat *st, struct cache_entry *ce)
3147{
3148        struct strbuf buf = STRBUF_INIT;
3149        size_t len;
3150        char *img;
3151        struct patch *previous;
3152        int status;
3153
3154        previous = previous_patch(patch, &status);
3155        if (status)
3156                return error(_("path %s has been renamed/deleted"),
3157                             patch->old_name);
3158        if (previous) {
3159                /* We have a patched copy in memory; use that. */
3160                strbuf_add(&buf, previous->result, previous->resultsize);
3161        } else {
3162                status = load_patch_target(&buf, ce, st,
3163                                           patch->old_name, patch->old_mode);
3164                if (status < 0)
3165                        return status;
3166                else if (status == SUBMODULE_PATCH_WITHOUT_INDEX) {
3167                        /*
3168                         * There is no way to apply subproject
3169                         * patch without looking at the index.
3170                         * NEEDSWORK: shouldn't this be flagged
3171                         * as an error???
3172                         */
3173                        free_fragment_list(patch->fragments);
3174                        patch->fragments = NULL;
3175                } else if (status) {
3176                        return error(_("read of %s failed"), patch->old_name);
3177                }
3178        }
3179
3180        img = strbuf_detach(&buf, &len);
3181        prepare_image(image, img, len, !patch->is_binary);
3182        return 0;
3183}
3184
3185static int three_way_merge(struct image *image,
3186                           char *path,
3187                           const unsigned char *base,
3188                           const unsigned char *ours,
3189                           const unsigned char *theirs)
3190{
3191        mmfile_t base_file, our_file, their_file;
3192        mmbuffer_t result = { NULL };
3193        int status;
3194
3195        read_mmblob(&base_file, base);
3196        read_mmblob(&our_file, ours);
3197        read_mmblob(&their_file, theirs);
3198        status = ll_merge(&result, path,
3199                          &base_file, "base",
3200                          &our_file, "ours",
3201                          &their_file, "theirs", NULL);
3202        free(base_file.ptr);
3203        free(our_file.ptr);
3204        free(their_file.ptr);
3205        if (status < 0 || !result.ptr) {
3206                free(result.ptr);
3207                return -1;
3208        }
3209        clear_image(image);
3210        image->buf = result.ptr;
3211        image->len = result.size;
3212
3213        return status;
3214}
3215
3216/*
3217 * When directly falling back to add/add three-way merge, we read from
3218 * the current contents of the new_name.  In no cases other than that
3219 * this function will be called.
3220 */
3221static int load_current(struct image *image, struct patch *patch)
3222{
3223        struct strbuf buf = STRBUF_INIT;
3224        int status, pos;
3225        size_t len;
3226        char *img;
3227        struct stat st;
3228        struct cache_entry *ce;
3229        char *name = patch->new_name;
3230        unsigned mode = patch->new_mode;
3231
3232        if (!patch->is_new)
3233                die("BUG: patch to %s is not a creation", patch->old_name);
3234
3235        pos = cache_name_pos(name, strlen(name));
3236        if (pos < 0)
3237                return error(_("%s: does not exist in index"), name);
3238        ce = active_cache[pos];
3239        if (lstat(name, &st)) {
3240                if (errno != ENOENT)
3241                        return error(_("%s: %s"), name, strerror(errno));
3242                if (checkout_target(ce, &st))
3243                        return -1;
3244        }
3245        if (verify_index_match(ce, &st))
3246                return error(_("%s: does not match index"), name);
3247
3248        status = load_patch_target(&buf, ce, &st, name, mode);
3249        if (status < 0)
3250                return status;
3251        else if (status)
3252                return -1;
3253        img = strbuf_detach(&buf, &len);
3254        prepare_image(image, img, len, !patch->is_binary);
3255        return 0;
3256}
3257
3258static int try_threeway(struct image *image, struct patch *patch,
3259                        struct stat *st, struct cache_entry *ce)
3260{
3261        unsigned char pre_sha1[20], post_sha1[20], our_sha1[20];
3262        struct strbuf buf = STRBUF_INIT;
3263        size_t len;
3264        int status;
3265        char *img;
3266        struct image tmp_image;
3267
3268        /* No point falling back to 3-way merge in these cases */
3269        if (patch->is_delete ||
3270            S_ISGITLINK(patch->old_mode) || S_ISGITLINK(patch->new_mode))
3271                return -1;
3272
3273        /* Preimage the patch was prepared for */
3274        if (patch->is_new)
3275                write_sha1_file("", 0, blob_type, pre_sha1);
3276        else if (get_sha1(patch->old_sha1_prefix, pre_sha1) ||
3277                 read_blob_object(&buf, pre_sha1, patch->old_mode))
3278                return error("repository lacks the necessary blob to fall back on 3-way merge.");
3279
3280        fprintf(stderr, "Falling back to three-way merge...\n");
3281
3282        img = strbuf_detach(&buf, &len);
3283        prepare_image(&tmp_image, img, len, 1);
3284        /* Apply the patch to get the post image */
3285        if (apply_fragments(&tmp_image, patch) < 0) {
3286                clear_image(&tmp_image);
3287                return -1;
3288        }
3289        /* post_sha1[] is theirs */
3290        write_sha1_file(tmp_image.buf, tmp_image.len, blob_type, post_sha1);
3291        clear_image(&tmp_image);
3292
3293        /* our_sha1[] is ours */
3294        if (patch->is_new) {
3295                if (load_current(&tmp_image, patch))
3296                        return error("cannot read the current contents of '%s'",
3297                                     patch->new_name);
3298        } else {
3299                if (load_preimage(&tmp_image, patch, st, ce))
3300                        return error("cannot read the current contents of '%s'",
3301                                     patch->old_name);
3302        }
3303        write_sha1_file(tmp_image.buf, tmp_image.len, blob_type, our_sha1);
3304        clear_image(&tmp_image);
3305
3306        /* in-core three-way merge between post and our using pre as base */
3307        status = three_way_merge(image, patch->new_name,
3308                                 pre_sha1, our_sha1, post_sha1);
3309        if (status < 0) {
3310                fprintf(stderr, "Failed to fall back on three-way merge...\n");
3311                return status;
3312        }
3313
3314        if (status) {
3315                patch->conflicted_threeway = 1;
3316                if (patch->is_new)
3317                        hashclr(patch->threeway_stage[0]);
3318                else
3319                        hashcpy(patch->threeway_stage[0], pre_sha1);
3320                hashcpy(patch->threeway_stage[1], our_sha1);
3321                hashcpy(patch->threeway_stage[2], post_sha1);
3322                fprintf(stderr, "Applied patch to '%s' with conflicts.\n", patch->new_name);
3323        } else {
3324                fprintf(stderr, "Applied patch to '%s' cleanly.\n", patch->new_name);
3325        }
3326        return 0;
3327}
3328
3329static int apply_data(struct patch *patch, struct stat *st, struct cache_entry *ce)
3330{
3331        struct image image;
3332
3333        if (load_preimage(&image, patch, st, ce) < 0)
3334                return -1;
3335
3336        if (patch->direct_to_threeway ||
3337            apply_fragments(&image, patch) < 0) {
3338                /* Note: with --reject, apply_fragments() returns 0 */
3339                if (!threeway || try_threeway(&image, patch, st, ce) < 0)
3340                        return -1;
3341        }
3342        patch->result = image.buf;
3343        patch->resultsize = image.len;
3344        add_to_fn_table(patch);
3345        free(image.line_allocated);
3346
3347        if (0 < patch->is_delete && patch->resultsize)
3348                return error(_("removal patch leaves file contents"));
3349
3350        return 0;
3351}
3352
3353/*
3354 * If "patch" that we are looking at modifies or deletes what we have,
3355 * we would want it not to lose any local modification we have, either
3356 * in the working tree or in the index.
3357 *
3358 * This also decides if a non-git patch is a creation patch or a
3359 * modification to an existing empty file.  We do not check the state
3360 * of the current tree for a creation patch in this function; the caller
3361 * check_patch() separately makes sure (and errors out otherwise) that
3362 * the path the patch creates does not exist in the current tree.
3363 */
3364static int check_preimage(struct patch *patch, struct cache_entry **ce, struct stat *st)
3365{
3366        const char *old_name = patch->old_name;
3367        struct patch *previous = NULL;
3368        int stat_ret = 0, status;
3369        unsigned st_mode = 0;
3370
3371        if (!old_name)
3372                return 0;
3373
3374        assert(patch->is_new <= 0);
3375        previous = previous_patch(patch, &status);
3376
3377        if (status)
3378                return error(_("path %s has been renamed/deleted"), old_name);
3379        if (previous) {
3380                st_mode = previous->new_mode;
3381        } else if (!cached) {
3382                stat_ret = lstat(old_name, st);
3383                if (stat_ret && errno != ENOENT)
3384                        return error(_("%s: %s"), old_name, strerror(errno));
3385        }
3386
3387        if (check_index && !previous) {
3388                int pos = cache_name_pos(old_name, strlen(old_name));
3389                if (pos < 0) {
3390                        if (patch->is_new < 0)
3391                                goto is_new;
3392                        return error(_("%s: does not exist in index"), old_name);
3393                }
3394                *ce = active_cache[pos];
3395                if (stat_ret < 0) {
3396                        if (checkout_target(*ce, st))
3397                                return -1;
3398                }
3399                if (!cached && verify_index_match(*ce, st))
3400                        return error(_("%s: does not match index"), old_name);
3401                if (cached)
3402                        st_mode = (*ce)->ce_mode;
3403        } else if (stat_ret < 0) {
3404                if (patch->is_new < 0)
3405                        goto is_new;
3406                return error(_("%s: %s"), old_name, strerror(errno));
3407        }
3408
3409        if (!cached && !previous)
3410                st_mode = ce_mode_from_stat(*ce, st->st_mode);
3411
3412        if (patch->is_new < 0)
3413                patch->is_new = 0;
3414        if (!patch->old_mode)
3415                patch->old_mode = st_mode;
3416        if ((st_mode ^ patch->old_mode) & S_IFMT)
3417                return error(_("%s: wrong type"), old_name);
3418        if (st_mode != patch->old_mode)
3419                warning(_("%s has type %o, expected %o"),
3420                        old_name, st_mode, patch->old_mode);
3421        if (!patch->new_mode && !patch->is_delete)
3422                patch->new_mode = st_mode;
3423        return 0;
3424
3425 is_new:
3426        patch->is_new = 1;
3427        patch->is_delete = 0;
3428        free(patch->old_name);
3429        patch->old_name = NULL;
3430        return 0;
3431}
3432
3433
3434#define EXISTS_IN_INDEX 1
3435#define EXISTS_IN_WORKTREE 2
3436
3437static int check_to_create(const char *new_name, int ok_if_exists)
3438{
3439        struct stat nst;
3440
3441        if (check_index &&
3442            cache_name_pos(new_name, strlen(new_name)) >= 0 &&
3443            !ok_if_exists)
3444                return EXISTS_IN_INDEX;
3445        if (cached)
3446                return 0;
3447
3448        if (!lstat(new_name, &nst)) {
3449                if (S_ISDIR(nst.st_mode) || ok_if_exists)
3450                        return 0;
3451                /*
3452                 * A leading component of new_name might be a symlink
3453                 * that is going to be removed with this patch, but
3454                 * still pointing at somewhere that has the path.
3455                 * In such a case, path "new_name" does not exist as
3456                 * far as git is concerned.
3457                 */
3458                if (has_symlink_leading_path(new_name, strlen(new_name)))
3459                        return 0;
3460
3461                return EXISTS_IN_WORKTREE;
3462        } else if ((errno != ENOENT) && (errno != ENOTDIR)) {
3463                return error("%s: %s", new_name, strerror(errno));
3464        }
3465        return 0;
3466}
3467
3468/*
3469 * Check and apply the patch in-core; leave the result in patch->result
3470 * for the caller to write it out to the final destination.
3471 */
3472static int check_patch(struct patch *patch)
3473{
3474        struct stat st;
3475        const char *old_name = patch->old_name;
3476        const char *new_name = patch->new_name;
3477        const char *name = old_name ? old_name : new_name;
3478        struct cache_entry *ce = NULL;
3479        struct patch *tpatch;
3480        int ok_if_exists;
3481        int status;
3482
3483        patch->rejected = 1; /* we will drop this after we succeed */
3484
3485        status = check_preimage(patch, &ce, &st);
3486        if (status)
3487                return status;
3488        old_name = patch->old_name;
3489
3490        /*
3491         * A type-change diff is always split into a patch to delete
3492         * old, immediately followed by a patch to create new (see
3493         * diff.c::run_diff()); in such a case it is Ok that the entry
3494         * to be deleted by the previous patch is still in the working
3495         * tree and in the index.
3496         *
3497         * A patch to swap-rename between A and B would first rename A
3498         * to B and then rename B to A.  While applying the first one,
3499         * the presense of B should not stop A from getting renamed to
3500         * B; ask to_be_deleted() about the later rename.  Removal of
3501         * B and rename from A to B is handled the same way by asking
3502         * was_deleted().
3503         */
3504        if ((tpatch = in_fn_table(new_name)) &&
3505            (was_deleted(tpatch) || to_be_deleted(tpatch)))
3506                ok_if_exists = 1;
3507        else
3508                ok_if_exists = 0;
3509
3510        if (new_name &&
3511            ((0 < patch->is_new) | (0 < patch->is_rename) | patch->is_copy)) {
3512                int err = check_to_create(new_name, ok_if_exists);
3513
3514                if (err && threeway) {
3515                        patch->direct_to_threeway = 1;
3516                } else switch (err) {
3517                case 0:
3518                        break; /* happy */
3519                case EXISTS_IN_INDEX:
3520                        return error(_("%s: already exists in index"), new_name);
3521                        break;
3522                case EXISTS_IN_WORKTREE:
3523                        return error(_("%s: already exists in working directory"),
3524                                     new_name);
3525                default:
3526                        return err;
3527                }
3528
3529                if (!patch->new_mode) {
3530                        if (0 < patch->is_new)
3531                                patch->new_mode = S_IFREG | 0644;
3532                        else
3533                                patch->new_mode = patch->old_mode;
3534                }
3535        }
3536
3537        if (new_name && old_name) {
3538                int same = !strcmp(old_name, new_name);
3539                if (!patch->new_mode)
3540                        patch->new_mode = patch->old_mode;
3541                if ((patch->old_mode ^ patch->new_mode) & S_IFMT) {
3542                        if (same)
3543                                return error(_("new mode (%o) of %s does not "
3544                                               "match old mode (%o)"),
3545                                        patch->new_mode, new_name,
3546                                        patch->old_mode);
3547                        else
3548                                return error(_("new mode (%o) of %s does not "
3549                                               "match old mode (%o) of %s"),
3550                                        patch->new_mode, new_name,
3551                                        patch->old_mode, old_name);
3552                }
3553        }
3554
3555        if (apply_data(patch, &st, ce) < 0)
3556                return error(_("%s: patch does not apply"), name);
3557        patch->rejected = 0;
3558        return 0;
3559}
3560
3561static int check_patch_list(struct patch *patch)
3562{
3563        int err = 0;
3564
3565        prepare_fn_table(patch);
3566        while (patch) {
3567                if (apply_verbosely)
3568                        say_patch_name(stderr,
3569                                       _("Checking patch %s..."), patch);
3570                err |= check_patch(patch);
3571                patch = patch->next;
3572        }
3573        return err;
3574}
3575
3576/* This function tries to read the sha1 from the current index */
3577static int get_current_sha1(const char *path, unsigned char *sha1)
3578{
3579        int pos;
3580
3581        if (read_cache() < 0)
3582                return -1;
3583        pos = cache_name_pos(path, strlen(path));
3584        if (pos < 0)
3585                return -1;
3586        hashcpy(sha1, active_cache[pos]->sha1);
3587        return 0;
3588}
3589
3590/* Build an index that contains the just the files needed for a 3way merge */
3591static void build_fake_ancestor(struct patch *list, const char *filename)
3592{
3593        struct patch *patch;
3594        struct index_state result = { NULL };
3595        int fd;
3596
3597        /* Once we start supporting the reverse patch, it may be
3598         * worth showing the new sha1 prefix, but until then...
3599         */
3600        for (patch = list; patch; patch = patch->next) {
3601                const unsigned char *sha1_ptr;
3602                unsigned char sha1[20];
3603                struct cache_entry *ce;
3604                const char *name;
3605
3606                name = patch->old_name ? patch->old_name : patch->new_name;
3607                if (0 < patch->is_new)
3608                        continue;
3609                else if (get_sha1_blob(patch->old_sha1_prefix, sha1))
3610                        /* git diff has no index line for mode/type changes */
3611                        if (!patch->lines_added && !patch->lines_deleted) {
3612                                if (get_current_sha1(patch->old_name, sha1))
3613                                        die("mode change for %s, which is not "
3614                                                "in current HEAD", name);
3615                                sha1_ptr = sha1;
3616                        } else
3617                                die("sha1 information is lacking or useless "
3618                                        "(%s).", name);
3619                else
3620                        sha1_ptr = sha1;
3621
3622                ce = make_cache_entry(patch->old_mode, sha1_ptr, name, 0, 0);
3623                if (!ce)
3624                        die(_("make_cache_entry failed for path '%s'"), name);
3625                if (add_index_entry(&result, ce, ADD_CACHE_OK_TO_ADD))
3626                        die ("Could not add %s to temporary index", name);
3627        }
3628
3629        fd = open(filename, O_WRONLY | O_CREAT, 0666);
3630        if (fd < 0 || write_index(&result, fd) || close(fd))
3631                die ("Could not write temporary index to %s", filename);
3632
3633        discard_index(&result);
3634}
3635
3636static void stat_patch_list(struct patch *patch)
3637{
3638        int files, adds, dels;
3639
3640        for (files = adds = dels = 0 ; patch ; patch = patch->next) {
3641                files++;
3642                adds += patch->lines_added;
3643                dels += patch->lines_deleted;
3644                show_stats(patch);
3645        }
3646
3647        print_stat_summary(stdout, files, adds, dels);
3648}
3649
3650static void numstat_patch_list(struct patch *patch)
3651{
3652        for ( ; patch; patch = patch->next) {
3653                const char *name;
3654                name = patch->new_name ? patch->new_name : patch->old_name;
3655                if (patch->is_binary)
3656                        printf("-\t-\t");
3657                else
3658                        printf("%d\t%d\t", patch->lines_added, patch->lines_deleted);
3659                write_name_quoted(name, stdout, line_termination);
3660        }
3661}
3662
3663static void show_file_mode_name(const char *newdelete, unsigned int mode, const char *name)
3664{
3665        if (mode)
3666                printf(" %s mode %06o %s\n", newdelete, mode, name);
3667        else
3668                printf(" %s %s\n", newdelete, name);
3669}
3670
3671static void show_mode_change(struct patch *p, int show_name)
3672{
3673        if (p->old_mode && p->new_mode && p->old_mode != p->new_mode) {
3674                if (show_name)
3675                        printf(" mode change %06o => %06o %s\n",
3676                               p->old_mode, p->new_mode, p->new_name);
3677                else
3678                        printf(" mode change %06o => %06o\n",
3679                               p->old_mode, p->new_mode);
3680        }
3681}
3682
3683static void show_rename_copy(struct patch *p)
3684{
3685        const char *renamecopy = p->is_rename ? "rename" : "copy";
3686        const char *old, *new;
3687
3688        /* Find common prefix */
3689        old = p->old_name;
3690        new = p->new_name;
3691        while (1) {
3692                const char *slash_old, *slash_new;
3693                slash_old = strchr(old, '/');
3694                slash_new = strchr(new, '/');
3695                if (!slash_old ||
3696                    !slash_new ||
3697                    slash_old - old != slash_new - new ||
3698                    memcmp(old, new, slash_new - new))
3699                        break;
3700                old = slash_old + 1;
3701                new = slash_new + 1;
3702        }
3703        /* p->old_name thru old is the common prefix, and old and new
3704         * through the end of names are renames
3705         */
3706        if (old != p->old_name)
3707                printf(" %s %.*s{%s => %s} (%d%%)\n", renamecopy,
3708                       (int)(old - p->old_name), p->old_name,
3709                       old, new, p->score);
3710        else
3711                printf(" %s %s => %s (%d%%)\n", renamecopy,
3712                       p->old_name, p->new_name, p->score);
3713        show_mode_change(p, 0);
3714}
3715
3716static void summary_patch_list(struct patch *patch)
3717{
3718        struct patch *p;
3719
3720        for (p = patch; p; p = p->next) {
3721                if (p->is_new)
3722                        show_file_mode_name("create", p->new_mode, p->new_name);
3723                else if (p->is_delete)
3724                        show_file_mode_name("delete", p->old_mode, p->old_name);
3725                else {
3726                        if (p->is_rename || p->is_copy)
3727                                show_rename_copy(p);
3728                        else {
3729                                if (p->score) {
3730                                        printf(" rewrite %s (%d%%)\n",
3731                                               p->new_name, p->score);
3732                                        show_mode_change(p, 0);
3733                                }
3734                                else
3735                                        show_mode_change(p, 1);
3736                        }
3737                }
3738        }
3739}
3740
3741static void patch_stats(struct patch *patch)
3742{
3743        int lines = patch->lines_added + patch->lines_deleted;
3744
3745        if (lines > max_change)
3746                max_change = lines;
3747        if (patch->old_name) {
3748                int len = quote_c_style(patch->old_name, NULL, NULL, 0);
3749                if (!len)
3750                        len = strlen(patch->old_name);
3751                if (len > max_len)
3752                        max_len = len;
3753        }
3754        if (patch->new_name) {
3755                int len = quote_c_style(patch->new_name, NULL, NULL, 0);
3756                if (!len)
3757                        len = strlen(patch->new_name);
3758                if (len > max_len)
3759                        max_len = len;
3760        }
3761}
3762
3763static void remove_file(struct patch *patch, int rmdir_empty)
3764{
3765        if (update_index) {
3766                if (remove_file_from_cache(patch->old_name) < 0)
3767                        die(_("unable to remove %s from index"), patch->old_name);
3768        }
3769        if (!cached) {
3770                if (!remove_or_warn(patch->old_mode, patch->old_name) && rmdir_empty) {
3771                        remove_path(patch->old_name);
3772                }
3773        }
3774}
3775
3776static void add_index_file(const char *path, unsigned mode, void *buf, unsigned long size)
3777{
3778        struct stat st;
3779        struct cache_entry *ce;
3780        int namelen = strlen(path);
3781        unsigned ce_size = cache_entry_size(namelen);
3782
3783        if (!update_index)
3784                return;
3785
3786        ce = xcalloc(1, ce_size);
3787        memcpy(ce->name, path, namelen);
3788        ce->ce_mode = create_ce_mode(mode);
3789        ce->ce_flags = create_ce_flags(0);
3790        ce->ce_namelen = namelen;
3791        if (S_ISGITLINK(mode)) {
3792                const char *s = buf;
3793
3794                if (get_sha1_hex(s + strlen("Subproject commit "), ce->sha1))
3795                        die(_("corrupt patch for subproject %s"), path);
3796        } else {
3797                if (!cached) {
3798                        if (lstat(path, &st) < 0)
3799                                die_errno(_("unable to stat newly created file '%s'"),
3800                                          path);
3801                        fill_stat_cache_info(ce, &st);
3802                }
3803                if (write_sha1_file(buf, size, blob_type, ce->sha1) < 0)
3804                        die(_("unable to create backing store for newly created file %s"), path);
3805        }
3806        if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
3807                die(_("unable to add cache entry for %s"), path);
3808}
3809
3810static int try_create_file(const char *path, unsigned int mode, const char *buf, unsigned long size)
3811{
3812        int fd;
3813        struct strbuf nbuf = STRBUF_INIT;
3814
3815        if (S_ISGITLINK(mode)) {
3816                struct stat st;
3817                if (!lstat(path, &st) && S_ISDIR(st.st_mode))
3818                        return 0;
3819                return mkdir(path, 0777);
3820        }
3821
3822        if (has_symlinks && S_ISLNK(mode))
3823                /* Although buf:size is counted string, it also is NUL
3824                 * terminated.
3825                 */
3826                return symlink(buf, path);
3827
3828        fd = open(path, O_CREAT | O_EXCL | O_WRONLY, (mode & 0100) ? 0777 : 0666);
3829        if (fd < 0)
3830                return -1;
3831
3832        if (convert_to_working_tree(path, buf, size, &nbuf)) {
3833                size = nbuf.len;
3834                buf  = nbuf.buf;
3835        }
3836        write_or_die(fd, buf, size);
3837        strbuf_release(&nbuf);
3838
3839        if (close(fd) < 0)
3840                die_errno(_("closing file '%s'"), path);
3841        return 0;
3842}
3843
3844/*
3845 * We optimistically assume that the directories exist,
3846 * which is true 99% of the time anyway. If they don't,
3847 * we create them and try again.
3848 */
3849static void create_one_file(char *path, unsigned mode, const char *buf, unsigned long size)
3850{
3851        if (cached)
3852                return;
3853        if (!try_create_file(path, mode, buf, size))
3854                return;
3855
3856        if (errno == ENOENT) {
3857                if (safe_create_leading_directories(path))
3858                        return;
3859                if (!try_create_file(path, mode, buf, size))
3860                        return;
3861        }
3862
3863        if (errno == EEXIST || errno == EACCES) {
3864                /* We may be trying to create a file where a directory
3865                 * used to be.
3866                 */
3867                struct stat st;
3868                if (!lstat(path, &st) && (!S_ISDIR(st.st_mode) || !rmdir(path)))
3869                        errno = EEXIST;
3870        }
3871
3872        if (errno == EEXIST) {
3873                unsigned int nr = getpid();
3874
3875                for (;;) {
3876                        char newpath[PATH_MAX];
3877                        mksnpath(newpath, sizeof(newpath), "%s~%u", path, nr);
3878                        if (!try_create_file(newpath, mode, buf, size)) {
3879                                if (!rename(newpath, path))
3880                                        return;
3881                                unlink_or_warn(newpath);
3882                                break;
3883                        }
3884                        if (errno != EEXIST)
3885                                break;
3886                        ++nr;
3887                }
3888        }
3889        die_errno(_("unable to write file '%s' mode %o"), path, mode);
3890}
3891
3892static void add_conflicted_stages_file(struct patch *patch)
3893{
3894        int stage, namelen;
3895        unsigned ce_size, mode;
3896        struct cache_entry *ce;
3897
3898        if (!update_index)
3899                return;
3900        namelen = strlen(patch->new_name);
3901        ce_size = cache_entry_size(namelen);
3902        mode = patch->new_mode ? patch->new_mode : (S_IFREG | 0644);
3903
3904        remove_file_from_cache(patch->new_name);
3905        for (stage = 1; stage < 4; stage++) {
3906                if (is_null_sha1(patch->threeway_stage[stage - 1]))
3907                        continue;
3908                ce = xcalloc(1, ce_size);
3909                memcpy(ce->name, patch->new_name, namelen);
3910                ce->ce_mode = create_ce_mode(mode);
3911                ce->ce_flags = create_ce_flags(stage);
3912                ce->ce_namelen = namelen;
3913                hashcpy(ce->sha1, patch->threeway_stage[stage - 1]);
3914                if (add_cache_entry(ce, ADD_CACHE_OK_TO_ADD) < 0)
3915                        die(_("unable to add cache entry for %s"), patch->new_name);
3916        }
3917}
3918
3919static void create_file(struct patch *patch)
3920{
3921        char *path = patch->new_name;
3922        unsigned mode = patch->new_mode;
3923        unsigned long size = patch->resultsize;
3924        char *buf = patch->result;
3925
3926        if (!mode)
3927                mode = S_IFREG | 0644;
3928        create_one_file(path, mode, buf, size);
3929
3930        if (patch->conflicted_threeway)
3931                add_conflicted_stages_file(patch);
3932        else
3933                add_index_file(path, mode, buf, size);
3934}
3935
3936/* phase zero is to remove, phase one is to create */
3937static void write_out_one_result(struct patch *patch, int phase)
3938{
3939        if (patch->is_delete > 0) {
3940                if (phase == 0)
3941                        remove_file(patch, 1);
3942                return;
3943        }
3944        if (patch->is_new > 0 || patch->is_copy) {
3945                if (phase == 1)
3946                        create_file(patch);
3947                return;
3948        }
3949        /*
3950         * Rename or modification boils down to the same
3951         * thing: remove the old, write the new
3952         */
3953        if (phase == 0)
3954                remove_file(patch, patch->is_rename);
3955        if (phase == 1)
3956                create_file(patch);
3957}
3958
3959static int write_out_one_reject(struct patch *patch)
3960{
3961        FILE *rej;
3962        char namebuf[PATH_MAX];
3963        struct fragment *frag;
3964        int cnt = 0;
3965        struct strbuf sb = STRBUF_INIT;
3966
3967        for (cnt = 0, frag = patch->fragments; frag; frag = frag->next) {
3968                if (!frag->rejected)
3969                        continue;
3970                cnt++;
3971        }
3972
3973        if (!cnt) {
3974                if (apply_verbosely)
3975                        say_patch_name(stderr,
3976                                       _("Applied patch %s cleanly."), patch);
3977                return 0;
3978        }
3979
3980        /* This should not happen, because a removal patch that leaves
3981         * contents are marked "rejected" at the patch level.
3982         */
3983        if (!patch->new_name)
3984                die(_("internal error"));
3985
3986        /* Say this even without --verbose */
3987        strbuf_addf(&sb, Q_("Applying patch %%s with %d reject...",
3988                            "Applying patch %%s with %d rejects...",
3989                            cnt),
3990                    cnt);
3991        say_patch_name(stderr, sb.buf, patch);
3992        strbuf_release(&sb);
3993
3994        cnt = strlen(patch->new_name);
3995        if (ARRAY_SIZE(namebuf) <= cnt + 5) {
3996                cnt = ARRAY_SIZE(namebuf) - 5;
3997                warning(_("truncating .rej filename to %.*s.rej"),
3998                        cnt - 1, patch->new_name);
3999        }
4000        memcpy(namebuf, patch->new_name, cnt);
4001        memcpy(namebuf + cnt, ".rej", 5);
4002
4003        rej = fopen(namebuf, "w");
4004        if (!rej)
4005                return error(_("cannot open %s: %s"), namebuf, strerror(errno));
4006
4007        /* Normal git tools never deal with .rej, so do not pretend
4008         * this is a git patch by saying --git nor give extended
4009         * headers.  While at it, maybe please "kompare" that wants
4010         * the trailing TAB and some garbage at the end of line ;-).
4011         */
4012        fprintf(rej, "diff a/%s b/%s\t(rejected hunks)\n",
4013                patch->new_name, patch->new_name);
4014        for (cnt = 1, frag = patch->fragments;
4015             frag;
4016             cnt++, frag = frag->next) {
4017                if (!frag->rejected) {
4018                        fprintf_ln(stderr, _("Hunk #%d applied cleanly."), cnt);
4019                        continue;
4020                }
4021                fprintf_ln(stderr, _("Rejected hunk #%d."), cnt);
4022                fprintf(rej, "%.*s", frag->size, frag->patch);
4023                if (frag->patch[frag->size-1] != '\n')
4024                        fputc('\n', rej);
4025        }
4026        fclose(rej);
4027        return -1;
4028}
4029
4030static int write_out_results(struct patch *list)
4031{
4032        int phase;
4033        int errs = 0;
4034        struct patch *l;
4035        struct string_list cpath = STRING_LIST_INIT_DUP;
4036
4037        for (phase = 0; phase < 2; phase++) {
4038                l = list;
4039                while (l) {
4040                        if (l->rejected)
4041                                errs = 1;
4042                        else {
4043                                write_out_one_result(l, phase);
4044                                if (phase == 1) {
4045                                        if (write_out_one_reject(l))
4046                                                errs = 1;
4047                                        if (l->conflicted_threeway) {
4048                                                string_list_append(&cpath, l->new_name);
4049                                                errs = 1;
4050                                        }
4051                                }
4052                        }
4053                        l = l->next;
4054                }
4055        }
4056
4057        if (cpath.nr) {
4058                struct string_list_item *item;
4059
4060                sort_string_list(&cpath);
4061                for_each_string_list_item(item, &cpath)
4062                        fprintf(stderr, "U %s\n", item->string);
4063                string_list_clear(&cpath, 0);
4064
4065                rerere(0);
4066        }
4067
4068        return errs;
4069}
4070
4071static struct lock_file lock_file;
4072
4073static struct string_list limit_by_name;
4074static int has_include;
4075static void add_name_limit(const char *name, int exclude)
4076{
4077        struct string_list_item *it;
4078
4079        it = string_list_append(&limit_by_name, name);
4080        it->util = exclude ? NULL : (void *) 1;
4081}
4082
4083static int use_patch(struct patch *p)
4084{
4085        const char *pathname = p->new_name ? p->new_name : p->old_name;
4086        int i;
4087
4088        /* Paths outside are not touched regardless of "--include" */
4089        if (0 < prefix_length) {
4090                int pathlen = strlen(pathname);
4091                if (pathlen <= prefix_length ||
4092                    memcmp(prefix, pathname, prefix_length))
4093                        return 0;
4094        }
4095
4096        /* See if it matches any of exclude/include rule */
4097        for (i = 0; i < limit_by_name.nr; i++) {
4098                struct string_list_item *it = &limit_by_name.items[i];
4099                if (!fnmatch(it->string, pathname, 0))
4100                        return (it->util != NULL);
4101        }
4102
4103        /*
4104         * If we had any include, a path that does not match any rule is
4105         * not used.  Otherwise, we saw bunch of exclude rules (or none)
4106         * and such a path is used.
4107         */
4108        return !has_include;
4109}
4110
4111
4112static void prefix_one(char **name)
4113{
4114        char *old_name = *name;
4115        if (!old_name)
4116                return;
4117        *name = xstrdup(prefix_filename(prefix, prefix_length, *name));
4118        free(old_name);
4119}
4120
4121static void prefix_patches(struct patch *p)
4122{
4123        if (!prefix || p->is_toplevel_relative)
4124                return;
4125        for ( ; p; p = p->next) {
4126                prefix_one(&p->new_name);
4127                prefix_one(&p->old_name);
4128        }
4129}
4130
4131#define INACCURATE_EOF  (1<<0)
4132#define RECOUNT         (1<<1)
4133
4134static int apply_patch(int fd, const char *filename, int options)
4135{
4136        size_t offset;
4137        struct strbuf buf = STRBUF_INIT; /* owns the patch text */
4138        struct patch *list = NULL, **listp = &list;
4139        int skipped_patch = 0;
4140
4141        patch_input_file = filename;
4142        read_patch_file(&buf, fd);
4143        offset = 0;
4144        while (offset < buf.len) {
4145                struct patch *patch;
4146                int nr;
4147
4148                patch = xcalloc(1, sizeof(*patch));
4149                patch->inaccurate_eof = !!(options & INACCURATE_EOF);
4150                patch->recount =  !!(options & RECOUNT);
4151                nr = parse_chunk(buf.buf + offset, buf.len - offset, patch);
4152                if (nr < 0)
4153                        break;
4154                if (apply_in_reverse)
4155                        reverse_patches(patch);
4156                if (prefix)
4157                        prefix_patches(patch);
4158                if (use_patch(patch)) {
4159                        patch_stats(patch);
4160                        *listp = patch;
4161                        listp = &patch->next;
4162                }
4163                else {
4164                        free_patch(patch);
4165                        skipped_patch++;
4166                }
4167                offset += nr;
4168        }
4169
4170        if (!list && !skipped_patch)
4171                die(_("unrecognized input"));
4172
4173        if (whitespace_error && (ws_error_action == die_on_ws_error))
4174                apply = 0;
4175
4176        update_index = check_index && apply;
4177        if (update_index && newfd < 0)
4178                newfd = hold_locked_index(&lock_file, 1);
4179
4180        if (check_index) {
4181                if (read_cache() < 0)
4182                        die(_("unable to read index file"));
4183        }
4184
4185        if ((check || apply) &&
4186            check_patch_list(list) < 0 &&
4187            !apply_with_reject)
4188                exit(1);
4189
4190        if (apply && write_out_results(list)) {
4191                if (apply_with_reject)
4192                        exit(1);
4193                /* with --3way, we still need to write the index out */
4194                return 1;
4195        }
4196
4197        if (fake_ancestor)
4198                build_fake_ancestor(list, fake_ancestor);
4199
4200        if (diffstat)
4201                stat_patch_list(list);
4202
4203        if (numstat)
4204                numstat_patch_list(list);
4205
4206        if (summary)
4207                summary_patch_list(list);
4208
4209        free_patch_list(list);
4210        strbuf_release(&buf);
4211        string_list_clear(&fn_table, 0);
4212        return 0;
4213}
4214
4215static int git_apply_config(const char *var, const char *value, void *cb)
4216{
4217        if (!strcmp(var, "apply.whitespace"))
4218                return git_config_string(&apply_default_whitespace, var, value);
4219        else if (!strcmp(var, "apply.ignorewhitespace"))
4220                return git_config_string(&apply_default_ignorewhitespace, var, value);
4221        return git_default_config(var, value, cb);
4222}
4223
4224static int option_parse_exclude(const struct option *opt,
4225                                const char *arg, int unset)
4226{
4227        add_name_limit(arg, 1);
4228        return 0;
4229}
4230
4231static int option_parse_include(const struct option *opt,
4232                                const char *arg, int unset)
4233{
4234        add_name_limit(arg, 0);
4235        has_include = 1;
4236        return 0;
4237}
4238
4239static int option_parse_p(const struct option *opt,
4240                          const char *arg, int unset)
4241{
4242        p_value = atoi(arg);
4243        p_value_known = 1;
4244        return 0;
4245}
4246
4247static int option_parse_z(const struct option *opt,
4248                          const char *arg, int unset)
4249{
4250        if (unset)
4251                line_termination = '\n';
4252        else
4253                line_termination = 0;
4254        return 0;
4255}
4256
4257static int option_parse_space_change(const struct option *opt,
4258                          const char *arg, int unset)
4259{
4260        if (unset)
4261                ws_ignore_action = ignore_ws_none;
4262        else
4263                ws_ignore_action = ignore_ws_change;
4264        return 0;
4265}
4266
4267static int option_parse_whitespace(const struct option *opt,
4268                                   const char *arg, int unset)
4269{
4270        const char **whitespace_option = opt->value;
4271
4272        *whitespace_option = arg;
4273        parse_whitespace_option(arg);
4274        return 0;
4275}
4276
4277static int option_parse_directory(const struct option *opt,
4278                                  const char *arg, int unset)
4279{
4280        root_len = strlen(arg);
4281        if (root_len && arg[root_len - 1] != '/') {
4282                char *new_root;
4283                root = new_root = xmalloc(root_len + 2);
4284                strcpy(new_root, arg);
4285                strcpy(new_root + root_len++, "/");
4286        } else
4287                root = arg;
4288        return 0;
4289}
4290
4291int cmd_apply(int argc, const char **argv, const char *prefix_)
4292{
4293        int i;
4294        int errs = 0;
4295        int is_not_gitdir = !startup_info->have_repository;
4296        int force_apply = 0;
4297
4298        const char *whitespace_option = NULL;
4299
4300        struct option builtin_apply_options[] = {
4301                { OPTION_CALLBACK, 0, "exclude", NULL, N_("path"),
4302                        N_("don't apply changes matching the given path"),
4303                        0, option_parse_exclude },
4304                { OPTION_CALLBACK, 0, "include", NULL, N_("path"),
4305                        N_("apply changes matching the given path"),
4306                        0, option_parse_include },
4307                { OPTION_CALLBACK, 'p', NULL, NULL, N_("num"),
4308                        N_("remove <num> leading slashes from traditional diff paths"),
4309                        0, option_parse_p },
4310                OPT_BOOLEAN(0, "no-add", &no_add,
4311                        N_("ignore additions made by the patch")),
4312                OPT_BOOLEAN(0, "stat", &diffstat,
4313                        N_("instead of applying the patch, output diffstat for the input")),
4314                OPT_NOOP_NOARG(0, "allow-binary-replacement"),
4315                OPT_NOOP_NOARG(0, "binary"),
4316                OPT_BOOLEAN(0, "numstat", &numstat,
4317                        N_("show number of added and deleted lines in decimal notation")),
4318                OPT_BOOLEAN(0, "summary", &summary,
4319                        N_("instead of applying the patch, output a summary for the input")),
4320                OPT_BOOLEAN(0, "check", &check,
4321                        N_("instead of applying the patch, see if the patch is applicable")),
4322                OPT_BOOLEAN(0, "index", &check_index,
4323                        N_("make sure the patch is applicable to the current index")),
4324                OPT_BOOLEAN(0, "cached", &cached,
4325                        N_("apply a patch without touching the working tree")),
4326                OPT_BOOLEAN(0, "apply", &force_apply,
4327                        N_("also apply the patch (use with --stat/--summary/--check)")),
4328                OPT_BOOL('3', "3way", &threeway,
4329                         N_( "attempt three-way merge if a patch does not apply")),
4330                OPT_FILENAME(0, "build-fake-ancestor", &fake_ancestor,
4331                        N_("build a temporary index based on embedded index information")),
4332                { OPTION_CALLBACK, 'z', NULL, NULL, NULL,
4333                        N_("paths are separated with NUL character"),
4334                        PARSE_OPT_NOARG, option_parse_z },
4335                OPT_INTEGER('C', NULL, &p_context,
4336                                N_("ensure at least <n> lines of context match")),
4337                { OPTION_CALLBACK, 0, "whitespace", &whitespace_option, N_("action"),
4338                        N_("detect new or modified lines that have whitespace errors"),
4339                        0, option_parse_whitespace },
4340                { OPTION_CALLBACK, 0, "ignore-space-change", NULL, NULL,
4341                        N_("ignore changes in whitespace when finding context"),
4342                        PARSE_OPT_NOARG, option_parse_space_change },
4343                { OPTION_CALLBACK, 0, "ignore-whitespace", NULL, NULL,
4344                        N_("ignore changes in whitespace when finding context"),
4345                        PARSE_OPT_NOARG, option_parse_space_change },
4346                OPT_BOOLEAN('R', "reverse", &apply_in_reverse,
4347                        N_("apply the patch in reverse")),
4348                OPT_BOOLEAN(0, "unidiff-zero", &unidiff_zero,
4349                        N_("don't expect at least one line of context")),
4350                OPT_BOOLEAN(0, "reject", &apply_with_reject,
4351                        N_("leave the rejected hunks in corresponding *.rej files")),
4352                OPT_BOOLEAN(0, "allow-overlap", &allow_overlap,
4353                        N_("allow overlapping hunks")),
4354                OPT__VERBOSE(&apply_verbosely, N_("be verbose")),
4355                OPT_BIT(0, "inaccurate-eof", &options,
4356                        N_("tolerate incorrectly detected missing new-line at the end of file"),
4357                        INACCURATE_EOF),
4358                OPT_BIT(0, "recount", &options,
4359                        N_("do not trust the line counts in the hunk headers"),
4360                        RECOUNT),
4361                { OPTION_CALLBACK, 0, "directory", NULL, N_("root"),
4362                        N_("prepend <root> to all filenames"),
4363                        0, option_parse_directory },
4364                OPT_END()
4365        };
4366
4367        prefix = prefix_;
4368        prefix_length = prefix ? strlen(prefix) : 0;
4369        git_config(git_apply_config, NULL);
4370        if (apply_default_whitespace)
4371                parse_whitespace_option(apply_default_whitespace);
4372        if (apply_default_ignorewhitespace)
4373                parse_ignorewhitespace_option(apply_default_ignorewhitespace);
4374
4375        argc = parse_options(argc, argv, prefix, builtin_apply_options,
4376                        apply_usage, 0);
4377
4378        if (apply_with_reject && threeway)
4379                die("--reject and --3way cannot be used together.");
4380        if (cached && threeway)
4381                die("--cached and --3way cannot be used together.");
4382        if (threeway) {
4383                if (is_not_gitdir)
4384                        die(_("--3way outside a repository"));
4385                check_index = 1;
4386        }
4387        if (apply_with_reject)
4388                apply = apply_verbosely = 1;
4389        if (!force_apply && (diffstat || numstat || summary || check || fake_ancestor))
4390                apply = 0;
4391        if (check_index && is_not_gitdir)
4392                die(_("--index outside a repository"));
4393        if (cached) {
4394                if (is_not_gitdir)
4395                        die(_("--cached outside a repository"));
4396                check_index = 1;
4397        }
4398        for (i = 0; i < argc; i++) {
4399                const char *arg = argv[i];
4400                int fd;
4401
4402                if (!strcmp(arg, "-")) {
4403                        errs |= apply_patch(0, "<stdin>", options);
4404                        read_stdin = 0;
4405                        continue;
4406                } else if (0 < prefix_length)
4407                        arg = prefix_filename(prefix, prefix_length, arg);
4408
4409                fd = open(arg, O_RDONLY);
4410                if (fd < 0)
4411                        die_errno(_("can't open patch '%s'"), arg);
4412                read_stdin = 0;
4413                set_default_whitespace_mode(whitespace_option);
4414                errs |= apply_patch(fd, arg, options);
4415                close(fd);
4416        }
4417        set_default_whitespace_mode(whitespace_option);
4418        if (read_stdin)
4419                errs |= apply_patch(0, "<stdin>", options);
4420        if (whitespace_error) {
4421                if (squelch_whitespace_errors &&
4422                    squelch_whitespace_errors < whitespace_error) {
4423                        int squelched =
4424                                whitespace_error - squelch_whitespace_errors;
4425                        warning(Q_("squelched %d whitespace error",
4426                                   "squelched %d whitespace errors",
4427                                   squelched),
4428                                squelched);
4429                }
4430                if (ws_error_action == die_on_ws_error)
4431                        die(Q_("%d line adds whitespace errors.",
4432                               "%d lines add whitespace errors.",
4433                               whitespace_error),
4434                            whitespace_error);
4435                if (applied_after_fixing_ws && apply)
4436                        warning("%d line%s applied after"
4437                                " fixing whitespace errors.",
4438                                applied_after_fixing_ws,
4439                                applied_after_fixing_ws == 1 ? "" : "s");
4440                else if (whitespace_error)
4441                        warning(Q_("%d line adds whitespace errors.",
4442                                   "%d lines add whitespace errors.",
4443                                   whitespace_error),
4444                                whitespace_error);
4445        }
4446
4447        if (update_index) {
4448                if (write_cache(newfd, active_cache, active_nr) ||
4449                    commit_locked_index(&lock_file))
4450                        die(_("Unable to write new index file"));
4451        }
4452
4453        return !!errs;
4454}