src/apply.c - third_party/libgit2 - Git at Google

 /*
  * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */

 #include <assert.h>

 #include "git2/patch.h"
 #include "git2/filter.h"
 #include "array.h"
 #include "patch.h"
 #include "fileops.h"
 #include "apply.h"
 #include "delta.h"
 #include "zstream.h"

 #define apply_err(...) \
 	( giterr_set(GITERR_PATCH, __VA_ARGS__), -1 )

 typedef struct {
 	/* The lines that we allocate ourself are allocated out of the pool.
 	 * (Lines may have been allocated out of the diff.)
 	 */
 	git_pool pool;
 	git_vector lines;
 } patch_image;

 static void patch_line_init(
 	git_diff_line *out,
 	const char *in,
 	size_t in_len,
 	size_t in_offset)
 {
 	out->content = in;
 	out->content_len = in_len;
 	out->content_offset = in_offset;
 }

 #define PATCH_IMAGE_INIT { GIT_POOL_INIT, GIT_VECTOR_INIT }

 static int patch_image_init_fromstr(
 	patch_image *out, const char *in, size_t in_len)
 {
 	git_diff_line *line;
 	const char *start, *end;

 	memset(out, 0x0, sizeof(patch_image));

 	git_pool_init(&out->pool, sizeof(git_diff_line));

 	for (start = in; start < in + in_len; start = end) {
 		end = memchr(start, '\n', in_len);

 		if (end == NULL)
 			end = in + in_len;

 		else if (end < in + in_len)
 			end++;

 		line = git_pool_mallocz(&out->pool, 1);
 		GITERR_CHECK_ALLOC(line);

 		if (git_vector_insert(&out->lines, line) < 0)
 			return -1;

 		patch_line_init(line, start, (end - start), (start - in));
 	}

 	return 0;
 }

 static void patch_image_free(patch_image *image)
 {
 	if (image == NULL)
 		return;

 	git_pool_clear(&image->pool);
 	git_vector_free(&image->lines);
 }

 static bool match_hunk(
 	patch_image *image,
 	patch_image *preimage,
 	size_t linenum)
 {
 	bool match = 0;
 	size_t i;

 	/* Ensure this hunk is within the image boundaries. */
 	if (git_vector_length(&preimage->lines) + linenum >
 		git_vector_length(&image->lines))
 		return 0;

 	match = 1;

 	/* Check exact match. */
 	for (i = 0; i < git_vector_length(&preimage->lines); i++) {
 		git_diff_line *preimage_line = git_vector_get(&preimage->lines, i);
 		git_diff_line *image_line = git_vector_get(&image->lines, linenum + i);

 		if (preimage_line->content_len != image_line->content_len ||
 			memcmp(preimage_line->content, image_line->content, image_line->content_len) != 0) {
 			match = 0;
 			break;
 		}
 	}

 	return match;
 }

 static bool find_hunk_linenum(
 	size_t *out,
 	patch_image *image,
 	patch_image *preimage,
 	size_t linenum)
 {
 	size_t max = git_vector_length(&image->lines);
 	bool match;

 	if (linenum > max)
 		linenum = max;

 	match = match_hunk(image, preimage, linenum);

 	*out = linenum;
 	return match;
 }

 static int update_hunk(
 	patch_image *image,
 	unsigned int linenum,
 	patch_image *preimage,
 	patch_image *postimage)
 {
 	size_t postlen = git_vector_length(&postimage->lines);
 	size_t prelen = git_vector_length(&preimage->lines);
 	size_t i;
 	int error = 0;

 	if (postlen > prelen)
 		error = git_vector_insert_null(
 			&image->lines, linenum, (postlen - prelen));
 	else if (prelen > postlen)
 		error = git_vector_remove_range(
 			&image->lines, linenum, (prelen - postlen));

 	if (error) {
 		giterr_set_oom();
 		return -1;
 	}

 	for (i = 0; i < git_vector_length(&postimage->lines); i++) {
 		image->lines.contents[linenum + i] =
 			git_vector_get(&postimage->lines, i);
 	}

 	return 0;
 }

 static int apply_hunk(
 	patch_image *image,
 	git_patch *patch,
 	git_patch_hunk *hunk)
 {
 	patch_image preimage = PATCH_IMAGE_INIT, postimage = PATCH_IMAGE_INIT;
 	size_t line_num, i;
 	int error = 0;

 	for (i = 0; i < hunk->line_count; i++) {
 		size_t linenum = hunk->line_start + i;
 		git_diff_line *line = git_array_get(patch->lines, linenum);

 		if (!line) {
 			error = apply_err("preimage does not contain line %"PRIuZ, linenum);
 			goto done;
 		}

 		if (line->origin == GIT_DIFF_LINE_CONTEXT ||
 			line->origin == GIT_DIFF_LINE_DELETION) {
 			if ((error = git_vector_insert(&preimage.lines, line)) < 0)
 				goto done;
 		}

 		if (line->origin == GIT_DIFF_LINE_CONTEXT ||
 			line->origin == GIT_DIFF_LINE_ADDITION) {
 			if ((error = git_vector_insert(&postimage.lines, line)) < 0)
 				goto done;
 		}
 	}

 	line_num = hunk->hunk.new_start ? hunk->hunk.new_start - 1 : 0;

 	if (!find_hunk_linenum(&line_num, image, &preimage, line_num)) {
 		error = apply_err("hunk at line %d did not apply",
 			hunk->hunk.new_start);
 		goto done;
 	}

 	error = update_hunk(image, line_num, &preimage, &postimage);

 done:
 	patch_image_free(&preimage);
 	patch_image_free(&postimage);

 	return error;
 }

 static int apply_hunks(
 	git_buf *out,
 	const char *source,
 	size_t source_len,
 	git_patch *patch)
 {
 	git_patch_hunk *hunk;
 	git_diff_line *line;
 	patch_image image;
 	size_t i;
 	int error = 0;

 	if ((error = patch_image_init_fromstr(&image, source, source_len)) < 0)
 		goto done;

 	git_array_foreach(patch->hunks, i, hunk) {
 		if ((error = apply_hunk(&image, patch, hunk)) < 0)
 			goto done;
 	}

 	git_vector_foreach(&image.lines, i, line)
 		git_buf_put(out, line->content, line->content_len);

 done:
 	patch_image_free(&image);

 	return error;
 }

 static int apply_binary_delta(
 	git_buf *out,
 	const char *source,
 	size_t source_len,
 	git_diff_binary_file *binary_file)
 {
 	git_buf inflated = GIT_BUF_INIT;
 	int error = 0;

 	/* no diff means identical contents */
 	if (binary_file->datalen == 0)
 		return git_buf_put(out, source, source_len);

 	error = git_zstream_inflatebuf(&inflated,
 		binary_file->data, binary_file->datalen);

 	if (!error && inflated.size != binary_file->inflatedlen) {
 		error = apply_err("inflated delta does not match expected length");
 		git_buf_free(out);
 	}

 	if (error < 0)
 		goto done;

 	if (binary_file->type == GIT_DIFF_BINARY_DELTA) {
 		void *data;
 		size_t data_len;

 		error = git_delta_apply(&data, &data_len, (void *)source, source_len,
 			(void *)inflated.ptr, inflated.size);

 		out->ptr = data;
 		out->size = data_len;
 		out->asize = data_len;
 	}
 	else if (binary_file->type == GIT_DIFF_BINARY_LITERAL) {
 		git_buf_swap(out, &inflated);
 	}
 	else {
 		error = apply_err("unknown binary delta type");
 		goto done;
 	}

 done:
 	git_buf_free(&inflated);
 	return error;
 }

 static int apply_binary(
 	git_buf *out,
 	const char *source,
 	size_t source_len,
 	git_patch *patch)
 {
 	git_buf reverse = GIT_BUF_INIT;
 	int error = 0;

 	if (!patch->binary.contains_data) {
 		error = apply_err("patch does not contain binary data");
 		goto done;
 	}

 	if (!patch->binary.old_file.datalen && !patch->binary.new_file.datalen)
 		goto done;

 	/* first, apply the new_file delta to the given source */
 	if ((error = apply_binary_delta(out, source, source_len,
 			&patch->binary.new_file)) < 0)
 		goto done;

 	/* second, apply the old_file delta to sanity check the result */
 	if ((error = apply_binary_delta(&reverse, out->ptr, out->size,
 			&patch->binary.old_file)) < 0)
 		goto done;

 	if (source_len != reverse.size ||
 		memcmp(source, reverse.ptr, source_len) != 0) {
 		error = apply_err("binary patch did not apply cleanly");
 		goto done;
 	}

 done:
 	if (error < 0)
 		git_buf_free(out);

 	git_buf_free(&reverse);
 	return error;
 }

 int git_apply__patch(
 	git_buf *contents_out,
 	char **filename_out,
 	unsigned int *mode_out,
 	const char *source,
 	size_t source_len,
 	git_patch *patch)
 {
 	char *filename = NULL;
 	unsigned int mode = 0;
 	int error = 0;

 	assert(contents_out && filename_out && mode_out && (source || !source_len) && patch);

 	*filename_out = NULL;
 	*mode_out = 0;

 	if (patch->delta->status != GIT_DELTA_DELETED) {
 		const git_diff_file *newfile = &patch->delta->new_file;

 		filename = git__strdup(newfile->path);
 		mode = newfile->mode ?
 			newfile->mode : GIT_FILEMODE_BLOB;
 	}

 	if (patch->delta->flags & GIT_DIFF_FLAG_BINARY)
 		error = apply_binary(contents_out, source, source_len, patch);
 	else if (patch->hunks.size)
 		error = apply_hunks(contents_out, source, source_len, patch);
 	else
 		error = git_buf_put(contents_out, source, source_len);

 	if (error)
 		goto done;

 	if (patch->delta->status == GIT_DELTA_DELETED &&
 		git_buf_len(contents_out) > 0) {
 		error = apply_err("removal patch leaves file contents");
 		goto done;
 	}

 	*filename_out = filename;
 	*mode_out = mode;

 done:
 	if (error < 0)
 		git__free(filename);

 	return error;
 }
	/*
	* Copyright (C) the libgit2 contributors. All rights reserved.
	*
	* This file is part of libgit2, distributed under the GNU GPL v2 with
	* a Linking Exception. For full terms see the included COPYING file.
	*/

	#include <assert.h>

	#include "git2/patch.h"
	#include "git2/filter.h"
	#include "array.h"
	#include "patch.h"
	#include "fileops.h"
	#include "apply.h"
	#include "delta.h"
	#include "zstream.h"

	#define apply_err(...) \
	( giterr_set(GITERR_PATCH, __VA_ARGS__), -1 )

	typedef struct {
	/* The lines that we allocate ourself are allocated out of the pool.
	* (Lines may have been allocated out of the diff.)
	*/
	git_pool pool;
	git_vector lines;
	} patch_image;

	static void patch_line_init(
	git_diff_line *out,
	const char *in,
	size_t in_len,
	size_t in_offset)
	{
	out->content = in;
	out->content_len = in_len;
	out->content_offset = in_offset;
	}

	#define PATCH_IMAGE_INIT { GIT_POOL_INIT, GIT_VECTOR_INIT }

	static int patch_image_init_fromstr(
	patch_image out, const char in, size_t in_len)
	{
	git_diff_line *line;
	const char start, end;

	memset(out, 0x0, sizeof(patch_image));

	git_pool_init(&out->pool, sizeof(git_diff_line));

	for (start = in; start < in + in_len; start = end) {
	end = memchr(start, '\n', in_len);

	if (end == NULL)
	end = in + in_len;

	else if (end < in + in_len)
	end++;

	line = git_pool_mallocz(&out->pool, 1);
	GITERR_CHECK_ALLOC(line);

	if (git_vector_insert(&out->lines, line) < 0)
	return -1;

	patch_line_init(line, start, (end - start), (start - in));
	}

	return 0;
	}

	static void patch_image_free(patch_image *image)
	{
	if (image == NULL)
	return;

	git_pool_clear(&image->pool);
	git_vector_free(&image->lines);
	}

	static bool match_hunk(
	patch_image *image,
	patch_image *preimage,
	size_t linenum)
	{
	bool match = 0;
	size_t i;

	/* Ensure this hunk is within the image boundaries. */
	if (git_vector_length(&preimage->lines) + linenum >
	git_vector_length(&image->lines))
	return 0;

	match = 1;

	/* Check exact match. */
	for (i = 0; i < git_vector_length(&preimage->lines); i++) {
	git_diff_line *preimage_line = git_vector_get(&preimage->lines, i);
	git_diff_line *image_line = git_vector_get(&image->lines, linenum + i);

	if (preimage_line->content_len != image_line->content_len \|\|
	memcmp(preimage_line->content, image_line->content, image_line->content_len) != 0) {
	match = 0;
	break;
	}
	}

	return match;
	}

	static bool find_hunk_linenum(
	size_t *out,
	patch_image *image,
	patch_image *preimage,
	size_t linenum)
	{
	size_t max = git_vector_length(&image->lines);
	bool match;

	if (linenum > max)
	linenum = max;

	match = match_hunk(image, preimage, linenum);

	*out = linenum;
	return match;
	}

	static int update_hunk(
	patch_image *image,
	unsigned int linenum,
	patch_image *preimage,
	patch_image *postimage)
	{
	size_t postlen = git_vector_length(&postimage->lines);
	size_t prelen = git_vector_length(&preimage->lines);
	size_t i;
	int error = 0;

	if (postlen > prelen)
	error = git_vector_insert_null(
	&image->lines, linenum, (postlen - prelen));
	else if (prelen > postlen)
	error = git_vector_remove_range(
	&image->lines, linenum, (prelen - postlen));

	if (error) {
	giterr_set_oom();
	return -1;
	}

	for (i = 0; i < git_vector_length(&postimage->lines); i++) {
	image->lines.contents[linenum + i] =
	git_vector_get(&postimage->lines, i);
	}

	return 0;
	}

	static int apply_hunk(
	patch_image *image,
	git_patch *patch,
	git_patch_hunk *hunk)
	{
	patch_image preimage = PATCH_IMAGE_INIT, postimage = PATCH_IMAGE_INIT;
	size_t line_num, i;
	int error = 0;

	for (i = 0; i < hunk->line_count; i++) {
	size_t linenum = hunk->line_start + i;
	git_diff_line *line = git_array_get(patch->lines, linenum);

	if (!line) {
	error = apply_err("preimage does not contain line %"PRIuZ, linenum);
	goto done;
	}

	if (line->origin == GIT_DIFF_LINE_CONTEXT \|\|
	line->origin == GIT_DIFF_LINE_DELETION) {
	if ((error = git_vector_insert(&preimage.lines, line)) < 0)
	goto done;
	}

	if (line->origin == GIT_DIFF_LINE_CONTEXT \|\|
	line->origin == GIT_DIFF_LINE_ADDITION) {
	if ((error = git_vector_insert(&postimage.lines, line)) < 0)
	goto done;
	}
	}

	line_num = hunk->hunk.new_start ? hunk->hunk.new_start - 1 : 0;

	if (!find_hunk_linenum(&line_num, image, &preimage, line_num)) {
	error = apply_err("hunk at line %d did not apply",
	hunk->hunk.new_start);
	goto done;
	}

	error = update_hunk(image, line_num, &preimage, &postimage);

	done:
	patch_image_free(&preimage);
	patch_image_free(&postimage);

	return error;
	}

	static int apply_hunks(
	git_buf *out,
	const char *source,
	size_t source_len,
	git_patch *patch)
	{
	git_patch_hunk *hunk;
	git_diff_line *line;
	patch_image image;
	size_t i;
	int error = 0;

	if ((error = patch_image_init_fromstr(&image, source, source_len)) < 0)
	goto done;

	git_array_foreach(patch->hunks, i, hunk) {
	if ((error = apply_hunk(&image, patch, hunk)) < 0)
	goto done;
	}

	git_vector_foreach(&image.lines, i, line)
	git_buf_put(out, line->content, line->content_len);

	done:
	patch_image_free(&image);

	return error;
	}

	static int apply_binary_delta(
	git_buf *out,
	const char *source,
	size_t source_len,
	git_diff_binary_file *binary_file)
	{
	git_buf inflated = GIT_BUF_INIT;
	int error = 0;

	/* no diff means identical contents */
	if (binary_file->datalen == 0)
	return git_buf_put(out, source, source_len);

	error = git_zstream_inflatebuf(&inflated,
	binary_file->data, binary_file->datalen);

	if (!error && inflated.size != binary_file->inflatedlen) {
	error = apply_err("inflated delta does not match expected length");
	git_buf_free(out);
	}

	if (error < 0)
	goto done;

	if (binary_file->type == GIT_DIFF_BINARY_DELTA) {
	void *data;
	size_t data_len;

	error = git_delta_apply(&data, &data_len, (void *)source, source_len,
	(void *)inflated.ptr, inflated.size);

	out->ptr = data;
	out->size = data_len;
	out->asize = data_len;
	}
	else if (binary_file->type == GIT_DIFF_BINARY_LITERAL) {
	git_buf_swap(out, &inflated);
	}
	else {
	error = apply_err("unknown binary delta type");
	goto done;
	}

	done:
	git_buf_free(&inflated);
	return error;
	}

	static int apply_binary(
	git_buf *out,
	const char *source,
	size_t source_len,
	git_patch *patch)
	{
	git_buf reverse = GIT_BUF_INIT;
	int error = 0;

	if (!patch->binary.contains_data) {
	error = apply_err("patch does not contain binary data");
	goto done;
	}

	if (!patch->binary.old_file.datalen && !patch->binary.new_file.datalen)
	goto done;

	/* first, apply the new_file delta to the given source */
	if ((error = apply_binary_delta(out, source, source_len,
	&patch->binary.new_file)) < 0)
	goto done;

	/* second, apply the old_file delta to sanity check the result */
	if ((error = apply_binary_delta(&reverse, out->ptr, out->size,
	&patch->binary.old_file)) < 0)
	goto done;

	if (source_len != reverse.size \|\|
	memcmp(source, reverse.ptr, source_len) != 0) {
	error = apply_err("binary patch did not apply cleanly");
	goto done;
	}

	done:
	if (error < 0)
	git_buf_free(out);

	git_buf_free(&reverse);
	return error;
	}

	int git_apply__patch(
	git_buf *contents_out,
	char **filename_out,
	unsigned int *mode_out,
	const char *source,
	size_t source_len,
	git_patch *patch)
	{
	char *filename = NULL;
	unsigned int mode = 0;
	int error = 0;

	assert(contents_out && filename_out && mode_out && (source \|\| !source_len) && patch);

	*filename_out = NULL;
	*mode_out = 0;

	if (patch->delta->status != GIT_DELTA_DELETED) {
	const git_diff_file *newfile = &patch->delta->new_file;

	filename = git__strdup(newfile->path);
	mode = newfile->mode ?
	newfile->mode : GIT_FILEMODE_BLOB;
	}

	if (patch->delta->flags & GIT_DIFF_FLAG_BINARY)
	error = apply_binary(contents_out, source, source_len, patch);
	else if (patch->hunks.size)
	error = apply_hunks(contents_out, source, source_len, patch);
	else
	error = git_buf_put(contents_out, source, source_len);

	if (error)
	goto done;

	if (patch->delta->status == GIT_DELTA_DELETED &&
	git_buf_len(contents_out) > 0) {
	error = apply_err("removal patch leaves file contents");
	goto done;
	}

	*filename_out = filename;
	*mode_out = mode;

	done:
	if (error < 0)
	git__free(filename);

	return error;
	}