/*

 * 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 "common.h"

#include "posix.h"

#include "buffer.h"

#include "repository.h"

#include "revwalk.h"

#include "commit_list.h"

#include "merge.h"

#include "path.h"

#include "refs.h"

#include "object.h"

#include "iterator.h"

#include "refs.h"

#include "diff.h"

#include "diff_generate.h"

#include "diff_tform.h"

#include "checkout.h"

#include "tree.h"

#include "blob.h"

#include "oid.h"

#include "index.h"

#include "filebuf.h"

#include "config.h"

#include "oidarray.h"

#include "annotated_commit.h"

#include "commit.h"

#include "oidarray.h"

#include "merge_driver.h"

#include "git2/types.h"

#include "git2/repository.h"

#include "git2/object.h"

#include "git2/commit.h"

#include "git2/merge.h"

#include "git2/refs.h"

#include "git2/reset.h"

#include "git2/checkout.h"

#include "git2/signature.h"

#include "git2/config.h"

#include "git2/tree.h"

#include "git2/oidarray.h"

#include "git2/annotated_commit.h"

#include "git2/sys/index.h"

#include "git2/sys/hashsig.h"

#define GIT_MERGE_INDEX_ENTRY_EXISTS(X)	((X).mode != 0)

#define GIT_MERGE_INDEX_ENTRY_ISFILE(X) S_ISREG((X).mode)

typedef enum {

	TREE_IDX_ANCESTOR = 0,

	TREE_IDX_OURS = 1,

	TREE_IDX_THEIRS = 2

} merge_tree_index_t;

/* Tracks D/F conflicts */

struct merge_diff_df_data {

	const char *df_path;

	const char *prev_path;

	git_merge_diff *prev_conflict;

};

/* Merge base computation */

int merge_bases_many(git_commit_list **out, git_revwalk **walk_out, git_repository *repo, size_t length, const git_oid input_array[])

{

	git_revwalk *walk = NULL;

	git_vector list;

	git_commit_list *result = NULL;

	git_commit_list_node *commit;

	int error = -1;

	unsigned int i;

	if (length < 2) {

		giterr_set(GITERR_INVALID, "at least two commits are required to find an ancestor");

		return -1;

	}

	if (git_vector_init(&list, length - 1, NULL) < 0)

		return -1;

	if (git_revwalk_new(&walk, repo) < 0)

		goto on_error;

	for (i = 1; i < length; i++) {

		commit = git_revwalk__commit_lookup(walk, &input_array[i]);

		if (commit == NULL)

			goto on_error;

		git_vector_insert(&list, commit);

	}

	commit = git_revwalk__commit_lookup(walk, &input_array[0]);

	if (commit == NULL)

		goto on_error;

	if (git_merge__bases_many(&result, walk, commit, &list) < 0)

		goto on_error;

	if (!result) {

		giterr_set(GITERR_MERGE, "no merge base found");

		error = GIT_ENOTFOUND;

		goto on_error;

	}

	*out = result;

	*walk_out = walk;

	git_vector_free(&list);

	return 0;

on_error:

	git_vector_free(&list);

	git_revwalk_free(walk);

	return error;

}

int git_merge_base_many(git_oid *out, git_repository *repo, size_t length, const git_oid input_array[])

{

	git_revwalk *walk;

	git_commit_list *result = NULL;

	int error = 0;

	assert(out && repo && input_array);

	if ((error = merge_bases_many(&result, &walk, repo, length, input_array)) < 0)

		return error;

	git_oid_cpy(out, &result->item->oid);

	git_commit_list_free(&result);

	git_revwalk_free(walk);

	return 0;

}

int git_merge_bases_many(git_oidarray *out, git_repository *repo, size_t length, const git_oid input_array[])

{

	git_revwalk *walk;

	git_commit_list *list, *result = NULL;

	int error = 0;

	git_array_oid_t array;

	assert(out && repo && input_array);

	if ((error = merge_bases_many(&result, &walk, repo, length, input_array)) < 0)

		return error;

	git_array_init(array);

	list = result;

	while (list) {

		git_oid *id = git_array_alloc(array);

		if (id == NULL) {

			error = -1;

			goto cleanup;

		}

		git_oid_cpy(id, &list->item->oid);

		list = list->next;

	}

	git_oidarray__from_array(out, &array);

cleanup:

	git_commit_list_free(&result);

	git_revwalk_free(walk);

	return error;

}

