#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 "git2/odb.h"

#include "git2/oid.h"

#include "git2/blob.h"

#include "git2/config.h"

#include "git2/sys/index.h"

#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 {

};

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

static size_t read_entry(git_index_entry *dest, const void *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_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);

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

{

const struct entry_srch_key *srch_key = key;

const git_index_entry *entry = array_member;

int cmp;

size_t len1, len2, len;

len1 = srch_key->path_len;

len2 = strlen(entry->path);

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);

return 0;

}

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

{

const struct entry_srch_key *srch_key = key;

const git_index_entry *entry = array_member;

int cmp;

size_t len1, len2, len;

len1 = srch_key->path_len;

len2 = strlen(entry->path);

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);

return 0;

}

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

{

return strcmp((const char *)a, (const char *)b);

}

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

{

return strcasecmp((const char *)a, (const char *)b);

}

static int index_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_isrch_path(const void *path, const void *array_member)

{

const git_index_entry *entry = array_member;

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

}

static int index_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;

}

static int index_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)

{

if (!reuc)

return;

git__free(reuc->path);

git__free(reuc);

}

static void index_entry_free(git_index_entry *entry)

{

if (!entry)

return;

git__free(entry->path);

git__free(entry);

}

static unsigned int 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 : index_create_mode(0666);

return index_create_mode(mode);

}

void git_index__set_ignore_case(git_index *index, bool ignore_case)

{

index->ignore_case = ignore_case;

index->entries_cmp_path = ignore_case ? index_icmp_path : index_cmp_path;

index->entries_search = ignore_case ? index_isrch : index_srch;

index->entries_search_path = ignore_case ? index_isrch_path : index_srch_path;

git_vector_set_cmp(&index->entries, ignore_case ? index_icmp : index_cmp);

git_vector_sort(&index->entries);

index->reuc_search = ignore_case ? reuc_isrch : reuc_srch;

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;

assert(index_out);

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

GITERR_CHECK_ALLOC(index);

if (index_path != NULL) {

index->index_file_path = git__strdup(index_path);

GITERR_CHECK_ALLOC(index->index_file_path);

/* 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, index_cmp) < 0 ||

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

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

return -1;

index->entries_cmp_path = index_cmp_path;

index->entries_search = index_srch;

index->entries_search_path = index_srch_path;

index->reuc_search = reuc_srch;

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

git_index_free(index);

return error;

}

*index_out = index;

GIT_REFCOUNT_INC(index);

return 0;

}

int git_index_new(git_index **out)

{

return git_index_open(out, NULL);

}

static void index_free(git_index *index)

{

git_index_clear(index);

git_vector_free(&index->entries);

git_vector_free(&index->names);

git_vector_free(&index->reuc);

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_entries_free(git_vector *entries)

{

size_t i;

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

index_entry_free(git__swap(entries->contents[i], NULL));

git_vector_clear(entries);

}

void git_index_clear(git_index *index)

{

assert(index);

index_entries_free(&index->entries);

git_index_reuc_clear(index);

git_index_name_clear(index);

git_futils_filestamp_set(&index->stamp, NULL);

git_tree_cache_free(index->tree);

index->tree = NULL;

}

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, unsigned 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;

}

unsigned 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));

}

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)

git_index_clear(index);

return 0;

}

updated = git_futils_filestamp_check(&stamp, index->index_file_path);

if (updated < 0 || (!updated && !force))

return updated;

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

if (error < 0)

return error;

git_index_clear(index);

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_write(git_index *index)

{

git_filebuf file = GIT_FILEBUF_INIT;

int error;

if (!index->index_file_path)

return create_index_error(-1,

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

git_vector_sort(&index->entries);

git_vector_sort(&index->reuc);

if ((error = git_filebuf_open(

&file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS, GIT_INDEX_FILE_MODE)) < 0) {

if (error == GIT_ELOCKED)

giterr_set(GITERR_INDEX, "The index is locked. This might be due to a concurrrent or crashed process");

return error;

}

if ((error = write_index(index, &file)) < 0) {

git_filebuf_cleanup(&file);

return error;

}

if ((error = git_filebuf_commit(&file)) < 0)

return error;

error = git_futils_filestamp_check(&index->stamp, index->index_file_path);

if (error < 0)

return error;

index->on_disk = 1;

return 0;

}

const char * git_index_path(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)

{

size_t pos;

assert(index);

if (git_index__find(&pos, index, path, 0, stage) < 0) {

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

return NULL;

}

return git_index_get_byindex(index, pos);

}

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;

/* entry->mtime.nanoseconds = st->st_mtimensec; */

/* entry->ctime.nanoseconds = st->st_ctimensec; */

entry->dev = st->st_rdev;

entry->ino = st->st_ino;

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

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

entry->uid = st->st_uid;

entry->gid = st->st_gid;

entry->file_size = st->st_size;

}

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

{

const git_index_entry *entry_a = a;

const git_index_entry *entry_b = b;

return strcmp(entry_a->path, entry_b->path);

}

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

{

const git_index_entry *entry_a = a;

const git_index_entry *entry_b = b;

return strcasecmp(entry_a->path, entry_b->path);

}

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.");

/* 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)

return error;

entry = git__calloc(1, sizeof(git_index_entry));

GITERR_CHECK_ALLOC(entry);

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

entry->id = oid;

entry->path = git__strdup(rel_path);

GITERR_CHECK_ALLOC(entry->path);

*entry_out = entry;

return 0;

}

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 = NULL;

reuc = git__calloc(1, sizeof(git_index_reuc_entry));

GITERR_CHECK_ALLOC(reuc);

reuc->path = git__strdup(path);

if (reuc->path == NULL)

return -1;

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);

*reuc_out = reuc;

return 0;

}

static git_index_entry *index_entry_dup(const git_index_entry *source_entry)

{

git_index_entry *entry;

entry = git__malloc(sizeof(git_index_entry));

if (!entry)

return NULL;

memcpy(entry, source_entry, sizeof(git_index_entry));

/* duplicate the path string so we own it */

entry->path = git__strdup(entry->path);

if (!entry->path)

return NULL;

return entry;

}

