#include <stddef.h>

#include "common.h"

#include "repository.h"

#include "index.h"

#include "tree.h"

#include "tree-cache.h"

#include "hash.h"

#include "iterator.h"

#include "pathspec.h"

#include "ignore.h"

#include "blob.h"

#include "idxmap.h"

#include "diff.h"

#include "git2/odb.h"

#include "git2/oid.h"

#include "git2/blob.h"

#include "git2/config.h"

#include "git2/sys/index.h"

#define INSERT_IN_MAP_EX(idx, map, e, err) do { \

if ((idx)->ignore_case) \

git_idxmap_icase_insert((khash_t(idxicase) *) (map), (e), (e), (err)); \

else \

git_idxmap_insert((map), (e), (e), (err)); \

} while (0)

#define INSERT_IN_MAP(idx, e, err) INSERT_IN_MAP_EX(idx, (idx)->entries_map, e, err)

#define LOOKUP_IN_MAP(p, idx, k) do { \

if ((idx)->ignore_case) \

(p) = git_idxmap_icase_lookup_index((khash_t(idxicase) *) index->entries_map, (k)); \

else \

(p) = git_idxmap_lookup_index(index->entries_map, (k)); \

} while (0)

#define DELETE_IN_MAP(idx, e) do { \

if ((idx)->ignore_case) \

git_idxmap_icase_delete((khash_t(idxicase) *) (idx)->entries_map, (e)); \

else \

git_idxmap_delete((idx)->entries_map, (e)); \

} while (0)

static int index_apply_to_wd_diff(git_index *index, int action, const git_strarray *paths,

unsigned int flags,

git_index_matched_path_cb cb, void *payload);

#define entry_size(type,len) ((offsetof(type, path) + (len) + 8) & ~7)

#define short_entry_size(len) entry_size(struct entry_short, len)

#define long_entry_size(len) entry_size(struct entry_long, len)

#define minimal_entry_size (offsetof(struct entry_short, path))

static const size_t INDEX_FOOTER_SIZE = GIT_OID_RAWSZ;

static const size_t INDEX_HEADER_SIZE = 12;

static const unsigned int INDEX_VERSION_NUMBER = 2;

static const unsigned int INDEX_VERSION_NUMBER_EXT = 3;

static const unsigned int INDEX_HEADER_SIG = 0x44495243;

static const char INDEX_EXT_TREECACHE_SIG[] = {'T', 'R', 'E', 'E'};

static const char INDEX_EXT_UNMERGED_SIG[] = {'R', 'E', 'U', 'C'};

static const char INDEX_EXT_CONFLICT_NAME_SIG[] = {'N', 'A', 'M', 'E'};

#define INDEX_OWNER(idx) ((git_repository *)(GIT_REFCOUNT_OWNER(idx)))

struct index_header {

};

struct index_extension {

char signature[4];

uint32_t extension_size;

};

struct entry_time {

uint32_t seconds;

uint32_t nanoseconds;

};

struct entry_short {

};

struct entry_long {

};

struct entry_srch_key {

};

struct entry_internal {

};

struct reuc_entry_internal {

};

static size_t read_extension(git_index *index, const char *buffer, size_t buffer_size);

static int read_header(struct index_header *dest, const void *buffer);

static int parse_index(git_index *index, const char *buffer, size_t buffer_size);

static bool is_index_extended(git_index *index);

static int write_index(git_oid *checksum, git_index *index, git_filebuf *file);

static void index_entry_free(git_index_entry *entry);

static void index_entry_reuc_free(git_index_reuc_entry *reuc);

int git_index_entry_srch(const void *key, const void *array_member)

{

const struct entry_srch_key *srch_key = key;

const struct entry_internal *entry = array_member;

int cmp;

size_t len1, len2, len;

len1 = srch_key->pathlen;

len2 = entry->pathlen;

len = len1 < len2 ? len1 : len2;

cmp = memcmp(srch_key->path, entry->path, len);

if (cmp)

return cmp;

if (len1 < len2)

return -1;

if (len1 > len2)

return 1;

if (srch_key->stage != GIT_INDEX_STAGE_ANY)

return srch_key->stage - GIT_IDXENTRY_STAGE(&entry->entry);

return 0;

}

int git_index_entry_isrch(const void *key, const void *array_member)