int git_merge_base_octopus(git_oid *out, git_repository *repo, size_t length, const git_oid input_array[])

{

	git_oid result;

	unsigned int i;

	int error = -1;

	assert(out && repo && input_array);

	if (length < 2) {

		giterr_set(GITERR_INVALID, "at least two commits are required to find an ancestor");

		return -1;

	}

	result = input_array[0];

	for (i = 1; i < length; i++) {

		error = git_merge_base(&result, repo, &result, &input_array[i]);

		if (error < 0)

			return error;

	}

	*out = result;

	return 0;

}

static int merge_bases(git_commit_list **out, git_revwalk **walk_out, git_repository *repo, const git_oid *one, const git_oid *two)

{

	git_revwalk *walk;

	git_vector list;

	git_commit_list *result = NULL;

	git_commit_list_node *commit;

	void *contents[1];

	if (git_revwalk_new(&walk, repo) < 0)

		return -1;

	commit = git_revwalk__commit_lookup(walk, two);

	if (commit == NULL)

		goto on_error;

	/* This is just one value, so we can do it on the stack */

	memset(&list, 0x0, sizeof(git_vector));

	contents[0] = commit;

	list.length = 1;

	list.contents = contents;

	commit = git_revwalk__commit_lookup(walk, one);

	if (commit == NULL)

		goto on_error;

	if (git_merge__bases_many(&result, walk, commit, &list) < 0)

		goto on_error;

	if (!result) {

		git_revwalk_free(walk);

		giterr_set(GITERR_MERGE, "no merge base found");

		return GIT_ENOTFOUND;

	}

	*out = result;

	*walk_out = walk;

	return 0;

on_error:

	git_revwalk_free(walk);

	return -1;

}

int git_merge_base(git_oid *out, git_repository *repo, const git_oid *one, const git_oid *two)

{

	int error;

	git_revwalk *walk;

	git_commit_list *result;

	if ((error = merge_bases(&result, &walk, repo, one, two)) < 0)

		return error;

	git_oid_cpy(out, &result->item->oid);

	git_commit_list_free(&result);

	git_revwalk_free(walk);

	return 0;

}

int git_merge_bases(git_oidarray *out, git_repository *repo, const git_oid *one, const git_oid *two)

{

	int error;

	git_revwalk *walk;

	git_commit_list *result, *list;

	git_array_oid_t array;

	git_array_init(array);

	if ((error = merge_bases(&result, &walk, repo, one, two)) < 0)

		return error;

	list = result;

	while (list) {

		git_oid *id = git_array_alloc(array);

		if (id == NULL)

			goto on_error;

		git_oid_cpy(id, &list->item->oid);

		list = list->next;

	}

	git_oidarray__from_array(out, &array);

	git_commit_list_free(&result);

	git_revwalk_free(walk);

	return 0;

on_error:

	git_commit_list_free(&result);

	git_revwalk_free(walk);

	return -1;

}

static int interesting(git_pqueue *list)

{

	size_t i;

	for (i = 0; i < git_pqueue_size(list); i++) {

		git_commit_list_node *commit = git_pqueue_get(list, i);

		if ((commit->flags & STALE) == 0)

			return 1;

	}

	return 0;

}

static void clear_commit_marks_1(git_commit_list **plist,

		git_commit_list_node *commit, unsigned int mark)

{

	while (commit) {

		unsigned int i;

		if (!(mark & commit->flags))

			return;

		commit->flags &= ~mark;

		for (i = 1; i < commit->out_degree; i++) {

			git_commit_list_node *p = commit->parents[i];

			git_commit_list_insert(p, plist);

		}

		commit = commit->out_degree ? commit->parents[0] : NULL;

	}

}

static void clear_commit_marks_many(git_vector *commits, unsigned int mark)

{

	git_commit_list *list = NULL;

	git_commit_list_node *c;

	unsigned int i;

	git_vector_foreach(commits, i, c) {

		git_commit_list_insert(c, &list);

	}

	while (list)

		clear_commit_marks_1(&list, git_commit_list_pop(&list), mark);

}

static void clear_commit_marks(git_commit_list_node *commit, unsigned int mark)

