/*

* apply.c

*

* Copyright (C) Linus Torvalds, 2005

*

* This applies patches on top of some (arbitrary) version of the SCM.

*

*/

#include <fnmatch.h>

#include "cache.h"

#include "cache-tree.h"

#include "quote.h"

#include "blob.h"

#include "delta.h"

#include "builtin.h"

/*

* --check turns on checking that the working tree matches the

* files that are being modified, but doesn't apply the patch

* --stat does just a diffstat, and doesn't actually apply

* --numstat does numeric diffstat, and doesn't actually apply

* --index-info shows the old and new index info for paths if available.

* --index updates the cache as well.

* --cached updates only the cache without ever touching the working tree.

*/

static const char *prefix;

static int prefix_length = -1;

static int newfd = -1;

static int unidiff_zero;

static int p_value = 1;

static int check_index;

static int write_index;

static int cached;

static int diffstat;

static int numstat;

static int summary;

static int check;

static int apply = 1;

static int apply_in_reverse;

static int apply_with_reject;

static int apply_verbosely;

static int no_add;

static int show_index_info;

static int line_termination = '\n';

static unsigned long p_context = -1;

static const char apply_usage[] =

"git-apply [--stat] [--numstat] [--summary] [--check] [--index] [--cached] [--apply] [--no-add] [--index-info] [--allow-binary-replacement] [--reverse] [--reject] [--verbose] [-z] [-pNUM] [-CNUM] [--whitespace=<nowarn|warn|error|error-all|strip>] <patch>...";

static enum whitespace_eol {

} new_whitespace = warn_on_whitespace;

static int whitespace_error;

static int squelch_whitespace_errors = 5;

static int applied_after_stripping;

static const char *patch_input_file;

static void parse_whitespace_option(const char *option)

{

if (!option) {

new_whitespace = warn_on_whitespace;

return;

}

if (!strcmp(option, "warn")) {

new_whitespace = warn_on_whitespace;

return;

}

if (!strcmp(option, "nowarn")) {

new_whitespace = nowarn_whitespace;

return;

}

if (!strcmp(option, "error")) {

new_whitespace = error_on_whitespace;

return;

}

if (!strcmp(option, "error-all")) {

new_whitespace = error_on_whitespace;

squelch_whitespace_errors = 0;

return;

}

if (!strcmp(option, "strip")) {

new_whitespace = strip_whitespace;

return;

}

die("unrecognized whitespace option '%s'", option);

}

static void set_default_whitespace_mode(const char *whitespace_option)

{

if (!whitespace_option && !apply_default_whitespace) {

new_whitespace = (apply

? warn_on_whitespace

: nowarn_whitespace);

}

}

/*

* For "diff-stat" like behaviour, we keep track of the biggest change

* we've seen, and the longest filename. That allows us to do simple

* scaling.

*/

static int max_change, max_len;

/*

* Various "current state", notably line numbers and what

* file (and how) we're patching right now.. The "is_xxxx"

* things are flags, where -1 means "don't know yet".

*/

static int linenr = 1;

/*

* This represents one "hunk" from a patch, starting with

* "@@ -oldpos,oldlines +newpos,newlines @@" marker. The

* patch text is pointed at by patch, and its byte length

* is stored in size. leading and trailing are the number

* of context lines.

*/

struct fragment {

};

/*

* When dealing with a binary patch, we reuse "leading" field

* to store the type of the binary hunk, either deflated "delta"

* or deflated "literal".

*/

#define binary_patch_method leading

#define BINARY_DELTA_DEFLATED 1

#define BINARY_LITERAL_DEFLATED 2

struct patch {

};

static void say_patch_name(FILE *output, const char *pre, struct patch *patch, const char *post)

{

fputs(pre, output);

if (patch->old_name && patch->new_name &&

strcmp(patch->old_name, patch->new_name)) {

write_name_quoted(NULL, 0, patch->old_name, 1, output);

fputs(" => ", output);

write_name_quoted(NULL, 0, patch->new_name, 1, output);

}

else {

const char *n = patch->new_name;

if (!n)

n = patch->old_name;

write_name_quoted(NULL, 0, n, 1, output);

}

fputs(post, output);

}