{

const struct entry_srch_key *srch_key = key;

const struct entry_internal *entry = array_member;

int cmp;

size_t len1, len2, len;

len1 = srch_key->pathlen;

len2 = entry->pathlen;

len = len1 < len2 ? len1 : len2;

cmp = strncasecmp(srch_key->path, entry->path, len);

if (cmp)

return cmp;

if (len1 < len2)

return -1;

if (len1 > len2)

return 1;

if (srch_key->stage != GIT_INDEX_STAGE_ANY)

return srch_key->stage - GIT_IDXENTRY_STAGE(&entry->entry);

return 0;

}

static int index_entry_srch_path(const void *path, const void *array_member)

{

const git_index_entry *entry = array_member;

return strcmp((const char *)path, entry->path);

}

static int index_entry_isrch_path(const void *path, const void *array_member)

{

const git_index_entry *entry = array_member;

return strcasecmp((const char *)path, entry->path);

}

int git_index_entry_cmp(const void *a, const void *b)

{

int diff;

const git_index_entry *entry_a = a;

const git_index_entry *entry_b = b;

diff = strcmp(entry_a->path, entry_b->path);

if (diff == 0)

diff = (GIT_IDXENTRY_STAGE(entry_a) - GIT_IDXENTRY_STAGE(entry_b));

return diff;

}

int git_index_entry_icmp(const void *a, const void *b)

{

int diff;

const git_index_entry *entry_a = a;

const git_index_entry *entry_b = b;

diff = strcasecmp(entry_a->path, entry_b->path);

if (diff == 0)

diff = (GIT_IDXENTRY_STAGE(entry_a) - GIT_IDXENTRY_STAGE(entry_b));

return diff;

}

static int conflict_name_cmp(const void *a, const void *b)

{

const git_index_name_entry *name_a = a;

const git_index_name_entry *name_b = b;

if (name_a->ancestor && !name_b->ancestor)

return 1;

if (!name_a->ancestor && name_b->ancestor)

return -1;

if (name_a->ancestor)

return strcmp(name_a->ancestor, name_b->ancestor);

if (!name_a->ours || !name_b->ours)

return 0;

return strcmp(name_a->ours, name_b->ours);

}

#if 0

static int conflict_name_icmp(const void *a, const void *b)

{

const git_index_name_entry *name_a = a;

const git_index_name_entry *name_b = b;

if (name_a->ancestor && !name_b->ancestor)

return 1;

if (!name_a->ancestor && name_b->ancestor)

return -1;

if (name_a->ancestor)

return strcasecmp(name_a->ancestor, name_b->ancestor);

if (!name_a->ours || !name_b->ours)

return 0;

return strcasecmp(name_a->ours, name_b->ours);

}

static int reuc_srch(const void *key, const void *array_member)

{

const git_index_reuc_entry *reuc = array_member;

return strcmp(key, reuc->path);

}

static int reuc_isrch(const void *key, const void *array_member)

{

const git_index_reuc_entry *reuc = array_member;

return strcasecmp(key, reuc->path);

}

static int reuc_cmp(const void *a, const void *b)

{

const git_index_reuc_entry *info_a = a;

const git_index_reuc_entry *info_b = b;

return strcmp(info_a->path, info_b->path);

}

static int reuc_icmp(const void *a, const void *b)

{

const git_index_reuc_entry *info_a = a;

const git_index_reuc_entry *info_b = b;

return strcasecmp(info_a->path, info_b->path);

}

static void index_entry_reuc_free(git_index_reuc_entry *reuc)

{

git__free(reuc);

}

static void index_entry_free(git_index_entry *entry)

{

if (!entry)

return;

memset(&entry->id, 0, sizeof(entry->id));

git__free(entry);

}

unsigned int git_index__create_mode(unsigned int mode)

{

if (S_ISLNK(mode))

return S_IFLNK;

if (S_ISDIR(mode) || (mode & S_IFMT) == (S_IFLNK | S_IFDIR))

return (S_IFLNK | S_IFDIR);

return S_IFREG | GIT_PERMS_CANONICAL(mode);

}

static unsigned int index_merge_mode(

git_index *index, git_index_entry *existing, unsigned int mode)

{

if (index->no_symlinks && S_ISREG(mode) &&

existing && S_ISLNK(existing->mode))

return existing->mode;

if (index->distrust_filemode && S_ISREG(mode))

return (existing && S_ISREG(existing->mode)) ?

existing->mode : git_index__create_mode(0666);

return git_index__create_mode(mode);

}