{

	git_commit_list *list = NULL;

	git_commit_list_insert(commit, &list);

	while (list)

		clear_commit_marks_1(&list, git_commit_list_pop(&list), mark);

}

static int paint_down_to_common(

	git_commit_list **out, git_revwalk *walk, git_commit_list_node *one, git_vector *twos)

{

	git_pqueue list;

	git_commit_list *result = NULL;

	git_commit_list_node *two;

	int error;

	unsigned int i;

	if (git_pqueue_init(&list, 0, twos->length * 2, git_commit_list_time_cmp) < 0)

		return -1;

	one->flags |= PARENT1;

	if (git_pqueue_insert(&list, one) < 0)

		return -1;

	git_vector_foreach(twos, i, two) {

		if (git_commit_list_parse(walk, two) < 0)

			return -1;

		two->flags |= PARENT2;

		if (git_pqueue_insert(&list, two) < 0)

			return -1;

	}

	/* as long as there are non-STALE commits */

	while (interesting(&list)) {

		git_commit_list_node *commit = git_pqueue_pop(&list);

		int flags;

		if (commit == NULL)

			break;

		flags = commit->flags & (PARENT1 | PARENT2 | STALE);

		if (flags == (PARENT1 | PARENT2)) {

			if (!(commit->flags & RESULT)) {

				commit->flags |= RESULT;

				if (git_commit_list_insert(commit, &result) == NULL)

					return -1;

			}

			/* we mark the parents of a merge stale */

			flags |= STALE;

		}

		for (i = 0; i < commit->out_degree; i++) {

			git_commit_list_node *p = commit->parents[i];

			if ((p->flags & flags) == flags)

				continue;

			if ((error = git_commit_list_parse(walk, p)) < 0)

				return error;

			p->flags |= flags;

			if (git_pqueue_insert(&list, p) < 0)

				return -1;

		}

	}

	git_pqueue_free(&list);

	*out = result;

	return 0;

}

static int remove_redundant(git_revwalk *walk, git_vector *commits)

{

	git_vector work = GIT_VECTOR_INIT;

	unsigned char *redundant;

	unsigned int *filled_index;

	unsigned int i, j;

	int error = 0;

	redundant = git__calloc(commits->length, 1);

	GITERR_CHECK_ALLOC(redundant);

	filled_index = git__calloc((commits->length - 1), sizeof(unsigned int));

	GITERR_CHECK_ALLOC(filled_index);

	for (i = 0; i < commits->length; ++i) {

		if ((error = git_commit_list_parse(walk, commits->contents[i])) < 0)

			goto done;

	}

	for (i = 0; i < commits->length; ++i) {

		git_commit_list *common = NULL;

		git_commit_list_node *commit = commits->contents[i];

		if (redundant[i])

			continue;

		git_vector_clear(&work);

		for (j = 0; j < commits->length; j++) {

			if (i == j || redundant[j])

				continue;

			filled_index[work.length] = j;

			if ((error = git_vector_insert(&work, commits->contents[j])) < 0)

				goto done;

		}

		error = paint_down_to_common(&common, walk, commit, &work);

		if (error < 0)

			goto done;

		if (commit->flags & PARENT2)

			redundant[i] = 1;

		for (j = 0; j < work.length; j++) {

			git_commit_list_node *w = work.contents[j];

			if (w->flags & PARENT1)

				redundant[filled_index[j]] = 1;

		}

		clear_commit_marks(commit, ALL_FLAGS);

		clear_commit_marks_many(&work, ALL_FLAGS);

		git_commit_list_free(&common);

	}

	for (i = 0; i < commits->length; ++i) {

		if (redundant[i])

			commits->contents[i] = NULL;

	}

done:

	git__free(redundant);

	git__free(filled_index);

	git_vector_free(&work);

	return error;

}

int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_list_node *one, git_vector *twos)