#define CHUNKSIZE (8192)

#define SLOP (16)

static void *read_patch_file(int fd, unsigned long *sizep)

{

unsigned long size = 0, alloc = CHUNKSIZE;

void *buffer = xmalloc(alloc);

for (;;) {

int nr = alloc - size;

if (nr < 1024) {

alloc += CHUNKSIZE;

buffer = xrealloc(buffer, alloc);

nr = alloc - size;

}

nr = xread(fd, (char *) buffer + size, nr);

if (!nr)

break;

if (nr < 0)

die("git-apply: read returned %s", strerror(errno));

size += nr;

}

*sizep = size;

/*

* Make sure that we have some slop in the buffer

* so that we can do speculative "memcmp" etc, and

* see to it that it is NUL-filled.

*/

if (alloc < size + SLOP)

buffer = xrealloc(buffer, size + SLOP);

memset((char *) buffer + size, 0, SLOP);

return buffer;

}

static unsigned long linelen(const char *buffer, unsigned long size)

{

unsigned long len = 0;

while (size--) {

len++;

if (*buffer++ == '\n')

break;

}

return len;

}

static int is_dev_null(const char *str)

{

return !memcmp("/dev/null", str, 9) && isspace(str[9]);

}

#define TERM_SPACE 1

#define TERM_TAB 2

static int name_terminate(const char *name, int namelen, int c, int terminate)

{

if (c == ' ' && !(terminate & TERM_SPACE))

return 0;

if (c == '\t' && !(terminate & TERM_TAB))

return 0;

return 1;

}

static char * find_name(const char *line, char *def, int p_value, int terminate)

{

int len;

const char *start = line;

char *name;

if (*line == '"') {

/* Proposed "new-style" GNU patch/diff format; see

* http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2

*/

name = unquote_c_style(line, NULL);

if (name) {

char *cp = name;

while (p_value) {

cp = strchr(name, '/');

if (!cp)

break;

cp++;

p_value--;

}

if (cp) {

/* name can later be freed, so we need

* to memmove, not just return cp

*/

memmove(name, cp, strlen(cp) + 1);

free(def);

return name;

}

else {

free(name);

name = NULL;

}

}

}

for (;;) {

char c = *line;

if (isspace(c)) {

if (c == '\n')

break;

if (name_terminate(start, line-start, c, terminate))

break;

}

line++;

if (c == '/' && !--p_value)

start = line;

}

if (!start)

return def;

len = line - start;

if (!len)

return def;

/*

* Generally we prefer the shorter name, especially

* if the other one is just a variation of that with

* something else tacked on to the end (ie "file.orig"

* or "file~").

*/

if (def) {

int deflen = strlen(def);

if (deflen < len && !strncmp(start, def, deflen))

return def;

}

name = xmalloc(len + 1);

memcpy(name, start, len);

name[len] = 0;

free(def);

return name;

}

/*

* Get the name etc info from the --/+++ lines of a traditional patch header

*

* NOTE! This hardcodes "-p1" behaviour in filename detection.

*

* FIXME! The end-of-filename heuristics are kind of screwy. For existing

* files, we can happily check the index for a match, but for creating a

* new file we should try to match whatever "patch" does. I have no idea.

*/

static void parse_traditional_patch(const char *first, const char *second, struct patch *patch)

{

char *name;

first += 4; /* skip "--- " */

second += 4; /* skip "+++ " */

if (is_dev_null(first)) {

patch->is_new = 1;

patch->is_delete = 0;

name = find_name(second, NULL, p_value, TERM_SPACE | TERM_TAB);

patch->new_name = name;

} else if (is_dev_null(second)) {

patch->is_new = 0;

patch->is_delete = 1;

name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);

patch->old_name = name;

} else {

name = find_name(first, NULL, p_value, TERM_SPACE | TERM_TAB);

name = find_name(second, name, p_value, TERM_SPACE | TERM_TAB);

patch->old_name = patch->new_name = name;

}

if (!name)

die("unable to find filename in patch at line %d", linenr);

}

static int gitdiff_hdrend(const char *line, struct patch *patch)

{

return -1;

}