GIT_INLINE(int) index_find_in_entries(

size_t *out, git_vector *entries, git_vector_cmp entry_srch,

const char *path, size_t path_len, int stage)

{

struct entry_srch_key srch_key;

srch_key.path = path;

srch_key.pathlen = !path_len ? strlen(path) : path_len;

srch_key.stage = stage;

return git_vector_bsearch2(out, entries, entry_srch, &srch_key);

}

GIT_INLINE(int) index_find(

size_t *out, git_index *index,

const char *path, size_t path_len, int stage)

{

git_vector_sort(&index->entries);

return index_find_in_entries(

out, &index->entries, index->entries_search, path, path_len, stage);

}

void git_index__set_ignore_case(git_index *index, bool ignore_case)

{

index->ignore_case = ignore_case;

if (ignore_case) {

index->entries_cmp_path = git__strcasecmp_cb;

index->entries_search = git_index_entry_isrch;

index->entries_search_path = index_entry_isrch_path;

index->reuc_search = reuc_isrch;

} else {

index->entries_cmp_path = git__strcmp_cb;

index->entries_search = git_index_entry_srch;

index->entries_search_path = index_entry_srch_path;

index->reuc_search = reuc_srch;

}

git_vector_set_cmp(&index->entries,

ignore_case ? git_index_entry_icmp : git_index_entry_cmp);

git_vector_sort(&index->entries);

git_vector_set_cmp(&index->reuc, ignore_case ? reuc_icmp : reuc_cmp);

git_vector_sort(&index->reuc);

}

int git_index_open(git_index **index_out, const char *index_path)

{

git_index *index;

int error = -1;

assert(index_out);

index = git__calloc(1, sizeof(git_index));

GITERR_CHECK_ALLOC(index);

git_pool_init(&index->tree_pool, 1);

if (index_path != NULL) {

index->index_file_path = git__strdup(index_path);

if (!index->index_file_path)

goto fail;

/* Check if index file is stored on disk already */

if (git_path_exists(index->index_file_path) == true)

index->on_disk = 1;

}

if (git_vector_init(&index->entries, 32, git_index_entry_cmp) < 0 ||

git_idxmap_alloc(&index->entries_map) < 0 ||

git_vector_init(&index->names, 8, conflict_name_cmp) < 0 ||

git_vector_init(&index->reuc, 8, reuc_cmp) < 0 ||

git_vector_init(&index->deleted, 8, git_index_entry_cmp) < 0)

goto fail;

index->entries_cmp_path = git__strcmp_cb;

index->entries_search = git_index_entry_srch;

index->entries_search_path = index_entry_srch_path;

index->reuc_search = reuc_srch;

if (index_path != NULL && (error = git_index_read(index, true)) < 0)

goto fail;

*index_out = index;

GIT_REFCOUNT_INC(index);

return 0;

fail:

git_pool_clear(&index->tree_pool);

git_index_free(index);

return error;

}

int git_index_new(git_index **out)

{

return git_index_open(out, NULL);

}

static void index_free(git_index *index)