{

	int error;

	unsigned int i;

	git_commit_list_node *two;

	git_commit_list *result = NULL, *tmp = NULL;

	/* If there's only the one commit, there can be no merge bases */

	if (twos->length == 0) {

		*out = NULL;

		return 0;

	}

	/* if the commit is repeated, we have a our merge base already */

	git_vector_foreach(twos, i, two) {

		if (one == two)

			return git_commit_list_insert(one, out) ? 0 : -1;

	}

	if (git_commit_list_parse(walk, one) < 0)

		return -1;

	error = paint_down_to_common(&result, walk, one, twos);

	if (error < 0)

		return error;

	/* filter out any stale commits in the results */

	tmp = result;

	result = NULL;

	while (tmp) {

		git_commit_list_node *c = git_commit_list_pop(&tmp);

		if (!(c->flags & STALE))

			if (git_commit_list_insert_by_date(c, &result) == NULL)

				return -1;

	}

	/*

	 * more than one merge base -- see if there are redundant merge

	 * bases and remove them

	 */

	if (result && result->next) {

		git_vector redundant = GIT_VECTOR_INIT;

		while (result)

			git_vector_insert(&redundant, git_commit_list_pop(&result));

		clear_commit_marks(one, ALL_FLAGS);

		clear_commit_marks_many(twos, ALL_FLAGS);

		if ((error = remove_redundant(walk, &redundant)) < 0) {

			git_vector_free(&redundant);

			return error;

		}

		git_vector_foreach(&redundant, i, two) {

			if (two != NULL)

				git_commit_list_insert_by_date(two, &result);

		}

		git_vector_free(&redundant);

	}

	*out = result;

	return 0;

}

int git_repository_mergehead_foreach(

	git_repository *repo,

	git_repository_mergehead_foreach_cb cb,

	void *payload)

{

	git_buf merge_head_path = GIT_BUF_INIT, merge_head_file = GIT_BUF_INIT;

	char *buffer, *line;

	size_t line_num = 1;

	git_oid oid;

	int error = 0;

	assert(repo && cb);

	if ((error = git_buf_joinpath(&merge_head_path, repo->gitdir,

		GIT_MERGE_HEAD_FILE)) < 0)

		return error;

	if ((error = git_futils_readbuffer(&merge_head_file,

		git_buf_cstr(&merge_head_path))) < 0)

		goto cleanup;

	buffer = merge_head_file.ptr;

	while ((line = git__strsep(&buffer, "\n")) != NULL) {

		if (strlen(line) != GIT_OID_HEXSZ) {

			giterr_set(GITERR_INVALID, "unable to parse OID - invalid length");

			error = -1;

			goto cleanup;

		}

		if ((error = git_oid_fromstr(&oid, line)) < 0)

			goto cleanup;

		if ((error = cb(&oid, payload)) != 0) {

			giterr_set_after_callback(error);

			goto cleanup;

		}

		++line_num;

	}

	if (*buffer) {

		giterr_set(GITERR_MERGE, "no EOL at line %"PRIuZ, line_num);

		error = -1;

		goto cleanup;

	}

cleanup:

	git_buf_free(&merge_head_path);

	git_buf_free(&merge_head_file);

	return error;

}

GIT_INLINE(int) index_entry_cmp(const git_index_entry *a, const git_index_entry *b)

{

	int value = 0;

	if (a->path == NULL)

		return (b->path == NULL) ? 0 : 1;

	if ((value = a->mode - b->mode) == 0 &&

		(value = git_oid__cmp(&a->id, &b->id)) == 0)

		value = strcmp(a->path, b->path);

	return value;

}

/* Conflict resolution */

static int merge_conflict_resolve_trivial(

	int *resolved,

	git_merge_diff_list *diff_list,

	const git_merge_diff *conflict)