/*

* We're anal about diff header consistency, to make

* sure that we don't end up having strange ambiguous

* patches floating around.

*

* As a result, gitdiff_{old|new}name() will check

* their names against any previous information, just

* to make sure..

*/

static char *gitdiff_verify_name(const char *line, int isnull, char *orig_name, const char *oldnew)

{

if (!orig_name && !isnull)

return find_name(line, NULL, 1, 0);

if (orig_name) {

int len;

const char *name;

char *another;

name = orig_name;

len = strlen(name);

if (isnull)

die("git-apply: bad git-diff - expected /dev/null, got %s on line %d", name, linenr);

another = find_name(line, NULL, 1, 0);

if (!another || memcmp(another, name, len))

die("git-apply: bad git-diff - inconsistent %s filename on line %d", oldnew, linenr);

free(another);

return orig_name;

}

else {

/* expect "/dev/null" */

if (memcmp("/dev/null", line, 9) || line[9] != '\n')

die("git-apply: bad git-diff - expected /dev/null on line %d", linenr);

return NULL;

}

}

static int gitdiff_oldname(const char *line, struct patch *patch)

{

patch->old_name = gitdiff_verify_name(line, patch->is_new, patch->old_name, "old");

return 0;

}

static int gitdiff_newname(const char *line, struct patch *patch)

{

patch->new_name = gitdiff_verify_name(line, patch->is_delete, patch->new_name, "new");

return 0;

}

static int gitdiff_oldmode(const char *line, struct patch *patch)

{

patch->old_mode = strtoul(line, NULL, 8);

return 0;

}

static int gitdiff_newmode(const char *line, struct patch *patch)

{

patch->new_mode = strtoul(line, NULL, 8);

return 0;

}

static int gitdiff_delete(const char *line, struct patch *patch)

{

patch->is_delete = 1;

patch->old_name = patch->def_name;

return gitdiff_oldmode(line, patch);

}

static int gitdiff_newfile(const char *line, struct patch *patch)

{

patch->is_new = 1;

patch->new_name = patch->def_name;

return gitdiff_newmode(line, patch);

}

static int gitdiff_copysrc(const char *line, struct patch *patch)

{

patch->is_copy = 1;

patch->old_name = find_name(line, NULL, 0, 0);

return 0;

}

static int gitdiff_copydst(const char *line, struct patch *patch)

{

patch->is_copy = 1;

patch->new_name = find_name(line, NULL, 0, 0);

return 0;

}

static int gitdiff_renamesrc(const char *line, struct patch *patch)

{

patch->is_rename = 1;

patch->old_name = find_name(line, NULL, 0, 0);

return 0;

}

static int gitdiff_renamedst(const char *line, struct patch *patch)

{

patch->is_rename = 1;

patch->new_name = find_name(line, NULL, 0, 0);

return 0;

}

static int gitdiff_similarity(const char *line, struct patch *patch)

{

if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)

patch->score = 0;

return 0;

}

static int gitdiff_dissimilarity(const char *line, struct patch *patch)

{

if ((patch->score = strtoul(line, NULL, 10)) == ULONG_MAX)

patch->score = 0;

return 0;

}

static int gitdiff_index(const char *line, struct patch *patch)

{

/* index line is N hexadecimal, "..", N hexadecimal,

* and optional space with octal mode.

*/

const char *ptr, *eol;

int len;

ptr = strchr(line, '.');

if (!ptr || ptr[1] != '.' || 40 < ptr - line)

return 0;

len = ptr - line;

memcpy(patch->old_sha1_prefix, line, len);

patch->old_sha1_prefix[len] = 0;

line = ptr + 2;

ptr = strchr(line, ' ');

eol = strchr(line, '\n');

if (!ptr || eol < ptr)

ptr = eol;

len = ptr - line;

if (40 < len)

return 0;

memcpy(patch->new_sha1_prefix, line, len);

patch->new_sha1_prefix[len] = 0;

if (*ptr == ' ')

patch->new_mode = patch->old_mode = strtoul(ptr+1, NULL, 8);

return 0;

}

/*

* This is normal for a diff that doesn't change anything: we'll fall through

* into the next diff. Tell the parser to break out.

*/

static int gitdiff_unrecognized(const char *line, struct patch *patch)

{

return -1;

}