{

/* index iterators increment the refcount of the index, so if we

assert(!git_atomic_get(&index->readers));

git_index_clear(index);

git_idxmap_free(index->entries_map);

git_vector_free(&index->entries);

git_vector_free(&index->names);

git_vector_free(&index->reuc);

git_vector_free(&index->deleted);

git__free(index->index_file_path);

git__memzero(index, sizeof(*index));

git__free(index);

}

void git_index_free(git_index *index)

{

if (index == NULL)

return;

GIT_REFCOUNT_DEC(index, index_free);

}

static void index_free_deleted(git_index *index)

{

int readers = (int)git_atomic_get(&index->readers);

size_t i;

if (readers > 0 || !index->deleted.length)

return;

for (i = 0; i < index->deleted.length; ++i) {

git_index_entry *ie = git__swap(index->deleted.contents[i], NULL);

index_entry_free(ie);

}

git_vector_clear(&index->deleted);

}

static int index_remove_entry(git_index *index, size_t pos)

{

int error = 0;

git_index_entry *entry = git_vector_get(&index->entries, pos);

if (entry != NULL)

git_tree_cache_invalidate_path(index->tree, entry->path);

DELETE_IN_MAP(index, entry);

error = git_vector_remove(&index->entries, pos);

if (!error) {

if (git_atomic_get(&index->readers) > 0) {

error = git_vector_insert(&index->deleted, entry);

} else {

index_entry_free(entry);

}

}

return error;

}

int git_index_clear(git_index *index)

{

int error = 0;

assert(index);

index->tree = NULL;

git_pool_clear(&index->tree_pool);

git_idxmap_clear(index->entries_map);

while (!error && index->entries.length > 0)

error = index_remove_entry(index, index->entries.length - 1);

index_free_deleted(index);

git_index_reuc_clear(index);

git_index_name_clear(index);

git_futils_filestamp_set(&index->stamp, NULL);

return error;

}

static int create_index_error(int error, const char *msg)

{

giterr_set(GITERR_INDEX, msg);

return error;

}

int git_index_set_caps(git_index *index, int caps)

{

unsigned int old_ignore_case;

assert(index);

old_ignore_case = index->ignore_case;

if (caps == GIT_INDEXCAP_FROM_OWNER) {

git_repository *repo = INDEX_OWNER(index);

int val;

if (!repo)

return create_index_error(

-1, "Cannot access repository to set index caps");

if (!git_repository__cvar(&val, repo, GIT_CVAR_IGNORECASE))

index->ignore_case = (val != 0);

if (!git_repository__cvar(&val, repo, GIT_CVAR_FILEMODE))

index->distrust_filemode = (val == 0);

if (!git_repository__cvar(&val, repo, GIT_CVAR_SYMLINKS))

index->no_symlinks = (val == 0);

}

else {

index->ignore_case = ((caps & GIT_INDEXCAP_IGNORE_CASE) != 0);

index->distrust_filemode = ((caps & GIT_INDEXCAP_NO_FILEMODE) != 0);

index->no_symlinks = ((caps & GIT_INDEXCAP_NO_SYMLINKS) != 0);

}

if (old_ignore_case != index->ignore_case) {

git_index__set_ignore_case(index, (bool)index->ignore_case);

}

return 0;

}

int git_index_caps(const git_index *index)

{

return ((index->ignore_case ? GIT_INDEXCAP_IGNORE_CASE : 0) |

(index->distrust_filemode ? GIT_INDEXCAP_NO_FILEMODE : 0) |

(index->no_symlinks ? GIT_INDEXCAP_NO_SYMLINKS : 0));

}

const git_oid *git_index_checksum(git_index *index)

{

return &index->checksum;

}

static int compare_checksum(git_index *index)

{

int fd, error;

ssize_t bytes_read;

git_oid checksum = {{ 0 }};

if ((fd = p_open(index->index_file_path, O_RDONLY)) < 0)

return fd;

if ((error = p_lseek(fd, -20, SEEK_END)) < 0) {

p_close(fd);

giterr_set(GITERR_OS, "failed to seek to end of file");

return -1;

}

bytes_read = p_read(fd, &checksum, GIT_OID_RAWSZ);

p_close(fd);

if (bytes_read < 0)

return -1;

return !!git_oid_cmp(&checksum, &index->checksum);

}

int git_index_read(git_index *index, int force)

{

int error = 0, updated;

git_buf buffer = GIT_BUF_INIT;

git_futils_filestamp stamp = index->stamp;

if (!index->index_file_path)

return create_index_error(-1,

"Failed to read index: The index is in-memory only");

index->on_disk = git_path_exists(index->index_file_path);

if (!index->on_disk) {

if (force)

return git_index_clear(index);

return 0;

}

if ((updated = git_futils_filestamp_check(&stamp, index->index_file_path) < 0) ||

((updated = compare_checksum(index)) < 0)) {

giterr_set(

GITERR_INDEX,

"Failed to read index: '%s' no longer exists",

index->index_file_path);

return updated;

}

if (!updated && !force)

return 0;

error = git_futils_readbuffer(&buffer, index->index_file_path);

if (error < 0)

return error;

index->tree = NULL;

git_pool_clear(&index->tree_pool);

error = git_index_clear(index);

if (!error)

error = parse_index(index, buffer.ptr, buffer.size);

if (!error)

git_futils_filestamp_set(&index->stamp, &stamp);

git_buf_free(&buffer);

return error;

}

int git_index__changed_relative_to(

git_index *index, const git_oid *checksum)

{

/* attempt to update index (ignoring errors) */

if (git_index_read(index, false) < 0)

giterr_clear();

return !!git_oid_cmp(&index->checksum, checksum);

}