{

	int ours_empty, theirs_empty;

	int ours_changed, theirs_changed, ours_theirs_differ;

	git_index_entry const *result = NULL;

	int error = 0;

	assert(resolved && diff_list && conflict);

	*resolved = 0;

	if (conflict->type == GIT_MERGE_DIFF_DIRECTORY_FILE ||

		conflict->type == GIT_MERGE_DIFF_RENAMED_ADDED)

		return 0;

	if (conflict->our_status == GIT_DELTA_RENAMED ||

		conflict->their_status == GIT_DELTA_RENAMED)

		return 0;

	ours_empty = !GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry);

	theirs_empty = !GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry);

	ours_changed = (conflict->our_status != GIT_DELTA_UNMODIFIED);

	theirs_changed = (conflict->their_status != GIT_DELTA_UNMODIFIED);

	ours_theirs_differ = ours_changed && theirs_changed &&

		index_entry_cmp(&conflict->our_entry, &conflict->their_entry);

	/*

	 * Note: with only one ancestor, some cases are not distinct:

	 *

	 * 16: ancest:anc1/anc2, head:anc1, remote:anc2 = result:no merge

	 * 3: ancest:(empty)^, head:head, remote:(empty) = result:no merge

	 * 2: ancest:(empty)^, head:(empty), remote:remote = result:no merge

	 *

	 * Note that the two cases that take D/F conflicts into account

	 * specifically do not need to be explicitly tested, as D/F conflicts

	 * would fail the *empty* test:

	 *

	 * 3ALT: ancest:(empty)+, head:head, remote:*empty* = result:head

	 * 2ALT: ancest:(empty)+, head:*empty*, remote:remote = result:remote

	 *

	 * Note that many of these cases need not be explicitly tested, as

	 * they simply degrade to "all different" cases (eg, 11):

	 *

	 * 4: ancest:(empty)^, head:head, remote:remote = result:no merge

	 * 7: ancest:ancest+, head:(empty), remote:remote = result:no merge

	 * 9: ancest:ancest+, head:head, remote:(empty) = result:no merge

	 * 11: ancest:ancest+, head:head, remote:remote = result:no merge

	 */

	/* 5ALT: ancest:*, head:head, remote:head = result:head */

	if (ours_changed && !ours_empty && !ours_theirs_differ)

		result = &conflict->our_entry;

	/* 6: ancest:ancest+, head:(empty), remote:(empty) = result:no merge */

	else if (ours_changed && ours_empty && theirs_empty)

		*resolved = 0;

	/* 8: ancest:ancest^, head:(empty), remote:ancest = result:no merge */

	else if (ours_empty && !theirs_changed)

		*resolved = 0;

	/* 10: ancest:ancest^, head:ancest, remote:(empty) = result:no merge */

	else if (!ours_changed && theirs_empty)

		*resolved = 0;

	/* 13: ancest:ancest+, head:head, remote:ancest = result:head */

	else if (ours_changed && !theirs_changed)

		result = &conflict->our_entry;

	/* 14: ancest:ancest+, head:ancest, remote:remote = result:remote */

	else if (!ours_changed && theirs_changed)

		result = &conflict->their_entry;

	else

		*resolved = 0;

	if (result != NULL &&

		GIT_MERGE_INDEX_ENTRY_EXISTS(*result) &&

		(error = git_vector_insert(&diff_list->staged, (void *)result)) >= 0)

		*resolved = 1;

	/* Note: trivial resolution does not update the REUC. */

	return error;

}

static int merge_conflict_resolve_one_removed(

	int *resolved,

	git_merge_diff_list *diff_list,

	const git_merge_diff *conflict)

{

	int ours_empty, theirs_empty;

	int ours_changed, theirs_changed;

	int error = 0;

	assert(resolved && diff_list && conflict);

	*resolved = 0;

	if (conflict->type == GIT_MERGE_DIFF_DIRECTORY_FILE ||

		conflict->type == GIT_MERGE_DIFF_RENAMED_ADDED)

		return 0;

	ours_empty = !GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry);

	theirs_empty = !GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry);

	ours_changed = (conflict->our_status != GIT_DELTA_UNMODIFIED);

	theirs_changed = (conflict->their_status != GIT_DELTA_UNMODIFIED);

	/* Removed in both */

	if (ours_changed && ours_empty && theirs_empty)

		*resolved = 1;

	/* Removed in ours */

	else if (ours_empty && !theirs_changed)

		*resolved = 1;

	/* Removed in theirs */

	else if (!ours_changed && theirs_empty)

		*resolved = 1;

	if (*resolved)

		git_vector_insert(&diff_list->resolved, (git_merge_diff *)conflict);

	return error;

}

static int merge_conflict_resolve_one_renamed(

	int *resolved,

	git_merge_diff_list *diff_list,

	const git_merge_diff *conflict)