static const char *stop_at_slash(const char *line, int llen)

{

int i;

for (i = 0; i < llen; i++) {

int ch = line[i];

if (ch == '/')

return line + i;

}

return NULL;

}

/* This is to extract the same name that appears on "diff --git"

* line. We do not find and return anything if it is a rename

* patch, and it is OK because we will find the name elsewhere.

* We need to reliably find name only when it is mode-change only,

* creation or deletion of an empty file. In any of these cases,

* both sides are the same name under a/ and b/ respectively.

*/

static char *git_header_name(char *line, int llen)

{

int len;

const char *name;

const char *second = NULL;

line += strlen("diff --git ");

llen -= strlen("diff --git ");

if (*line == '"') {

const char *cp;

char *first = unquote_c_style(line, &second);

if (!first)

return NULL;

/* advance to the first slash */

cp = stop_at_slash(first, strlen(first));

if (!cp || cp == first) {

/* we do not accept absolute paths */

free_first_and_fail:

free(first);

return NULL;

}

len = strlen(cp+1);

memmove(first, cp+1, len+1); /* including NUL */

/* second points at one past closing dq of name.

* find the second name.

*/

while ((second < line + llen) && isspace(*second))

second++;

if (line + llen <= second)

goto free_first_and_fail;

if (*second == '"') {

char *sp = unquote_c_style(second, NULL);

if (!sp)

goto free_first_and_fail;

cp = stop_at_slash(sp, strlen(sp));

if (!cp || cp == sp) {

free_both_and_fail:

free(sp);

goto free_first_and_fail;

}

/* They must match, otherwise ignore */

if (strcmp(cp+1, first))

goto free_both_and_fail;

free(sp);

return first;

}

/* unquoted second */

cp = stop_at_slash(second, line + llen - second);

if (!cp || cp == second)

goto free_first_and_fail;

cp++;

if (line + llen - cp != len + 1 ||

memcmp(first, cp, len))

goto free_first_and_fail;

return first;

}

/* unquoted first name */

name = stop_at_slash(line, llen);

if (!name || name == line)

return NULL;

name++;

/* since the first name is unquoted, a dq if exists must be

* the beginning of the second name.

*/

for (second = name; second < line + llen; second++) {

if (*second == '"') {

const char *cp = second;

const char *np;

char *sp = unquote_c_style(second, NULL);

if (!sp)

return NULL;

np = stop_at_slash(sp, strlen(sp));

if (!np || np == sp) {

free_second_and_fail:

free(sp);

return NULL;

}

np++;

len = strlen(np);

if (len < cp - name &&

!strncmp(np, name, len) &&

isspace(name[len])) {

/* Good */

memmove(sp, np, len + 1);

return sp;

}

goto free_second_and_fail;

}

}

/*

* Accept a name only if it shows up twice, exactly the same

* form.

*/

for (len = 0 ; ; len++) {

switch (name[len]) {

default:

continue;

case '\n':

return NULL;

case '\t': case ' ':

second = name+len;

for (;;) {

char c = *second++;

if (c == '\n')

return NULL;

if (c == '/')

break;

}

if (second[len] == '\n' && !memcmp(name, second, len)) {

char *ret = xmalloc(len + 1);

memcpy(ret, name, len);

ret[len] = 0;

return ret;

}

}

}

return NULL;

}

/* Verify that we recognize the lines following a git header */

static int parse_git_header(char *line, int len, unsigned int size, struct patch *patch)