static bool is_racy_entry(git_index *index, const git_index_entry *entry)

{

/* Git special-cases submodules in the check */

if (S_ISGITLINK(entry->mode))

return false;

return git_index_entry_newer_than_index(entry, index);

}

static int truncate_racily_clean(git_index *index)

{

size_t i;

int error;

git_index_entry *entry;

git_diff_options diff_opts = GIT_DIFF_OPTIONS_INIT;

git_diff *diff = NULL;

git_vector paths = GIT_VECTOR_INIT;

git_diff_delta *delta;

/* Nothing to do if there's no repo to talk about */

if (!INDEX_OWNER(index))

return 0;

/* If there's no workdir, we can't know where to even check */

if (!git_repository_workdir(INDEX_OWNER(index)))

return 0;

diff_opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE | GIT_DIFF_IGNORE_SUBMODULES | GIT_DIFF_DISABLE_PATHSPEC_MATCH;

git_vector_foreach(&index->entries, i, entry) {

if ((entry->flags_extended & GIT_IDXENTRY_UPTODATE) == 0 &&

is_racy_entry(index, entry))

git_vector_insert(&paths, (char *)entry->path);

}

if (paths.length == 0)

goto done;

diff_opts.pathspec.count = paths.length;

diff_opts.pathspec.strings = (char **)paths.contents;

if ((error = git_diff_index_to_workdir(&diff, INDEX_OWNER(index), index, &diff_opts)) < 0)

return error;

git_vector_foreach(&diff->deltas, i, delta) {

entry = (git_index_entry *)git_index_get_bypath(index, delta->old_file.path, 0);

/* Ensure that we have a stage 0 for this file (ie, it's not a

if (entry)

entry->file_size = 0;

}

done:

git_diff_free(diff);

git_vector_free(&paths);

return 0;

}

int git_index_write(git_index *index)

{

git_indexwriter writer = GIT_INDEXWRITER_INIT;

int error;

truncate_racily_clean(index);

if ((error = git_indexwriter_init(&writer, index)) == 0)

error = git_indexwriter_commit(&writer);

git_indexwriter_cleanup(&writer);

return error;

}

const char * git_index_path(const git_index *index)

{

assert(index);

return index->index_file_path;

}

int git_index_write_tree(git_oid *oid, git_index *index)

{

git_repository *repo;

assert(oid && index);

repo = INDEX_OWNER(index);

if (repo == NULL)

return create_index_error(-1, "Failed to write tree. "

"The index file is not backed up by an existing repository");

return git_tree__write_index(oid, index, repo);

}

int git_index_write_tree_to(

git_oid *oid, git_index *index, git_repository *repo)

{

assert(oid && index && repo);

return git_tree__write_index(oid, index, repo);

}

size_t git_index_entrycount(const git_index *index)

{

assert(index);

return index->entries.length;

}

const git_index_entry *git_index_get_byindex(

git_index *index, size_t n)

{

assert(index);

git_vector_sort(&index->entries);

return git_vector_get(&index->entries, n);

}

const git_index_entry *git_index_get_bypath(

git_index *index, const char *path, int stage)

{

khiter_t pos;

git_index_entry key = {{ 0 }};

assert(index);

key.path = path;

GIT_IDXENTRY_STAGE_SET(&key, stage);

LOOKUP_IN_MAP(pos, index, &key);

if (git_idxmap_valid_index(index->entries_map, pos))

return git_idxmap_value_at(index->entries_map, pos);

giterr_set(GITERR_INDEX, "Index does not contain %s", path);

return NULL;

}

void git_index_entry__init_from_stat(

git_index_entry *entry, struct stat *st, bool trust_mode)

{

entry->ctime.seconds = (git_time_t)st->st_ctime;

entry->mtime.seconds = (git_time_t)st->st_mtime;

#if defined(GIT_USE_NSEC)

entry->mtime.nanoseconds = st->st_mtim.tv_nsec;

entry->ctime.nanoseconds = st->st_ctim.tv_nsec;

entry->dev = st->st_rdev;

entry->ino = st->st_ino;

entry->mode = (!trust_mode && S_ISREG(st->st_mode)) ?

git_index__create_mode(0666) : git_index__create_mode(st->st_mode);

entry->uid = st->st_uid;

entry->gid = st->st_gid;

entry->file_size = st->st_size;

}

static void index_entry_adjust_namemask(

git_index_entry *entry,

size_t path_length)

{

entry->flags &= ~GIT_IDXENTRY_NAMEMASK;

if (path_length < GIT_IDXENTRY_NAMEMASK)

entry->flags |= path_length & GIT_IDXENTRY_NAMEMASK;

else

entry->flags |= GIT_IDXENTRY_NAMEMASK;

}

static int index_entry_create(

git_index_entry **out,

git_repository *repo,

const char *path)

{

size_t pathlen = strlen(path), alloclen;

struct entry_internal *entry;

if (!git_path_isvalid(repo, path,

GIT_PATH_REJECT_DEFAULTS | GIT_PATH_REJECT_DOT_GIT)) {

giterr_set(GITERR_INDEX, "Invalid path: '%s'", path);

return -1;

}

GITERR_CHECK_ALLOC_ADD(&alloclen, sizeof(struct entry_internal), pathlen);

GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);

entry = git__calloc(1, alloclen);

GITERR_CHECK_ALLOC(entry);

entry->pathlen = pathlen;

memcpy(entry->path, path, pathlen);

entry->entry.path = entry->path;

*out = (git_index_entry *)entry;

return 0;

}

static int index_entry_init(

git_index_entry **entry_out,

git_index *index,

const char *rel_path)

{

int error = 0;

git_index_entry *entry = NULL;

struct stat st;

git_oid oid;

if (INDEX_OWNER(index) == NULL)

return create_index_error(-1,

"Could not initialize index entry. "

"Index is not backed up by an existing repository.");

if (index_entry_create(&entry, INDEX_OWNER(index), rel_path) < 0)

return -1;

/* write the blob to disk and get the oid and stat info */

error = git_blob__create_from_paths(

&oid, &st, INDEX_OWNER(index), NULL, rel_path, 0, true);

if (error < 0) {

index_entry_free(entry);

return error;

}

entry->id = oid;

git_index_entry__init_from_stat(entry, &st, !index->distrust_filemode);

*entry_out = (git_index_entry *)entry;

return 0;

}

static git_index_reuc_entry *reuc_entry_alloc(const char *path)

{

size_t pathlen = strlen(path),

structlen = sizeof(struct reuc_entry_internal),

alloclen;

struct reuc_entry_internal *entry;

if (GIT_ADD_SIZET_OVERFLOW(&alloclen, structlen, pathlen) ||

GIT_ADD_SIZET_OVERFLOW(&alloclen, alloclen, 1))

return NULL;

entry = git__calloc(1, alloclen);

if (!entry)

return NULL;

entry->pathlen = pathlen;

memcpy(entry->path, path, pathlen);

entry->entry.path = entry->path;

return (git_index_reuc_entry *)entry;

}

static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,

int their_mode, const git_oid *their_oid)