{

	int ours_renamed, theirs_renamed;

	int ours_changed, theirs_changed;

	git_index_entry *merged;

	int error = 0;

	assert(resolved && diff_list && conflict);

	*resolved = 0;

	if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry) ||

		!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry))

		return 0;

	ours_renamed = (conflict->our_status == GIT_DELTA_RENAMED);

	theirs_renamed = (conflict->their_status == GIT_DELTA_RENAMED);

	if (!ours_renamed && !theirs_renamed)

		return 0;

	/* Reject one file in a 2->1 conflict */

	if (conflict->type == GIT_MERGE_DIFF_BOTH_RENAMED_2_TO_1 ||

		conflict->type == GIT_MERGE_DIFF_BOTH_RENAMED_1_TO_2 ||

		conflict->type == GIT_MERGE_DIFF_RENAMED_ADDED)

		return 0;

	ours_changed = (git_oid__cmp(&conflict->ancestor_entry.id, &conflict->our_entry.id) != 0);

	theirs_changed = (git_oid__cmp(&conflict->ancestor_entry.id, &conflict->their_entry.id) != 0);

	/* if both are modified (and not to a common target) require a merge */

	if (ours_changed && theirs_changed &&

		git_oid__cmp(&conflict->our_entry.id, &conflict->their_entry.id) != 0)

		return 0;

	if ((merged = git_pool_malloc(&diff_list->pool, sizeof(git_index_entry))) == NULL)

		return -1;

	if (ours_changed)

		memcpy(merged, &conflict->our_entry, sizeof(git_index_entry));

	else

		memcpy(merged, &conflict->their_entry, sizeof(git_index_entry));

	if (ours_renamed)

		merged->path = conflict->our_entry.path;

	else

		merged->path = conflict->their_entry.path;

	*resolved = 1;

	git_vector_insert(&diff_list->staged, merged);

	git_vector_insert(&diff_list->resolved, (git_merge_diff *)conflict);

	return error;

}

static bool merge_conflict_can_resolve_contents(

	const git_merge_diff *conflict)

{

	if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry) ||

		!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry))

		return false;

	/* Reject D/F conflicts */

	if (conflict->type == GIT_MERGE_DIFF_DIRECTORY_FILE)

		return false;

	/* Reject submodules. */

	if (S_ISGITLINK(conflict->ancestor_entry.mode) ||

		S_ISGITLINK(conflict->our_entry.mode) ||

		S_ISGITLINK(conflict->their_entry.mode))

		return false;

	/* Reject link/file conflicts. */

	if ((S_ISLNK(conflict->ancestor_entry.mode) ^

			S_ISLNK(conflict->our_entry.mode)) ||

		(S_ISLNK(conflict->ancestor_entry.mode) ^

			S_ISLNK(conflict->their_entry.mode)))

		return false;

	/* Reject name conflicts */

	if (conflict->type == GIT_MERGE_DIFF_BOTH_RENAMED_2_TO_1 ||

		conflict->type == GIT_MERGE_DIFF_RENAMED_ADDED)

		return false;

	if ((conflict->our_status & GIT_DELTA_RENAMED) == GIT_DELTA_RENAMED &&

		(conflict->their_status & GIT_DELTA_RENAMED) == GIT_DELTA_RENAMED &&

		strcmp(conflict->ancestor_entry.path, conflict->their_entry.path) != 0)

		return false;

	return true;

}

static int merge_conflict_invoke_driver(

	git_index_entry **out,

	const char *name,

	git_merge_driver *driver,

	git_merge_diff_list *diff_list,

	git_merge_driver_source *src)

{

	git_index_entry *result;

	git_buf buf = GIT_BUF_INIT;

	const char *path;

	uint32_t mode;

	git_odb *odb = NULL;

	git_oid oid;

	int error;

	*out = NULL;

	if ((error = driver->apply(driver, &path, &mode, &buf, name, src)) < 0 ||

		(error = git_repository_odb(&odb, src->repo)) < 0 ||

		(error = git_odb_write(&oid, odb, buf.ptr, buf.size, GIT_OBJ_BLOB)) < 0)

		goto done;

	result = git_pool_mallocz(&diff_list->pool, sizeof(git_index_entry));

	GITERR_CHECK_ALLOC(result);

	git_oid_cpy(&result->id, &oid;;

	result->mode = mode;

	result->file_size = buf.size;

	result->path = git_pool_strdup(&diff_list->pool, path);

	GITERR_CHECK_ALLOC(result->path);

	*out = result;

done:

	git_buf_free(&buf;;

	git_odb_free(odb);

	return error;

}