| /* |
| * This file is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License, version 2, |
| * as published by the Free Software Foundation. |
| * |
| * In addition to the permissions in the GNU General Public License, |
| * the authors give you unlimited permission to link the compiled |
| * version of this file into combinations with other programs, |
| * and to distribute those combinations without any restriction |
| * coming from the use of this file. (The General Public License |
| * restrictions do apply in other respects; for example, they cover |
| * modification of the file, and distribution when not linked into |
| * a combined executable.) |
| * |
| * This file is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; see the file COPYING. If not, write to |
| * the Free Software Foundation, 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #include <stddef.h> |
| |
| #include "common.h" |
| #include "repository.h" |
| #include "index.h" |
| #include "hash.h" |
| #include "git2/odb.h" |
| #include "git2/blob.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'}; |
| |
| struct index_header { |
| uint32_t signature; |
| uint32_t version; |
| uint32_t entry_count; |
| }; |
| |
| struct index_extension { |
| char signature[4]; |
| uint32_t extension_size; |
| }; |
| |
| struct entry_time { |
| uint32_t seconds; |
| uint32_t nanoseconds; |
| }; |
| |
| struct entry_short { |
| struct entry_time ctime; |
| struct entry_time mtime; |
| uint32_t dev; |
| uint32_t ino; |
| uint32_t mode; |
| uint32_t uid; |
| uint32_t gid; |
| uint32_t file_size; |
| git_oid oid; |
| uint16_t flags; |
| char path[1]; /* arbitrary length */ |
| }; |
| |
| struct entry_long { |
| struct entry_time ctime; |
| struct entry_time mtime; |
| uint32_t dev; |
| uint32_t ino; |
| uint32_t mode; |
| uint32_t uid; |
| uint32_t gid; |
| uint32_t file_size; |
| git_oid oid; |
| uint16_t flags; |
| uint16_t flags_extended; |
| char path[1]; /* arbitrary length */ |
| }; |
| |
| /* local declarations */ |
| 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 read_tree(git_index *index, const char *buffer, size_t buffer_size); |
| static int read_tree_internal(git_index_tree **, const char **, const char *, git_index_tree *); |
| |
| static int parse_index(git_index *index, const char *buffer, size_t buffer_size); |
| static int is_index_extended(git_index *index); |
| static int write_index(git_index *index, git_filebuf *file); |
| |
| static int index_srch(const void *key, const void *array_member) |
| { |
| const git_index_entry *entry = array_member; |
| |
| return strcmp(key, entry->path); |
| } |
| |
| static int index_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); |
| } |
| |
| static int unmerged_srch(const void *key, const void *array_member) |
| { |
| const git_index_entry_unmerged *entry = array_member; |
| |
| return strcmp(key, entry->path); |
| } |
| |
| static int unmerged_cmp(const void *a, const void *b) |
| { |
| const git_index_entry_unmerged *info_a = a; |
| const git_index_entry_unmerged *info_b = b; |
| |
| return strcmp(info_a->path, info_b->path); |
| } |
| |
| 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 | ((mode & 0100) ? 0755 : 0644); |
| } |
| |
| static int index_initialize(git_index **index_out, git_repository *owner, const char *index_path) |
| { |
| git_index *index; |
| |
| assert(index_out && index_path); |
| |
| index = git__malloc(sizeof(git_index)); |
| if (index == NULL) |
| return GIT_ENOMEM; |
| |
| memset(index, 0x0, sizeof(git_index)); |
| |
| index->index_file_path = git__strdup(index_path); |
| if (index->index_file_path == NULL) { |
| free(index); |
| return GIT_ENOMEM; |
| } |
| |
| index->repository = owner; |
| |
| git_vector_init(&index->entries, 32, index_cmp); |
| |
| /* Check if index file is stored on disk already */ |
| if (git_futils_exists(index->index_file_path) == 0) |
| index->on_disk = 1; |
| |
| *index_out = index; |
| return git_index_read(index); |
| } |
| |
| int git_index_open(git_index **index_out, const char *index_path) |
| { |
| return index_initialize(index_out, NULL, index_path); |
| } |
| |
| /* |
| * Moved from `repository.c` |
| */ |
| int git_repository_index(git_index **index_out, git_repository *repo) |
| { |
| if (repo->is_bare) |
| return git__throw(GIT_EBAREINDEX, "Failed to open index. Repository is bare"); |
| |
| return index_initialize(index_out, repo, repo->path_index); |
| } |
| |
| void git_index_free(git_index *index) |
| { |
| if (index == NULL) |
| return; |
| |
| git_index_clear(index); |
| git_vector_free(&index->entries); |
| git_vector_free(&index->unmerged); |
| |
| free(index->index_file_path); |
| free(index); |
| } |
| |
| static void free_tree(git_index_tree *tree) |
| { |
| unsigned int i; |
| |
| if (tree == NULL) |
| return; |
| |
| for (i = 0; i < tree->children_count; ++i) |
| free_tree(tree->children[i]); |
| |
| free(tree->name); |
| free(tree->children); |
| free(tree); |
| } |
| |
| void git_index_clear(git_index *index) |
| { |
| unsigned int i; |
| |
| assert(index); |
| |
| for (i = 0; i < index->entries.length; ++i) { |
| git_index_entry *e; |
| e = git_vector_get(&index->entries, i); |
| free(e->path); |
| free(e); |
| } |
| |
| for (i = 0; i < index->unmerged.length; ++i) { |
| git_index_entry_unmerged *e; |
| e = git_vector_get(&index->unmerged, i); |
| free(e->path); |
| free(e); |
| } |
| |
| git_vector_clear(&index->entries); |
| git_vector_clear(&index->unmerged); |
| index->last_modified = 0; |
| |
| free_tree(index->tree); |
| index->tree = NULL; |
| } |
| |
| int git_index_read(git_index *index) |
| { |
| int error = GIT_SUCCESS, updated; |
| git_fbuffer buffer = GIT_FBUFFER_INIT; |
| time_t mtime; |
| |
| assert(index->index_file_path); |
| |
| if (!index->on_disk || git_futils_exists(index->index_file_path) < 0) { |
| git_index_clear(index); |
| index->on_disk = 0; |
| return GIT_SUCCESS; |
| } |
| |
| /* We don't want to update the mtime if we fail to parse the index */ |
| mtime = index->last_modified; |
| error = git_futils_readbuffer_updated(&buffer, index->index_file_path, &mtime, &updated); |
| if (error < GIT_SUCCESS) |
| return git__rethrow(error, "Failed to read index"); |
| |
| if (updated) { |
| git_index_clear(index); |
| error = parse_index(index, buffer.data, buffer.len); |
| |
| if (error == GIT_SUCCESS) |
| index->last_modified = mtime; |
| |
| git_futils_freebuffer(&buffer); |
| } |
| |
| if (error < GIT_SUCCESS) |
| return git__rethrow(error, "Failed to parse index"); |
| return error; |
| } |
| |
| int git_index_write(git_index *index) |
| { |
| git_filebuf file; |
| struct stat indexst; |
| int error; |
| |
| git_vector_sort(&index->entries); |
| |
| if ((error = git_filebuf_open(&file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS)) < GIT_SUCCESS) |
| return git__rethrow(error, "Failed to write index"); |
| |
| if ((error = write_index(index, &file)) < GIT_SUCCESS) { |
| git_filebuf_cleanup(&file); |
| return git__rethrow(error, "Failed to write index"); |
| } |
| |
| if ((error = git_filebuf_commit(&file)) < GIT_SUCCESS) |
| return git__rethrow(error, "Failed to write index"); |
| |
| if (p_stat(index->index_file_path, &indexst) == 0) { |
| index->last_modified = indexst.st_mtime; |
| index->on_disk = 1; |
| } |
| |
| return GIT_SUCCESS; |
| } |
| |
| unsigned int git_index_entrycount(git_index *index) |
| { |
| assert(index); |
| return index->entries.length; |
| } |
| |
| unsigned int git_index_entrycount_unmerged(git_index *index) |
| { |
| assert(index); |
| return index->unmerged.length; |
| } |
| |
| git_index_entry *git_index_get(git_index *index, unsigned int n) |
| { |
| git_vector_sort(&index->entries); |
| return git_vector_get(&index->entries, n); |
| } |
| |
| static int index_entry_init(git_index_entry **entry_out, git_index *index, const char *rel_path, int stage) |
| { |
| git_index_entry *entry; |
| char full_path[GIT_PATH_MAX]; |
| struct stat st; |
| git_oid oid; |
| int error; |
| |
| if (index->repository == NULL) |
| return git__throw(GIT_EBAREINDEX, "Failed to initialize entry. Repository is bare"); |
| |
| git_path_join(full_path, index->repository->path_workdir, rel_path); |
| |
| if (p_lstat(full_path, &st) < 0) |
| return git__throw(GIT_ENOTFOUND, "Failed to initialize entry. '%s' cannot be opened", full_path); |
| |
| if (stage < 0 || stage > 3) |
| return git__throw(GIT_ERROR, "Failed to initialize entry. Invalid stage %i", stage); |
| |
| /* write the blob to disk and get the oid */ |
| if ((error = git_blob_create_fromfile(&oid, index->repository, rel_path)) < GIT_SUCCESS) |
| return git__rethrow(error, "Failed to initialize index entry"); |
| |
| entry = git__malloc(sizeof(git_index_entry)); |
| if (!entry) |
| return GIT_ENOMEM; |
| memset(entry, 0x0, sizeof(git_index_entry)); |
| |
| 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 = index_create_mode(st.st_mode); |
| entry->uid = st.st_uid; |
| entry->gid = st.st_gid; |
| entry->file_size = st.st_size; |
| entry->oid = oid; |
| |
| entry->flags |= (stage << GIT_IDXENTRY_STAGESHIFT); |
| entry->path = git__strdup(rel_path); |
| if (entry->path == NULL) { |
| free(entry); |
| return GIT_ENOMEM; |
| } |
| |
| *entry_out = entry; |
| return GIT_SUCCESS; |
| } |
| |
| 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 void index_entry_free(git_index_entry *entry) |
| { |
| if (!entry) |
| return; |
| free(entry->path); |
| free(entry); |
| } |
| |
| static int index_insert(git_index *index, git_index_entry *entry, int replace) |
| { |
| size_t path_length; |
| int position; |
| git_index_entry **entry_array; |
| |
| assert(index && entry); |
| |
| if (entry->path == NULL) |
| return git__throw(GIT_EMISSINGOBJDATA, "Failed to insert into index. Entry has no path"); |
| |
| /* 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;; |
| |
| /* |
| * replacing is not requested: just insert entry at the end; |
| * the index is no longer sorted |
| */ |
| if (!replace) { |
| if (git_vector_insert(&index->entries, entry) < GIT_SUCCESS) |
| return GIT_ENOMEM; |
| |
| return GIT_SUCCESS; |
| } |
| |
| /* look if an entry with this path already exists */ |
| position = git_index_find(index, entry->path); |
| |
| /* |
| * if no entry exists add the entry at the end; |
| * the index is no longer sorted |
| */ |
| if (position == GIT_ENOTFOUND) { |
| if (git_vector_insert(&index->entries, entry) < GIT_SUCCESS) |
| return GIT_ENOMEM; |
| |
| return GIT_SUCCESS; |
| } |
| |
| /* exists, replace it */ |
| entry_array = (git_index_entry **) index->entries.contents; |
| free(entry_array[position]->path); |
| free(entry_array[position]); |
| entry_array[position] = entry; |
| |
| return GIT_SUCCESS; |
| } |
| |
| static int index_add(git_index *index, const char *path, int stage, int replace) |
| { |
| git_index_entry *entry = NULL; |
| int ret; |
| |
| ret = index_entry_init(&entry, index, path, stage); |
| if (ret) |
| goto err; |
| |
| ret = index_insert(index, entry, replace); |
| if (ret) |
| goto err; |
| |
| return ret; |
| err: |
| index_entry_free(entry); |
| return git__rethrow(ret, "Failed to append to index"); |
| } |
| |
| int git_index_add(git_index *index, const char *path, int stage) |
| { |
| return index_add(index, path, stage, 1); |
| } |
| |
| int git_index_append(git_index *index, const char *path, int stage) |
| { |
| return index_add(index, path, stage, 0); |
| } |
| |
| static int index_add2(git_index *index, const git_index_entry *source_entry, |
| int replace) |
| { |
| git_index_entry *entry = NULL; |
| int ret; |
| |
| entry = index_entry_dup(source_entry); |
| if (entry == NULL) { |
| ret = GIT_ENOMEM; |
| goto err; |
| } |
| |
| ret = index_insert(index, entry, replace); |
| if (ret) |
| goto err; |
| |
| return ret; |
| err: |
| index_entry_free(entry); |
| return git__rethrow(ret, "Failed to append to index"); |
| } |
| |
| int git_index_add2(git_index *index, const git_index_entry *source_entry) |
| { |
| return index_add2(index, source_entry, 1); |
| } |
| |
| int git_index_append2(git_index *index, const git_index_entry *source_entry) |
| { |
| return index_add2(index, source_entry, 1); |
| } |
| |
| int git_index_remove(git_index *index, int position) |
| { |
| git_vector_sort(&index->entries); |
| return git_vector_remove(&index->entries, (unsigned int)position); |
| } |
| |
| int git_index_find(git_index *index, const char *path) |
| { |
| return git_vector_bsearch2(&index->entries, index_srch, path); |
| } |
| |
| void git_index_uniq(git_index *index) |
| { |
| git_vector_uniq(&index->entries); |
| } |
| |
| const git_index_entry_unmerged *git_index_get_unmerged_bypath(git_index *index, const char *path) |
| { |
| int pos; |
| assert(index && path); |
| |
| if (!index->unmerged.length) |
| return NULL; |
| |
| if ((pos = git_vector_bsearch2(&index->unmerged, unmerged_srch, path)) < GIT_SUCCESS) |
| return NULL; |
| |
| return git_vector_get(&index->unmerged, pos); |
| } |
| |
| const git_index_entry_unmerged *git_index_get_unmerged_byindex(git_index *index, unsigned int n) |
| { |
| assert(index); |
| return git_vector_get(&index->unmerged, n); |
| } |
| |
| |
| static int read_tree_internal(git_index_tree **out, |
| const char **buffer_in, const char *buffer_end, git_index_tree *parent) |
| { |
| git_index_tree *tree; |
| const char *name_start, *buffer; |
| long count; |
| int error = GIT_SUCCESS; |
| |
| if ((tree = git__malloc(sizeof(git_index_tree))) == NULL) |
| return GIT_ENOMEM; |
| |
| memset(tree, 0x0, sizeof(git_index_tree)); |
| tree->parent = parent; |
| |
| buffer = name_start = *buffer_in; |
| |
| if ((buffer = memchr(buffer, '\0', buffer_end - buffer)) == NULL) { |
| error = GIT_EOBJCORRUPTED; |
| goto cleanup; |
| } |
| |
| /* NUL-terminated tree name */ |
| tree->name = git__strdup(name_start); |
| if (tree->name == NULL) { |
| error = GIT_ENOMEM; |
| goto cleanup; |
| } |
| |
| if (++buffer >= buffer_end) { |
| error = GIT_EOBJCORRUPTED; |
| goto cleanup; |
| } |
| |
| /* Blank-terminated ASCII decimal number of entries in this tree */ |
| if (git__strtol32(&count, buffer, &buffer, 10) < GIT_SUCCESS || count < -1) { |
| error = GIT_EOBJCORRUPTED; |
| goto cleanup; |
| } |
| |
| /* Invalidated TREE. Free the tree but report success */ |
| if (count == -1) { |
| /* FIXME: return buffer_end or the end position for |
| * this single tree entry */ |
| *buffer_in = buffer_end; |
| *out = NULL; |
| free_tree(tree); /* Needs to be done manually */ |
| return GIT_SUCCESS; |
| } |
| |
| tree->entries = count; |
| |
| if (*buffer != ' ' || ++buffer >= buffer_end) { |
| error = GIT_EOBJCORRUPTED; |
| goto cleanup; |
| } |
| |
| /* Number of children of the tree, newline-terminated */ |
| if (git__strtol32(&count, buffer, &buffer, 10) < GIT_SUCCESS || |
| count < 0) { |
| error = GIT_EOBJCORRUPTED; |
| goto cleanup; |
| } |
| |
| tree->children_count = count; |
| |
| if (*buffer != '\n' || ++buffer >= buffer_end) { |
| error = GIT_EOBJCORRUPTED; |
| goto cleanup; |
| } |
| |
| /* 160-bit SHA-1 for this tree and it's children */ |
| if (buffer + GIT_OID_RAWSZ > buffer_end) { |
| error = GIT_EOBJCORRUPTED; |
| goto cleanup; |
| } |
| |
| git_oid_fromraw(&tree->oid, (const unsigned char *)buffer); |
| buffer += GIT_OID_RAWSZ; |
| |
| /* Parse children: */ |
| if (tree->children_count > 0) { |
| unsigned int i; |
| int err; |
| |
| tree->children = git__malloc(tree->children_count * sizeof(git_index_tree *)); |
| if (tree->children == NULL) |
| goto cleanup; |
| |
| for (i = 0; i < tree->children_count; ++i) { |
| err = read_tree_internal(&tree->children[i], &buffer, buffer_end, tree); |
| |
| if (err < GIT_SUCCESS) |
| goto cleanup; |
| } |
| } |
| |
| *buffer_in = buffer; |
| *out = tree; |
| return GIT_SUCCESS; |
| |
| cleanup: |
| free_tree(tree); |
| return error; |
| } |
| |
| static int read_tree(git_index *index, const char *buffer, size_t buffer_size) |
| { |
| const char *buffer_end = buffer + buffer_size; |
| int error; |
| |
| error = read_tree_internal(&index->tree, &buffer, buffer_end, NULL); |
| |
| if (buffer < buffer_end) |
| return GIT_EOBJCORRUPTED; |
| |
| return error; |
| } |
| |
| static int read_unmerged(git_index *index, const char *buffer, size_t size) |
| { |
| const char *endptr; |
| size_t len; |
| int i; |
| |
| git_vector_init(&index->unmerged, 16, unmerged_cmp); |
| |
| while (size) { |
| git_index_entry_unmerged *lost; |
| |
| len = strlen(buffer) + 1; |
| if (size <= len) |
| return git__throw(GIT_ERROR, "Failed to read unmerged entries"); |
| |
| if ((lost = git__malloc(sizeof(git_index_entry_unmerged))) == NULL) |
| return GIT_ENOMEM; |
| |
| if (git_vector_insert(&index->unmerged, lost) < GIT_SUCCESS) |
| return git__throw(GIT_ERROR, "Failed to read unmerged entries"); |
| |
| lost->path = git__strdup(buffer); |
| if (!lost->path) |
| return GIT_ENOMEM; |
| |
| size -= len; |
| buffer += len; |
| |
| for (i = 0; i < 3; i++) { |
| long tmp; |
| |
| if (git__strtol32(&tmp, buffer, &endptr, 8) < GIT_SUCCESS || |
| !endptr || endptr == buffer || *endptr || tmp > UINT_MAX) |
| return GIT_ERROR; |
| |
| lost->mode[i] = tmp; |
| |
| len = (endptr + 1) - buffer; |
| if (size <= len) |
| return git__throw(GIT_ERROR, "Failed to read unmerged entries"); |
| |
| size -= len; |
| buffer += len; |
| } |
| |
| for (i = 0; i < 3; i++) { |
| if (!lost->mode[i]) |
| continue; |
| if (size < 20) |
| return git__throw(GIT_ERROR, "Failed to read unmerged entries"); |
| git_oid_fromraw(&lost->oid[i], (const unsigned char *) buffer); |
| size -= 20; |
| buffer += 20; |
| } |
| } |
| |
| return GIT_SUCCESS; |
| } |
| |
| static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffer_size) |
| { |
| size_t path_length, entry_size; |
| uint16_t flags_raw; |
| const char *path_ptr; |
| const struct entry_short *source = buffer; |
| |
| if (INDEX_FOOTER_SIZE + minimal_entry_size > buffer_size) |
| return 0; |
| |
| memset(dest, 0x0, sizeof(git_index_entry)); |
| |
| dest->ctime.seconds = (git_time_t)ntohl(source->ctime.seconds); |
| dest->ctime.nanoseconds = ntohl(source->ctime.nanoseconds); |
| dest->mtime.seconds = (git_time_t)ntohl(source->mtime.seconds); |
| dest->mtime.nanoseconds = ntohl(source->mtime.nanoseconds); |
| dest->dev = ntohl(source->dev); |
| dest->ino = ntohl(source->ino); |
| dest->mode = ntohl(source->mode); |
| dest->uid = ntohl(source->uid); |
| dest->gid = ntohl(source->gid); |
| dest->file_size = ntohl(source->file_size); |
| git_oid_cpy(&dest->oid, &source->oid); |
| dest->flags = ntohs(source->flags); |
| |
| if (dest->flags & GIT_IDXENTRY_EXTENDED) { |
| const struct entry_long *source_l = (const struct entry_long *)source; |
| path_ptr = source_l->path; |
| |
| flags_raw = ntohs(source_l->flags_extended); |
| memcpy(&dest->flags_extended, &flags_raw, 2); |
| } else |
| path_ptr = source->path; |
| |
| path_length = dest->flags & GIT_IDXENTRY_NAMEMASK; |
| |
| /* if this is a very long string, we must find its |
| * real length without overflowing */ |
| if (path_length == 0xFFF) { |
| const char *path_end; |
| |
| path_end = memchr(path_ptr, '\0', buffer_size); |
| if (path_end == NULL) |
| return 0; |
| |
| path_length = path_end - path_ptr; |
| } |
| |
| if (dest->flags & GIT_IDXENTRY_EXTENDED) |
| entry_size = long_entry_size(path_length); |
| else |
| entry_size = short_entry_size(path_length); |
| |
| if (INDEX_FOOTER_SIZE + entry_size > buffer_size) |
| return 0; |
| |
| dest->path = git__strdup(path_ptr); |
| assert(dest->path); |
| |
| return entry_size; |
| } |
| |
| static int read_header(struct index_header *dest, const void *buffer) |
| { |
| const struct index_header *source = buffer; |
| |
| dest->signature = ntohl(source->signature); |
| if (dest->signature != INDEX_HEADER_SIG) |
| return GIT_EOBJCORRUPTED; |
| |
| dest->version = ntohl(source->version); |
| if (dest->version != INDEX_VERSION_NUMBER_EXT && |
| dest->version != INDEX_VERSION_NUMBER) |
| return GIT_EOBJCORRUPTED; |
| |
| dest->entry_count = ntohl(source->entry_count); |
| return GIT_SUCCESS; |
| } |
| |
| static size_t read_extension(git_index *index, const char *buffer, size_t buffer_size) |
| { |
| const struct index_extension *source; |
| struct index_extension dest; |
| size_t total_size; |
| |
| source = (const struct index_extension *)(buffer); |
| |
| memcpy(dest.signature, source->signature, 4); |
| dest.extension_size = ntohl(source->extension_size); |
| |
| total_size = dest.extension_size + sizeof(struct index_extension); |
| |
| if (buffer_size - total_size < INDEX_FOOTER_SIZE) |
| return 0; |
| |
| /* optional extension */ |
| if (dest.signature[0] >= 'A' && dest.signature[0] <= 'Z') { |
| /* tree cache */ |
| if (memcmp(dest.signature, INDEX_EXT_TREECACHE_SIG, 4) == 0) { |
| if (read_tree(index, buffer + 8, dest.extension_size) < GIT_SUCCESS) |
| return 0; |
| } else if (memcmp(dest.signature, INDEX_EXT_UNMERGED_SIG, 4) == 0) { |
| if (read_unmerged(index, buffer + 8, dest.extension_size) < GIT_SUCCESS) |
| return 0; |
| } |
| /* else, unsupported extension. We cannot parse this, but we can skip |
| * it by returning `total_size */ |
| } else { |
| /* we cannot handle non-ignorable extensions; |
| * in fact they aren't even defined in the standard */ |
| return 0; |
| } |
| |
| return total_size; |
| } |
| |
| static int parse_index(git_index *index, const char *buffer, size_t buffer_size) |
| { |
| unsigned int i; |
| struct index_header header; |
| git_oid checksum_calculated, checksum_expected; |
| |
| #define seek_forward(_increase) { \ |
| if (_increase >= buffer_size) \ |
| return git__throw(GIT_EOBJCORRUPTED, "Failed to seek forward. Buffer size exceeded"); \ |
| buffer += _increase; \ |
| buffer_size -= _increase;\ |
| } |
| |
| if (buffer_size < INDEX_HEADER_SIZE + INDEX_FOOTER_SIZE) |
| return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Buffer too small"); |
| |
| /* Precalculate the SHA1 of the files's contents -- we'll match it to |
| * the provided SHA1 in the footer */ |
| git_hash_buf(&checksum_calculated, buffer, buffer_size - INDEX_FOOTER_SIZE); |
| |
| /* Parse header */ |
| if (read_header(&header, buffer) < GIT_SUCCESS) |
| return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Header is corrupted"); |
| |
| seek_forward(INDEX_HEADER_SIZE); |
| |
| git_vector_clear(&index->entries); |
| |
| /* Parse all the entries */ |
| for (i = 0; i < header.entry_count && buffer_size > INDEX_FOOTER_SIZE; ++i) { |
| size_t entry_size; |
| git_index_entry *entry; |
| |
| entry = git__malloc(sizeof(git_index_entry)); |
| if (entry == NULL) |
| return GIT_ENOMEM; |
| |
| entry_size = read_entry(entry, buffer, buffer_size); |
| |
| /* 0 bytes read means an object corruption */ |
| if (entry_size == 0) |
| return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Entry size is zero"); |
| |
| if (git_vector_insert(&index->entries, entry) < GIT_SUCCESS) |
| return GIT_ENOMEM; |
| |
| seek_forward(entry_size); |
| } |
| |
| if (i != header.entry_count) |
| return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Header entries changed while parsing"); |
| |
| /* There's still space for some extensions! */ |
| while (buffer_size > INDEX_FOOTER_SIZE) { |
| size_t extension_size; |
| |
| extension_size = read_extension(index, buffer, buffer_size); |
| |
| /* see if we have read any bytes from the extension */ |
| if (extension_size == 0) |
| return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Extension size is zero"); |
| |
| seek_forward(extension_size); |
| } |
| |
| if (buffer_size != INDEX_FOOTER_SIZE) |
| return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Buffer size does not match index footer size"); |
| |
| /* 160-bit SHA-1 over the content of the index file before this checksum. */ |
| git_oid_fromraw(&checksum_expected, (const unsigned char *)buffer); |
| |
| if (git_oid_cmp(&checksum_calculated, &checksum_expected) != 0) |
| return git__throw(GIT_EOBJCORRUPTED, "Failed to parse index. Calculated checksum does not match expected checksum"); |
| |
| #undef seek_forward |
| |
| /* force sorting in the vector: the entries are |
| * assured to be sorted on the index */ |
| index->entries.sorted = 1; |
| return GIT_SUCCESS; |
| } |
| |
| static int is_index_extended(git_index *index) |
| { |
| unsigned int i, extended; |
| |
| extended = 0; |
| |
| for (i = 0; i < index->entries.length; ++i) { |
| git_index_entry *entry; |
| entry = git_vector_get(&index->entries, i); |
| entry->flags &= ~GIT_IDXENTRY_EXTENDED; |
| if (entry->flags_extended & GIT_IDXENTRY_EXTENDED_FLAGS) { |
| extended++; |
| entry->flags |= GIT_IDXENTRY_EXTENDED; |
| } |
| } |
| return extended; |
| } |
| |
| static int write_disk_entry(git_filebuf *file, git_index_entry *entry) |
| { |
| struct entry_short *ondisk; |
| size_t path_len, disk_size; |
| char *path; |
| |
| path_len = strlen(entry->path); |
| |
| if (entry->flags & GIT_IDXENTRY_EXTENDED) |
| disk_size = long_entry_size(path_len); |
| else |
| disk_size = short_entry_size(path_len); |
| |
| if (git_filebuf_reserve(file, (void **)&ondisk, disk_size) < GIT_SUCCESS) |
| return GIT_ENOMEM; |
| |
| memset(ondisk, 0x0, disk_size); |
| |
| /** |
| * Yes, we have to truncate. |
| * |
| * The on-disk format for Index entries clearly defines |
| * the time and size fields to be 4 bytes each -- so even if |
| * we store these values with 8 bytes on-memory, they must |
| * be truncated to 4 bytes before writing to disk. |
| * |
| * In 2038 I will be either too dead or too rich to care about this |
| */ |
| ondisk->ctime.seconds = htonl((uint32_t)entry->ctime.seconds); |
| ondisk->mtime.seconds = htonl((uint32_t)entry->mtime.seconds); |
| ondisk->ctime.nanoseconds = htonl(entry->ctime.nanoseconds); |
| ondisk->mtime.nanoseconds = htonl(entry->mtime.nanoseconds); |
| ondisk->dev = htonl(entry->dev); |
| ondisk->ino = htonl(entry->ino); |
| ondisk->mode = htonl(entry->mode); |
| ondisk->uid = htonl(entry->uid); |
| ondisk->gid = htonl(entry->gid); |
| ondisk->file_size = htonl((uint32_t)entry->file_size); |
| |
| git_oid_cpy(&ondisk->oid, &entry->oid); |
| |
| ondisk->flags = htons(entry->flags); |
| |
| if (entry->flags & GIT_IDXENTRY_EXTENDED) { |
| struct entry_long *ondisk_ext; |
| ondisk_ext = (struct entry_long *)ondisk; |
| ondisk_ext->flags_extended = htons(entry->flags_extended); |
| path = ondisk_ext->path; |
| } |
| else |
| path = ondisk->path; |
| |
| memcpy(path, entry->path, path_len); |
| |
| return GIT_SUCCESS; |
| } |
| |
| static int write_entries(git_index *index, git_filebuf *file) |
| { |
| unsigned int i; |
| |
| for (i = 0; i < index->entries.length; ++i) { |
| git_index_entry *entry; |
| entry = git_vector_get(&index->entries, i); |
| if (write_disk_entry(file, entry) < GIT_SUCCESS) |
| return GIT_ENOMEM; |
| } |
| |
| return GIT_SUCCESS; |
| } |
| |
| static int write_index(git_index *index, git_filebuf *file) |
| { |
| int error = GIT_SUCCESS; |
| git_oid hash_final; |
| |
| struct index_header header; |
| |
| int is_extended; |
| |
| assert(index && file); |
| |
| is_extended = is_index_extended(index); |
| |
| header.signature = htonl(INDEX_HEADER_SIG); |
| header.version = htonl(is_extended ? INDEX_VERSION_NUMBER_EXT : INDEX_VERSION_NUMBER); |
| header.entry_count = htonl(index->entries.length); |
| |
| git_filebuf_write(file, &header, sizeof(struct index_header)); |
| |
| error = write_entries(index, file); |
| if (error < GIT_SUCCESS) |
| return git__rethrow(error, "Failed to write index"); |
| |
| /* TODO: write extensions (tree cache) */ |
| |
| /* get out the hash for all the contents we've appended to the file */ |
| git_filebuf_hash(&hash_final, file); |
| |
| /* write it at the end of the file */ |
| git_filebuf_write(file, hash_final.id, GIT_OID_RAWSZ); |
| |
| return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write index"); |
| } |
| |
| int git_index_entry_stage(const git_index_entry *entry) |
| { |
| return (entry->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT; |
| } |