static int has_file_name(git_index *index,

const git_index_entry *entry, size_t pos, int ok_to_replace)

{

int retval = 0;

size_t len = strlen(entry->path);

int stage = GIT_IDXENTRY_STAGE(entry);

const char *name = entry->path;

while (pos < index->entries.length) {

git_index_entry *p = index->entries.contents[pos++];

if (len >= strlen(p->path))

break;

if (memcmp(name, p->path, len))

break;

if (GIT_IDXENTRY_STAGE(p) != stage)

continue;

if (p->path[len] != '/')

continue;

retval = -1;

if (!ok_to_replace)

break;

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

}

return retval;

}

static int has_dir_name(git_index *index,

const git_index_entry *entry, int ok_to_replace)

{

int retval = 0;

int stage = GIT_IDXENTRY_STAGE(entry);

const char *name = entry->path;

const char *slash = name + strlen(name);

for (;;) {

size_t len, position;

for (;;) {

if (*--slash == '/')

break;

if (slash <= entry->path)

return retval;

}

len = slash - name;

if (git_index__find(&position, index, name, len, stage) == 0) {

retval = -1;

if (!ok_to_replace)

break;

git_vector_remove(&index->entries, position);

continue;

}

/*

while (position < index->entries.length) {

git_index_entry *p = index->entries.contents[position];

if ((strlen(p->path) <= len) ||

(p->path[len] != '/') ||

memcmp(p->path, name, len))

break; /* not our subdirectory */

if (GIT_IDXENTRY_STAGE(p) == stage)

return retval;

position++;

}

}

return retval;

}

static int check_file_directory_collision(git_index *index,

git_index_entry *entry, size_t pos, int ok_to_replace)

{

int retval = has_file_name(index, entry, pos, ok_to_replace);

retval = retval + has_dir_name(index, entry, ok_to_replace);

if (retval) {

giterr_set(GITERR_INDEX, "'%s' appears as both a file an a directory", entry->path);

return -1;

}

return 0;

}

static int index_insert(git_index *index, git_index_entry *entry, int replace)