{

unsigned long offset;

/* A git diff has explicit new/delete information, so we don't guess */

patch->is_new = 0;

patch->is_delete = 0;

/*

* Some things may not have the old name in the

* rest of the headers anywhere (pure mode changes,

* or removing or adding empty files), so we get

* the default name from the header.

*/

patch->def_name = git_header_name(line, len);

line += len;

size -= len;

linenr++;

for (offset = len ; size > 0 ; offset += len, size -= len, line += len, linenr++) {

static const struct opentry {

const char *str;

int (*fn)(const char *, struct patch *);

} optable[] = {

{ "@@ -", gitdiff_hdrend },

{ "--- ", gitdiff_oldname },

{ "+++ ", gitdiff_newname },

{ "old mode ", gitdiff_oldmode },

{ "new mode ", gitdiff_newmode },

{ "deleted file mode ", gitdiff_delete },

{ "new file mode ", gitdiff_newfile },

{ "copy from ", gitdiff_copysrc },

{ "copy to ", gitdiff_copydst },

{ "rename old ", gitdiff_renamesrc },

{ "rename new ", gitdiff_renamedst },

{ "rename from ", gitdiff_renamesrc },

{ "rename to ", gitdiff_renamedst },

{ "similarity index ", gitdiff_similarity },

{ "dissimilarity index ", gitdiff_dissimilarity },

{ "index ", gitdiff_index },

{ "", gitdiff_unrecognized },

};

int i;

len = linelen(line, size);

if (!len || line[len-1] != '\n')

break;

for (i = 0; i < ARRAY_SIZE(optable); i++) {

const struct opentry *p = optable + i;

int oplen = strlen(p->str);

if (len < oplen || memcmp(p->str, line, oplen))

continue;

if (p->fn(line + oplen, patch) < 0)

return offset;

break;

}

}

return offset;

}

static int parse_num(const char *line, unsigned long *p)

{

char *ptr;

if (!isdigit(*line))

return 0;

*p = strtoul(line, &ptr, 10);

return ptr - line;

}

static int parse_range(const char *line, int len, int offset, const char *expect,

unsigned long *p1, unsigned long *p2)

{

int digits, ex;

if (offset < 0 || offset >= len)

return -1;

line += offset;

len -= offset;

digits = parse_num(line, p1);

if (!digits)

return -1;

offset += digits;

line += digits;

len -= digits;

*p2 = 1;

if (*line == ',') {

digits = parse_num(line+1, p2);

if (!digits)

return -1;

offset += digits+1;

line += digits+1;

len -= digits+1;

}

ex = strlen(expect);

if (ex > len)

return -1;

if (memcmp(line, expect, ex))

return -1;

return offset + ex;

}

/*

* Parse a unified diff fragment header of the

* form "@@ -a,b +c,d @@"

*/

static int parse_fragment_header(char *line, int len, struct fragment *fragment)

{

int offset;

if (!len || line[len-1] != '\n')

return -1;

/* Figure out the number of lines in a fragment */

offset = parse_range(line, len, 4, " +", &fragment->oldpos, &fragment->oldlines);

offset = parse_range(line, len, offset, " @@", &fragment->newpos, &fragment->newlines);

return offset;

}

static int find_header(char *line, unsigned long size, int *hdrsize, struct patch *patch)

{

unsigned long offset, len;

patch->is_rename = patch->is_copy = 0;

patch->is_new = patch->is_delete = -1;

patch->old_mode = patch->new_mode = 0;

patch->old_name = patch->new_name = NULL;

for (offset = 0; size > 0; offset += len, size -= len, line += len, linenr++) {

unsigned long nextlen;

len = linelen(line, size);

if (!len)

break;

/* Testing this early allows us to take a few shortcuts.. */

if (len < 6)

continue;

/*

* Make sure we don't find any unconnected patch fragments.

* That's a sign that we didn't find a header, and that a

* patch has become corrupted/broken up.

*/

if (!memcmp("@@ -", line, 4)) {

struct fragment dummy;

if (parse_fragment_header(line, len, &dummy) < 0)

continue;

error("patch fragment without header at line %d: %.*s", linenr, (int)len-1, line);

}

if (size < len + 6)

break;

/*

* Git patch? It might not have a real patch, just a rename

* or mode change, so we handle that specially

*/

if (!memcmp("diff --git ", line, 11)) {

int git_hdr_len = parse_git_header(line, len, size, patch);

if (git_hdr_len <= len)

continue;

if (!patch->old_name && !patch->new_name) {

if (!patch->def_name)

die("git diff header lacks filename information (line %d)", linenr);

patch->old_name = patch->new_name = patch->def_name;

}

*hdrsize = git_hdr_len;

return offset;

}

/** --- followed by +++ ? */

if (memcmp("--- ", line, 4) || memcmp("+++ ", line + len, 4))

continue;

/*

* We only accept unified patches, so we want it to

* at least have "@@ -a,b +c,d @@\n", which is 14 chars

* minimum

*/

nextlen = linelen(line + len, size - len);

if (size < nextlen + 14 || memcmp("@@ -", line + len + nextlen, 4))

continue;

/* Ok, we'll consider it a patch */

parse_traditional_patch(line, line+len, patch);

*hdrsize = len + nextlen;

linenr += 2;

return offset;

}

return -1;

}