{

git_index_reuc_entry *reuc = NULL;

assert(reuc_out && path);

*reuc_out = reuc = reuc_entry_alloc(path);

GITERR_CHECK_ALLOC(reuc);

if ((reuc->mode[0] = ancestor_mode) > 0)

git_oid_cpy(&reuc->oid[0], ancestor_oid);

if ((reuc->mode[1] = our_mode) > 0)

git_oid_cpy(&reuc->oid[1], our_oid);

if ((reuc->mode[2] = their_mode) > 0)

git_oid_cpy(&reuc->oid[2], their_oid);

return 0;

}

static void index_entry_cpy(

git_index_entry *tgt,

const git_index_entry *src)

{

const char *tgt_path = tgt->path;

memcpy(tgt, src, sizeof(*tgt));

tgt->path = tgt_path;

}

static int index_entry_dup(

git_index_entry **out,

git_index *index,

const git_index_entry *src)

{

if (index_entry_create(out, INDEX_OWNER(index), src->path) < 0)

return -1;

index_entry_cpy(*out, src);

return 0;

}

static void index_entry_cpy_nocache(

git_index_entry *tgt,

const git_index_entry *src)

{

git_oid_cpy(&tgt->id, &src->id);

tgt->mode = src->mode;

tgt->flags = src->flags;

tgt->flags_extended = (src->flags_extended & GIT_IDXENTRY_EXTENDED_FLAGS);

}

static int index_entry_dup_nocache(

git_index_entry **out,

git_index *index,

const git_index_entry *src)

{

if (index_entry_create(out, INDEX_OWNER(index), src->path) < 0)