{

size_t path_length, position;

git_index_entry **existing = NULL;

assert(index && entry && entry->path != NULL);

/* make sure that the path length flag is correct */

path_length = strlen(entry->path);

entry->flags &= ~GIT_IDXENTRY_NAMEMASK;

if (path_length < GIT_IDXENTRY_NAMEMASK)

entry->flags |= path_length & GIT_IDXENTRY_NAMEMASK;

else

entry->flags |= GIT_IDXENTRY_NAMEMASK;

/* look if an entry with this path already exists */

if (!git_index__find(

&position, index, entry->path, 0, GIT_IDXENTRY_STAGE(entry))) {

existing = (git_index_entry **)&index->entries.contents[position];

/* update filemode to existing values if stat is not trusted */

entry->mode = index_merge_mode(index, *existing, entry->mode);

}

if (check_file_directory_collision(index, entry, position, replace) < 0)

return -1;

/* if replacing is not requested or no existing entry exists, just

if (!replace || !existing)

return git_vector_insert(&index->entries, entry);

/* exists, replace it (preserving name from existing entry) */

git__free(entry->path);

entry->path = (*existing)->path;

git__free(*existing);

*existing = entry;

return 0;

}

static int index_conflict_to_reuc(git_index *index, const char *path)

{

const git_index_entry *conflict_entries[3];

int ancestor_mode, our_mode, their_mode;

git_oid const *ancestor_oid, *our_oid, *their_oid;

int ret;

if ((ret = git_index_conflict_get(&conflict_entries[0],

&conflict_entries[1], &conflict_entries[2], index, path)) < 0)

return ret;

ancestor_mode = conflict_entries[0] == NULL ? 0 : conflict_entries[0]->mode;

our_mode = conflict_entries[1] == NULL ? 0 : conflict_entries[1]->mode;

their_mode = conflict_entries[2] == NULL ? 0 : conflict_entries[2]->mode;

ancestor_oid = conflict_entries[0] == NULL ? NULL : &conflict_entries[0]->id;

our_oid = conflict_entries[1] == NULL ? NULL : &conflict_entries[1]->id;

their_oid = conflict_entries[2] == NULL ? NULL : &conflict_entries[2]->id;

if ((ret = git_index_reuc_add(index, path, ancestor_mode, ancestor_oid,

our_mode, our_oid, their_mode, their_oid)) >= 0)

ret = git_index_conflict_remove(index, path);

return ret;

}

int git_index_add_bypath(git_index *index, const char *path)

{

git_index_entry *entry = NULL;

int ret;

assert(index && path);

if ((ret = index_entry_init(&entry, index, path)) < 0 ||

(ret = index_insert(index, entry, 1)) < 0)

goto on_error;

/* Adding implies conflict was resolved, move conflict entries to REUC */

if ((ret = index_conflict_to_reuc(index, path)) < 0 && ret != GIT_ENOTFOUND)

goto on_error;

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

return 0;

on_error:

index_entry_free(entry);

return ret;

}

int git_index_remove_bypath(git_index *index, const char *path)

{

int ret;

assert(index && path);

if (((ret = git_index_remove(index, path, 0)) < 0 &&

ret != GIT_ENOTFOUND) ||

((ret = index_conflict_to_reuc(index, path)) < 0 &&

ret != GIT_ENOTFOUND))

return ret;

return 0;

}

int git_index_add(git_index *index, const git_index_entry *source_entry)

{

git_index_entry *entry = NULL;

int ret;

entry = index_entry_dup(source_entry);

if (entry == NULL)

return -1;

if ((ret = index_insert(index, entry, 1)) < 0) {

index_entry_free(entry);

return ret;

}

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

return 0;

}

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

{

size_t position;

int error;

git_index_entry *entry;

if (git_index__find(&position, index, path, 0, stage) < 0) {

giterr_set(GITERR_INDEX, "Index does not contain %s at stage %d",

path, stage);

return GIT_ENOTFOUND;

}

entry = git_vector_get(&index->entries, position);

if (entry != NULL)

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

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

if (!error)

index_entry_free(entry);

return error;

}

int git_index_remove_directory(git_index *index, const char *dir, int stage)

{

git_buf pfx = GIT_BUF_INIT;

int error = 0;

size_t pos;

git_index_entry *entry;

if (git_buf_sets(&pfx, dir) < 0 || git_path_to_dir(&pfx) < 0)

return -1;

git_vector_sort(&index->entries);

pos = git_index__prefix_position(index, pfx.ptr);

while (1) {

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

if (!entry || git__prefixcmp(entry->path, pfx.ptr) != 0)

break;

if (GIT_IDXENTRY_STAGE(entry) != stage) {

++pos;

continue;

}

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

if ((error = git_vector_remove(&index->entries, pos)) < 0)

break;

index_entry_free(entry);

/* removed entry at 'pos' so we don't need to increment it */