/*

* Parse a unified diff. Note that this really needs to parse each

* fragment separately, since the only way to know the difference

* between a "---" that is part of a patch, and a "---" that starts

* the next patch is to look at the line counts..

*/

static int parse_fragment(char *line, unsigned long size, struct patch *patch, struct fragment *fragment)

{

int added, deleted;

int len = linelen(line, size), offset;

unsigned long oldlines, newlines;

unsigned long leading, trailing;

offset = parse_fragment_header(line, len, fragment);

if (offset < 0)

return -1;

oldlines = fragment->oldlines;

newlines = fragment->newlines;

leading = 0;

trailing = 0;

/* Parse the thing.. */

line += len;

size -= len;

linenr++;

added = deleted = 0;

for (offset = len;

0 < size;

offset += len, size -= len, line += len, linenr++) {

if (!oldlines && !newlines)

break;

len = linelen(line, size);

if (!len || line[len-1] != '\n')

return -1;

switch (*line) {

default:

return -1;

case ' ':

oldlines--;

newlines--;

if (!deleted && !added)

leading++;

trailing++;

break;

case '-':

deleted++;

oldlines--;

trailing = 0;

break;

case '+':

/*

* We know len is at least two, since we have a '+' and

* we checked that the last character was a '\n' above.

* That is, an addition of an empty line would check

* the '+' here. Sneaky...

*/

if ((new_whitespace != nowarn_whitespace) &&

isspace(line[len-2])) {

whitespace_error++;

if (squelch_whitespace_errors &&

squelch_whitespace_errors <

whitespace_error)

;

else {

fprintf(stderr, "Adds trailing whitespace.\n%s:%d:%.*s\n",

patch_input_file,

linenr, len-2, line+1);

}

}

added++;

newlines--;

trailing = 0;

break;

/* We allow "\ No newline at end of file". Depending

* on locale settings when the patch was produced we

* don't know what this line looks like. The only

* thing we do know is that it begins with "\ ".

* Checking for 12 is just for sanity check -- any

* l10n of "\ No newline..." is at least that long.

*/

case '\\':

if (len < 12 || memcmp(line, "\\ ", 2))

return -1;

break;

}

}

if (oldlines || newlines)

return -1;

fragment->leading = leading;

fragment->trailing = trailing;

/* If a fragment ends with an incomplete line, we failed to include

* it in the above loop because we hit oldlines == newlines == 0

* before seeing it.

*/

if (12 < size && !memcmp(line, "\\ ", 2))

offset += linelen(line, size);

patch->lines_added += added;

patch->lines_deleted += deleted;

if (0 < patch->is_new && oldlines)

return error("new file depends on old contents");

if (0 < patch->is_delete && newlines)

return error("deleted file still has contents");

return offset;

}

static int parse_single_patch(char *line, unsigned long size, struct patch *patch)

{

unsigned long offset = 0;

unsigned long oldlines = 0, newlines = 0, context = 0;

struct fragment **fragp = &patch->fragments;

while (size > 4 && !memcmp(line, "@@ -", 4)) {

struct fragment *fragment;

int len;

fragment = xcalloc(1, sizeof(*fragment));

len = parse_fragment(line, size, patch, fragment);

if (len <= 0)

die("corrupt patch at line %d", linenr);

fragment->patch = line;

fragment->size = len;

oldlines += fragment->oldlines;

newlines += fragment->newlines;

context += fragment->leading + fragment->trailing;

*fragp = fragment;

fragp = &fragment->next;

offset += len;

line += len;

size -= len;

}

/*

* If something was removed (i.e. we have old-lines) it cannot

* be creation, and if something was added it cannot be

* deletion. However, the reverse is not true; --unified=0

* patches that only add are not necessarily creation even

* though they do not have any old lines, and ones that only

* delete are not necessarily deletion.