diff options
Diffstat (limited to 'src/refs.c')
| -rw-r--r-- | src/refs.c | 1191 |
1 files changed, 581 insertions, 610 deletions
diff --git a/src/refs.c b/src/refs.c index f3388bf53..28e8f786b 100644 --- a/src/refs.c +++ b/src/refs.c @@ -15,7 +15,10 @@ #include <git2/tag.h> #include <git2/object.h> -#define MAX_NESTING_LEVEL 5 +GIT__USE_STRMAP; + +#define DEFAULT_NESTING_LEVEL 5 +#define MAX_NESTING_LEVEL 10 enum { GIT_PACKREF_HAS_PEEL = 1, @@ -29,8 +32,6 @@ struct packref { char name[GIT_FLEX_ARRAY]; }; -static const int default_table_size = 32; - static int reference_read( git_buf *file_content, time_t *mtime, @@ -61,7 +62,7 @@ static int packed_lookup(git_reference *ref); static int packed_write(git_repository *repo); /* internal helpers */ -static int reference_available(git_repository *repo, +static int reference_path_available(git_repository *repo, const char *ref, const char *old_ref); static int reference_delete(git_reference *ref); static int reference_lookup(git_reference *ref); @@ -97,98 +98,100 @@ static int reference_alloc( assert(ref_out && repo && name); reference = git__malloc(sizeof(git_reference)); - if (reference == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(reference); memset(reference, 0x0, sizeof(git_reference)); reference->owner = repo; reference->name = git__strdup(name); - if (reference->name == NULL) { - git__free(reference); - return GIT_ENOMEM; - } + GITERR_CHECK_ALLOC(reference->name); *ref_out = reference; - return GIT_SUCCESS; + return 0; } -static int reference_read(git_buf *file_content, time_t *mtime, const char *repo_path, const char *ref_name, int *updated) +static int reference_read( + git_buf *file_content, + time_t *mtime, + const char *repo_path, + const char *ref_name, + int *updated) { git_buf path = GIT_BUF_INIT; - int error = GIT_SUCCESS; + int result; assert(file_content && repo_path && ref_name); /* Determine the full path of the file */ - if ((error = git_buf_joinpath(&path, repo_path, ref_name)) == GIT_SUCCESS) - error = git_futils_readbuffer_updated(file_content, path.ptr, mtime, updated); + if (git_buf_joinpath(&path, repo_path, ref_name) < 0) + return -1; + result = git_futils_readbuffer_updated(file_content, path.ptr, mtime, updated); git_buf_free(&path); - - return error; + return result; } static int loose_parse_symbolic(git_reference *ref, git_buf *file_content) { - const unsigned int header_len = strlen(GIT_SYMREF); + const unsigned int header_len = (unsigned int)strlen(GIT_SYMREF); const char *refname_start; char *eol; refname_start = (const char *)file_content->ptr; - if (file_content->size < (header_len + 1)) - return git__throw(GIT_EOBJCORRUPTED, - "Failed to parse loose reference. Object too short"); + if (git_buf_len(file_content) < header_len + 1) + goto corrupt; /* * Assume we have already checked for the header * before calling this function */ - refname_start += header_len; ref->target.symbolic = git__strdup(refname_start); - if (ref->target.symbolic == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(ref->target.symbolic); /* remove newline at the end of file */ eol = strchr(ref->target.symbolic, '\n'); if (eol == NULL) - return git__throw(GIT_EOBJCORRUPTED, - "Failed to parse loose reference. Missing EOL"); + goto corrupt; *eol = '\0'; if (eol[-1] == '\r') eol[-1] = '\0'; - return GIT_SUCCESS; + return 0; + +corrupt: + giterr_set(GITERR_REFERENCE, "Corrupted loose reference file"); + return -1; } static int loose_parse_oid(git_oid *oid, git_buf *file_content) { - int error; char *buffer; buffer = (char *)file_content->ptr; /* File format: 40 chars (OID) + newline */ - if (file_content->size < GIT_OID_HEXSZ + 1) - return git__throw(GIT_EOBJCORRUPTED, - "Failed to parse loose reference. Reference too short"); + if (git_buf_len(file_content) < GIT_OID_HEXSZ + 1) + goto corrupt; - if ((error = git_oid_fromstr(oid, buffer)) < GIT_SUCCESS) - return git__rethrow(GIT_EOBJCORRUPTED, "Failed to parse loose reference."); + if (git_oid_fromstr(oid, buffer) < 0) + goto corrupt; buffer = buffer + GIT_OID_HEXSZ; if (*buffer == '\r') buffer++; if (*buffer != '\n') - return git__throw(GIT_EOBJCORRUPTED, - "Failed to parse loose reference. Missing EOL"); + goto corrupt; - return GIT_SUCCESS; + return 0; + +corrupt: + giterr_set(GITERR_REFERENCE, "Corrupted loose reference file"); + return -1; } static git_rtype loose_guess_rtype(const git_buf *full_path) @@ -198,7 +201,7 @@ static git_rtype loose_guess_rtype(const git_buf *full_path) type = GIT_REF_INVALID; - if (git_futils_readbuffer(&ref_file, full_path->ptr) == GIT_SUCCESS) { + if (git_futils_readbuffer(&ref_file, full_path->ptr) == 0) { if (git__prefixcmp((const char *)(ref_file.ptr), GIT_SYMREF) == 0) type = GIT_REF_SYMBOLIC; else @@ -211,15 +214,17 @@ static git_rtype loose_guess_rtype(const git_buf *full_path) static int loose_lookup(git_reference *ref) { - int error = GIT_SUCCESS, updated; + int result, updated; git_buf ref_file = GIT_BUF_INIT; - if (reference_read(&ref_file, &ref->mtime, - ref->owner->path_repository, ref->name, &updated) < GIT_SUCCESS) - return git__throw(GIT_ENOTFOUND, "Failed to lookup loose reference"); + result = reference_read(&ref_file, &ref->mtime, + ref->owner->path_repository, ref->name, &updated); + + if (result < 0) + return result; if (!updated) - return GIT_SUCCESS; + return 0; if (ref->flags & GIT_REF_SYMBOLIC) { git__free(ref->target.symbolic); @@ -230,18 +235,14 @@ static int loose_lookup(git_reference *ref) if (git__prefixcmp((const char *)(ref_file.ptr), GIT_SYMREF) == 0) { ref->flags |= GIT_REF_SYMBOLIC; - error = loose_parse_symbolic(ref, &ref_file); + result = loose_parse_symbolic(ref, &ref_file); } else { ref->flags |= GIT_REF_OID; - error = loose_parse_oid(&ref->target.oid, &ref_file); + result = loose_parse_oid(&ref->target.oid, &ref_file); } git_buf_free(&ref_file); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup loose reference"); - - return GIT_SUCCESS; + return result; } static int loose_lookup_to_packfile( @@ -249,54 +250,59 @@ static int loose_lookup_to_packfile( git_repository *repo, const char *name) { - int error = GIT_SUCCESS; git_buf ref_file = GIT_BUF_INIT; struct packref *ref = NULL; size_t name_len; *ref_out = NULL; - error = reference_read(&ref_file, NULL, repo->path_repository, name, NULL); - if (error < GIT_SUCCESS) - goto cleanup; + if (reference_read(&ref_file, NULL, repo->path_repository, name, NULL) < 0) + return -1; name_len = strlen(name); ref = git__malloc(sizeof(struct packref) + name_len + 1); + GITERR_CHECK_ALLOC(ref); memcpy(ref->name, name, name_len); ref->name[name_len] = 0; - error = loose_parse_oid(&ref->oid, &ref_file); - if (error < GIT_SUCCESS) - goto cleanup; + if (loose_parse_oid(&ref->oid, &ref_file) < 0) { + git_buf_free(&ref_file); + git__free(ref); + return -1; + } ref->flags = GIT_PACKREF_WAS_LOOSE; *ref_out = ref; git_buf_free(&ref_file); - return GIT_SUCCESS; - -cleanup: - git_buf_free(&ref_file); - git__free(ref); - - return git__rethrow(error, "Failed to lookup loose reference"); + return 0; } static int loose_write(git_reference *ref) { git_filebuf file = GIT_FILEBUF_INIT; git_buf ref_path = GIT_BUF_INIT; - int error; struct stat st; - error = git_buf_joinpath(&ref_path, ref->owner->path_repository, ref->name); - if (error < GIT_SUCCESS) - goto unlock; + if (git_buf_joinpath(&ref_path, ref->owner->path_repository, ref->name) < 0) + return -1; + + /* Remove a possibly existing empty directory hierarchy + * which name would collide with the reference name + */ + if (git_path_isdir(git_buf_cstr(&ref_path)) && + (git_futils_rmdir_r(git_buf_cstr(&ref_path), GIT_DIRREMOVAL_ONLY_EMPTY_DIRS) < 0)) { + git_buf_free(&ref_path); + return -1; + } + + if (git_filebuf_open(&file, ref_path.ptr, GIT_FILEBUF_FORCE) < 0) { + git_buf_free(&ref_path); + return -1; + } - error = git_filebuf_open(&file, ref_path.ptr, GIT_FILEBUF_FORCE); - if (error < GIT_SUCCESS) - goto unlock; + git_buf_free(&ref_path); if (ref->flags & GIT_REF_OID) { char oid[GIT_OID_HEXSZ + 1]; @@ -304,29 +310,18 @@ static int loose_write(git_reference *ref) git_oid_fmt(oid, &ref->target.oid); oid[GIT_OID_HEXSZ] = '\0'; - error = git_filebuf_printf(&file, "%s\n", oid); - if (error < GIT_SUCCESS) - goto unlock; + git_filebuf_printf(&file, "%s\n", oid); - } else if (ref->flags & GIT_REF_SYMBOLIC) { /* GIT_REF_SYMBOLIC */ - error = git_filebuf_printf(&file, GIT_SYMREF "%s\n", ref->target.symbolic); + } else if (ref->flags & GIT_REF_SYMBOLIC) { + git_filebuf_printf(&file, GIT_SYMREF "%s\n", ref->target.symbolic); } else { - error = git__throw(GIT_EOBJCORRUPTED, - "Failed to write reference. Invalid reference type"); - goto unlock; + assert(0); /* don't let this happen */ } - if (p_stat(ref_path.ptr, &st) == GIT_SUCCESS) + if (p_stat(ref_path.ptr, &st) == 0) ref->mtime = st.st_mtime; - git_buf_free(&ref_path); - return git_filebuf_commit(&file, GIT_REFS_FILE_MODE); - -unlock: - git_buf_free(&ref_path); - git_filebuf_cleanup(&file); - return git__rethrow(error, "Failed to write loose reference"); } static int packed_parse_peel( @@ -340,34 +335,32 @@ static int packed_parse_peel( /* Ensure it's not the first entry of the file */ if (tag_ref == NULL) - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. " - "Reference is the first entry of the file"); + goto corrupt; /* Ensure reference is a tag */ if (git__prefixcmp(tag_ref->name, GIT_REFS_TAGS_DIR) != 0) - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. Reference is not a tag"); + goto corrupt; if (buffer + GIT_OID_HEXSZ >= buffer_end) - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. Buffer too small"); + goto corrupt; /* Is this a valid object id? */ - if (git_oid_fromstr(&tag_ref->peel, buffer) < GIT_SUCCESS) - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. Not a valid object ID"); + if (git_oid_fromstr(&tag_ref->peel, buffer) < 0) + goto corrupt; buffer = buffer + GIT_OID_HEXSZ; if (*buffer == '\r') buffer++; if (*buffer != '\n') - return git__throw(GIT_EPACKEDREFSCORRUPTED, - "Failed to parse packed reference. Buffer not terminated correctly"); + goto corrupt; *buffer_out = buffer + 1; - return GIT_SUCCESS; + return 0; + +corrupt: + giterr_set(GITERR_REFERENCE, "The packed references file is corrupted"); + return -1; } static int packed_parse_oid( @@ -380,26 +373,20 @@ static int packed_parse_oid( const char *buffer = *buffer_out; const char *refname_begin, *refname_end; - int error = GIT_SUCCESS; size_t refname_len; git_oid id; refname_begin = (buffer + GIT_OID_HEXSZ + 1); - if (refname_begin >= buffer_end || - refname_begin[-1] != ' ') { - error = GIT_EPACKEDREFSCORRUPTED; - goto cleanup; - } + if (refname_begin >= buffer_end || refname_begin[-1] != ' ') + goto corrupt; /* Is this a valid object id? */ - if ((error = git_oid_fromstr(&id, buffer)) < GIT_SUCCESS) - goto cleanup; + if (git_oid_fromstr(&id, buffer) < 0) + goto corrupt; refname_end = memchr(refname_begin, '\n', buffer_end - refname_begin); - if (refname_end == NULL) { - error = GIT_EPACKEDREFSCORRUPTED; - goto cleanup; - } + if (refname_end == NULL) + goto corrupt; if (refname_end[-1] == '\r') refname_end--; @@ -407,6 +394,7 @@ static int packed_parse_oid( refname_len = refname_end - refname_begin; ref = git__malloc(sizeof(struct packref) + refname_len + 1); + GITERR_CHECK_ALLOC(ref); memcpy(ref->name, refname_begin, refname_len); ref->name[refname_len] = 0; @@ -418,32 +406,28 @@ static int packed_parse_oid( *ref_out = ref; *buffer_out = refname_end + 1; - return GIT_SUCCESS; + return 0; -cleanup: +corrupt: git__free(ref); - return git__rethrow(error, "Failed to parse OID of packed reference"); + giterr_set(GITERR_REFERENCE, "The packed references file is corrupted"); + return -1; } static int packed_load(git_repository *repo) { - int error = GIT_SUCCESS, updated; + int result, updated; git_buf packfile = GIT_BUF_INIT; const char *buffer_start, *buffer_end; git_refcache *ref_cache = &repo->references; /* First we make sure we have allocated the hash table */ if (ref_cache->packfile == NULL) { - ref_cache->packfile = git_hashtable_alloc( - default_table_size, git_hash__strhash_cb, git_hash__strcmp_cb); - - if (ref_cache->packfile == NULL) { - error = GIT_ENOMEM; - goto cleanup; - } + ref_cache->packfile = git_strmap_alloc(); + GITERR_CHECK_ALLOC(ref_cache->packfile); } - error = reference_read(&packfile, &ref_cache->packfile_time, + result = reference_read(&packfile, &ref_cache->packfile_time, repo->path_repository, GIT_PACKEDREFS_FILE, &updated); /* @@ -453,62 +437,59 @@ static int packed_load(git_repository *repo) * for us here, so just return. Anything else means we need to * refresh the packed refs. */ - if (error == GIT_ENOTFOUND) { - git_hashtable_clear(ref_cache->packfile); - return GIT_SUCCESS; - } else if (error < GIT_SUCCESS) { - return git__rethrow(error, "Failed to read packed refs"); - } else if (!updated) { - return GIT_SUCCESS; + if (result == GIT_ENOTFOUND) { + git_strmap_clear(ref_cache->packfile); + return 0; } + if (result < 0) + return -1; + + if (!updated) + return 0; + /* * At this point, we want to refresh the packed refs. We already * have the contents in our buffer. */ - - git_hashtable_clear(ref_cache->packfile); + git_strmap_clear(ref_cache->packfile); buffer_start = (const char *)packfile.ptr; buffer_end = (const char *)(buffer_start) + packfile.size; while (buffer_start < buffer_end && buffer_start[0] == '#') { buffer_start = strchr(buffer_start, '\n'); - if (buffer_start == NULL) { - error = GIT_EPACKEDREFSCORRUPTED; - goto cleanup; - } + if (buffer_start == NULL) + goto parse_failed; + buffer_start++; } while (buffer_start < buffer_end) { + int err; struct packref *ref = NULL; - error = packed_parse_oid(&ref, &buffer_start, buffer_end); - if (error < GIT_SUCCESS) - goto cleanup; + if (packed_parse_oid(&ref, &buffer_start, buffer_end) < 0) + goto parse_failed; if (buffer_start[0] == '^') { - error = packed_parse_peel(ref, &buffer_start, buffer_end); - if (error < GIT_SUCCESS) - goto cleanup; + if (packed_parse_peel(ref, &buffer_start, buffer_end) < 0) + goto parse_failed; } - error = git_hashtable_insert(ref_cache->packfile, ref->name, ref); - if (error < GIT_SUCCESS) { - git__free(ref); - goto cleanup; - } + git_strmap_insert(ref_cache->packfile, ref->name, ref, err); + if (err < 0) + goto parse_failed; } git_buf_free(&packfile); - return GIT_SUCCESS; + return 0; -cleanup: - git_hashtable_free(ref_cache->packfile); +parse_failed: + git_strmap_free(ref_cache->packfile); ref_cache->packfile = NULL; git_buf_free(&packfile); - return git__rethrow(error, "Failed to load packed references"); + return -1; } @@ -526,17 +507,17 @@ static int _dirent_loose_listall(void *_data, git_buf *full_path) struct dirent_list_data *data = (struct dirent_list_data *)_data; const char *file_path = full_path->ptr + data->repo_path_len; - if (git_path_isdir(full_path->ptr) == GIT_SUCCESS) + if (git_path_isdir(full_path->ptr) == true) return git_path_direach(full_path, _dirent_loose_listall, _data); /* do not add twice a reference that exists already in the packfile */ if ((data->list_flags & GIT_REF_PACKED) != 0 && - git_hashtable_lookup(data->repo->references.packfile, file_path) != NULL) - return GIT_SUCCESS; + git_strmap_exists(data->repo->references.packfile, file_path)) + return 0; if (data->list_flags != GIT_REF_LISTALL) { if ((data->list_flags & loose_guess_rtype(full_path)) == 0) - return GIT_SUCCESS; /* we are filtering out this reference */ + return 0; /* we are filtering out this reference */ } return data->callback(file_path, data->callback_payload); @@ -548,30 +529,25 @@ static int _dirent_loose_load(void *data, git_buf *full_path) void *old_ref = NULL; struct packref *ref; const char *file_path; - int error; + int err; - if (git_path_isdir(full_path->ptr) == GIT_SUCCESS) + if (git_path_isdir(full_path->ptr) == true) return git_path_direach(full_path, _dirent_loose_load, repository); file_path = full_path->ptr + strlen(repository->path_repository); - error = loose_lookup_to_packfile(&ref, repository, file_path); - if (error == GIT_SUCCESS) { + if (loose_lookup_to_packfile(&ref, repository, file_path) < 0) + return -1; - if (git_hashtable_insert2( - repository->references.packfile, - ref->name, ref, &old_ref) < GIT_SUCCESS) { - git__free(ref); - return GIT_ENOMEM; - } - - if (old_ref != NULL) - git__free(old_ref); + git_strmap_insert2( + repository->references.packfile, ref->name, ref, old_ref, err); + if (err < 0) { + git__free(ref); + return -1; } - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to load loose references into packfile"); + git__free(old_ref); + return 0; } /* @@ -582,24 +558,24 @@ static int _dirent_loose_load(void *data, git_buf *full_path) */ static int packed_loadloose(git_repository *repository) { - int error = GIT_SUCCESS; git_buf refs_path = GIT_BUF_INIT; + int result; /* the packfile must have been previously loaded! */ assert(repository->references.packfile); - if ((error = git_buf_joinpath(&refs_path, - repository->path_repository, GIT_REFS_DIR)) < GIT_SUCCESS) - return error; + if (git_buf_joinpath(&refs_path, repository->path_repository, GIT_REFS_DIR) < 0) + return -1; /* * Load all the loose files from disk into the Packfile table. * This will overwrite any old packed entries with their * updated loose versions */ - error = git_path_direach(&refs_path, _dirent_loose_load, repository); + result = git_path_direach(&refs_path, _dirent_loose_load, repository); git_buf_free(&refs_path); - return error; + + return result; } /* @@ -607,7 +583,6 @@ static int packed_loadloose(git_repository *repository) */ static int packed_write_ref(struct packref *ref, git_filebuf *file) { - int error; char oid[GIT_OID_HEXSZ + 1]; git_oid_fmt(oid, &ref->oid); @@ -628,14 +603,14 @@ static int packed_write_ref(struct packref *ref, git_filebuf *file) git_oid_fmt(peel, &ref->peel); peel[GIT_OID_HEXSZ] = 0; - error = git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel); + if (git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel) < 0) + return -1; } else { - error = git_filebuf_printf(file, "%s %s\n", oid, ref->name); + if (git_filebuf_printf(file, "%s %s\n", oid, ref->name) < 0) + return -1; } - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to write packed reference"); + return 0; } /* @@ -649,24 +624,22 @@ static int packed_write_ref(struct packref *ref, git_filebuf *file) static int packed_find_peel(git_repository *repo, struct packref *ref) { git_object *object; - int error; if (ref->flags & GIT_PACKREF_HAS_PEEL) - return GIT_SUCCESS; + return 0; /* * Only applies to tags, i.e. references * in the /refs/tags folder */ if (git__prefixcmp(ref->name, GIT_REFS_TAGS_DIR) != 0) - return GIT_SUCCESS; + return 0; /* * Find the tagged object in the repository */ - error = git_object_lookup(&object, repo, &ref->oid, GIT_OBJ_ANY); - if (error < GIT_SUCCESS) - return git__throw(GIT_EOBJCORRUPTED, "Failed to find packed reference"); + if (git_object_lookup(&object, repo, &ref->oid, GIT_OBJ_ANY) < 0) + return -1; /* * If the tagged object is a Tag object, we need to resolve it; @@ -690,7 +663,7 @@ static int packed_find_peel(git_repository *repo, struct packref *ref) } git_object_free(object); - return GIT_SUCCESS; + return 0; } /* @@ -708,25 +681,27 @@ static int packed_remove_loose(git_repository *repo, git_vector *packing_list) { unsigned int i; git_buf full_path = GIT_BUF_INIT; - int error = GIT_SUCCESS; + int failed = 0; for (i = 0; i < packing_list->length; ++i) { struct packref *ref = git_vector_get(packing_list, i); - int an_error; if ((ref->flags & GIT_PACKREF_WAS_LOOSE) == 0) continue; - an_error = git_buf_joinpath(&full_path, repo->path_repository, ref->name); + if (git_buf_joinpath(&full_path, repo->path_repository, ref->name) < 0) + return -1; /* critical; do not try to recover on oom */ - if (an_error == GIT_SUCCESS && - git_path_exists(full_path.ptr) == GIT_SUCCESS && - p_unlink(full_path.ptr) < GIT_SUCCESS) - an_error = GIT_EOSERR; + if (git_path_exists(full_path.ptr) == true && p_unlink(full_path.ptr) < 0) { + if (failed) + continue; - /* keep the error if we haven't seen one yet */ - if (error > an_error) - error = an_error; + giterr_set(GITERR_REFERENCE, + "Failed to remove loose reference '%s' after packing: %s", + full_path.ptr, strerror(errno)); + + failed = 1; + } /* * if we fail to remove a single file, this is *not* good, @@ -737,10 +712,7 @@ static int packed_remove_loose(git_repository *repo, git_vector *packing_list) } git_buf_free(&full_path); - - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to remove loose packed reference"); + return failed ? -1 : 0; } static int packed_sort(const void *a, const void *b) @@ -757,176 +729,228 @@ static int packed_sort(const void *a, const void *b) static int packed_write(git_repository *repo) { git_filebuf pack_file = GIT_FILEBUF_INIT; - int error; - const char *errmsg = "Failed to write packed references file"; unsigned int i; git_buf pack_file_path = GIT_BUF_INIT; git_vector packing_list; - size_t total_refs; + unsigned int total_refs; assert(repo && repo->references.packfile); - total_refs = repo->references.packfile->key_count; - if ((error = - git_vector_init(&packing_list, total_refs, packed_sort)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to init packed references list"); + total_refs = + (unsigned int)git_strmap_num_entries(repo->references.packfile); + + if (git_vector_init(&packing_list, total_refs, packed_sort) < 0) + return -1; /* Load all the packfile into a vector */ { struct packref *reference; - GIT_HASHTABLE_FOREACH_VALUE(repo->references.packfile, reference, - /* cannot fail: vector already has the right size */ + /* cannot fail: vector already has the right size */ + git_strmap_foreach_value(repo->references.packfile, reference, { git_vector_insert(&packing_list, reference); - ); + }); } /* sort the vector so the entries appear sorted on the packfile */ git_vector_sort(&packing_list); /* Now we can open the file! */ - error = git_buf_joinpath(&pack_file_path, repo->path_repository, GIT_PACKEDREFS_FILE); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_buf_joinpath(&pack_file_path, repo->path_repository, GIT_PACKEDREFS_FILE) < 0) + goto cleanup_memory; - if ((error = git_filebuf_open(&pack_file, pack_file_path.ptr, 0)) < GIT_SUCCESS) { - errmsg = "Failed to open packed references file"; - goto cleanup; - } + if (git_filebuf_open(&pack_file, pack_file_path.ptr, 0) < 0) + goto cleanup_packfile; /* Packfiles have a header... apparently * This is in fact not required, but we might as well print it * just for kicks */ - if ((error = - git_filebuf_printf(&pack_file, "%s\n", GIT_PACKEDREFS_HEADER)) < GIT_SUCCESS) { - errmsg = "Failed to write packed references file header"; - goto cleanup; - } + if (git_filebuf_printf(&pack_file, "%s\n", GIT_PACKEDREFS_HEADER) < 0) + goto cleanup_packfile; for (i = 0; i < packing_list.length; ++i) { struct packref *ref = (struct packref *)git_vector_get(&packing_list, i); - if ((error = packed_find_peel(repo, ref)) < GIT_SUCCESS) { - error = git__throw(GIT_EOBJCORRUPTED, - "A reference cannot be peeled"); - goto cleanup; - } + if (packed_find_peel(repo, ref) < 0) + goto cleanup_packfile; - if ((error = packed_write_ref(ref, &pack_file)) < GIT_SUCCESS) - goto cleanup; + if (packed_write_ref(ref, &pack_file) < 0) + goto cleanup_packfile; } -cleanup: /* if we've written all the references properly, we can commit * the packfile to make the changes effective */ - if (error == GIT_SUCCESS) { - error = git_filebuf_commit(&pack_file, GIT_PACKEDREFS_FILE_MODE); + if (git_filebuf_commit(&pack_file, GIT_PACKEDREFS_FILE_MODE) < 0) + goto cleanup_memory; - /* when and only when the packfile has been properly written, - * we can go ahead and remove the loose refs */ - if (error == GIT_SUCCESS) { - struct stat st; + /* when and only when the packfile has been properly written, + * we can go ahead and remove the loose refs */ + if (packed_remove_loose(repo, &packing_list) < 0) + goto cleanup_memory; - error = packed_remove_loose(repo, &packing_list); - - if (p_stat(pack_file_path.ptr, &st) == GIT_SUCCESS) - repo->references.packfile_time = st.st_mtime; - } - } - else git_filebuf_cleanup(&pack_file); + { + struct stat st; + if (p_stat(pack_file_path.ptr, &st) == 0) + repo->references.packfile_time = st.st_mtime; + } git_vector_free(&packing_list); git_buf_free(&pack_file_path); - if (error < GIT_SUCCESS) - git__rethrow(error, "%s", errmsg); + /* we're good now */ + return 0; + +cleanup_packfile: + git_filebuf_cleanup(&pack_file); + +cleanup_memory: + git_vector_free(&packing_list); + git_buf_free(&pack_file_path); - return error; + return -1; } +struct reference_available_t { + const char *new_ref; + const char *old_ref; + int available; +}; + static int _reference_available_cb(const char *ref, void *data) { - const char *new, *old; - const char **refs; + struct reference_available_t *d; assert(ref && data); + d = (struct reference_available_t *)data; - refs = (const char **)data; - - new = (const char *)refs[0]; - old = (const char *)refs[1]; + if (!d->old_ref || strcmp(d->old_ref, ref)) { + size_t reflen = strlen(ref); + size_t newlen = strlen(d->new_ref); + size_t cmplen = reflen < newlen ? reflen : newlen; + const char *lead = reflen < newlen ? d->new_ref : ref; - if (!old || strcmp(old, ref)) { - int reflen = strlen(ref); - int newlen = strlen(new); - int cmplen = reflen < newlen ? reflen : newlen; - const char *lead = reflen < newlen ? new : ref; - - if (!strncmp(new, ref, cmplen) && - lead[cmplen] == '/') - return GIT_EEXISTS; + if (!strncmp(d->new_ref, ref, cmplen) && lead[cmplen] == '/') { + d->available = 0; + return -1; + } } - return GIT_SUCCESS; + return 0; } -static int reference_available( +static int reference_path_available( git_repository *repo, const char *ref, const char* old_ref) { - const char *refs[2]; + struct reference_available_t data; - refs[0] = ref; - refs[1] = old_ref; + data.new_ref = ref; + data.old_ref = old_ref; + data.available = 1; if (git_reference_foreach(repo, GIT_REF_LISTALL, - _reference_available_cb, (void *)refs) < 0) { - return git__throw(GIT_EEXISTS, - "Reference name `%s` conflicts with existing reference", ref); + _reference_available_cb, (void *)&data) < 0) + return -1; + + if (!data.available) { + giterr_set(GITERR_REFERENCE, + "The path to reference '%s' collides with an existing one", ref); + return -1; } - return GIT_SUCCESS; + return 0; } static int reference_exists(int *exists, git_repository *repo, const char *ref_name) { - int error; git_buf ref_path = GIT_BUF_INIT; - error = packed_load(repo); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Cannot resolve if a reference exists"); + if (packed_load(repo) < 0) + return -1; - error = git_buf_joinpath(&ref_path, repo->path_repository, ref_name); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Cannot resolve if a reference exists"); + if (git_buf_joinpath(&ref_path, repo->path_repository, ref_name) < 0) + return -1; - if (git_path_isfile(ref_path.ptr) == GIT_SUCCESS || - git_hashtable_lookup(repo->references.packfile, ref_path.ptr) != NULL) { + if (git_path_isfile(ref_path.ptr) == true || + git_strmap_exists(repo->references.packfile, ref_path.ptr)) + { *exists = 1; } else { *exists = 0; } git_buf_free(&ref_path); + return 0; +} + +/* + * Check if a reference could be written to disk, based on: + * + * - Whether a reference with the same name already exists, + * and we are allowing or disallowing overwrites + * + * - Whether the name of the reference would collide with + * an existing path + */ +static int reference_can_write( + git_repository *repo, + const char *refname, + const char *previous_name, + int force) +{ + /* see if the reference shares a path with an existing reference; + * if a path is shared, we cannot create the reference, even when forcing */ + if (reference_path_available(repo, refname, previous_name) < 0) + return -1; + + /* check if the reference actually exists, but only if we are not forcing + * the rename. If we are forcing, it's OK to overwrite */ + if (!force) { + int exists; + + if (reference_exists(&exists, repo, refname) < 0) + return -1; + + /* We cannot proceed if the reference already exists and we're not forcing + * the rename; the existing one would be overwritten */ + if (exists) { + giterr_set(GITERR_REFERENCE, + "A reference with that name (%s) already exists", refname); + return GIT_EEXISTS; + } + } - return GIT_SUCCESS; + /* FIXME: if the reference exists and we are forcing, do we really need to + * remove the reference first? + * + * Two cases: + * + * - the reference already exists and is loose: not a problem, the file + * gets overwritten on disk + * + * - the reference already exists and is packed: we write a new one as + * loose, which by all means renders the packed one useless + */ + + return 0; } + static int packed_lookup(git_reference *ref) { - int error; struct packref *pack_ref = NULL; + git_strmap *packfile_refs; + khiter_t pos; - error = packed_load(ref->owner); - if (error < GIT_SUCCESS) - return git__rethrow(error, - "Failed to lookup reference from packfile"); + if (packed_load(ref->owner) < 0) + return -1; - if (ref->flags & GIT_REF_PACKED && + /* maybe the packfile hasn't changed at all, so we don't + * have to re-lookup the reference */ + if ((ref->flags & GIT_REF_PACKED) && ref->mtime == ref->owner->references.packfile_time) - return GIT_SUCCESS; + return 0; if (ref->flags & GIT_REF_SYMBOLIC) { git__free(ref->target.symbolic); @@ -934,39 +958,42 @@ static int packed_lookup(git_reference *ref) } /* Look up on the packfile */ - pack_ref = git_hashtable_lookup(ref->owner->references.packfile, ref->name); - if (pack_ref == NULL) - return git__throw(GIT_ENOTFOUND, - "Failed to lookup reference from packfile"); + packfile_refs = ref->owner->references.packfile; + pos = git_strmap_lookup_index(packfile_refs, ref->name); + if (!git_strmap_valid_index(packfile_refs, pos)) { + giterr_set(GITERR_REFERENCE, "Reference '%s' not found", ref->name); + return GIT_ENOTFOUND; + } + + pack_ref = git_strmap_value_at(packfile_refs, pos); ref->flags = GIT_REF_OID | GIT_REF_PACKED; ref->mtime = ref->owner->references.packfile_time; git_oid_cpy(&ref->target.oid, &pack_ref->oid); - return GIT_SUCCESS; + return 0; } static int reference_lookup(git_reference *ref) { - int error_loose, error_packed; + int result; - error_loose = loose_lookup(ref); - if (error_loose == GIT_SUCCESS) - return GIT_SUCCESS; + result = loose_lookup(ref); + if (result == 0) + return 0; - error_packed = packed_lookup(ref); - if (error_packed == GIT_SUCCESS) - return GIT_SUCCESS; + /* only try to lookup this reference on the packfile if it + * wasn't found on the loose refs; not if there was a critical error */ + if (result == GIT_ENOTFOUND) { + giterr_clear(); + result = packed_lookup(ref); + if (result == 0) + return 0; + } + /* unexpected error; free the reference */ git_reference_free(ref); - - if (error_loose != GIT_ENOTFOUND) - return git__rethrow(error_loose, "Failed to lookup reference"); - - if (error_packed != GIT_ENOTFOUND) - return git__rethrow(error_packed, "Failed to lookup reference"); - - return git__throw(GIT_ENOTFOUND, "Reference not found"); + return result; } /* @@ -976,7 +1003,7 @@ static int reference_lookup(git_reference *ref) */ static int reference_delete(git_reference *ref) { - int error; + int result; assert(ref); @@ -984,17 +1011,28 @@ static int reference_delete(git_reference *ref) * We need to reload the packfile, remove the reference from the * packing list, and repack */ if (ref->flags & GIT_REF_PACKED) { + git_strmap *packfile_refs; struct packref *packref; + khiter_t pos; + /* load the existing packfile */ - if ((error = packed_load(ref->owner)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to delete reference"); + if (packed_load(ref->owner) < 0) + return -1; + + packfile_refs = ref->owner->references.packfile; + pos = git_strmap_lookup_index(packfile_refs, ref->name); + if (!git_strmap_valid_index(packfile_refs, pos)) { + giterr_set(GITERR_REFERENCE, + "Reference %s stopped existing in the packfile", ref->name); + return -1; + } - if (git_hashtable_remove2(ref->owner->references.packfile, - ref->name, (void **) &packref) < GIT_SUCCESS) - return git__throw(GIT_ENOTFOUND, "Reference not found"); + packref = git_strmap_value_at(packfile_refs, pos); + git_strmap_delete_at(packfile_refs, pos); - git__free (packref); - error = packed_write(ref->owner); + git__free(packref); + if (packed_write(ref->owner) < 0) + return -1; /* If the reference is loose, we can just remove the reference * from the filesystem */ @@ -1002,66 +1040,114 @@ static int reference_delete(git_reference *ref) git_reference *ref_in_pack; git_buf full_path = GIT_BUF_INIT; - error = git_buf_joinpath(&full_path, ref->owner->path_repository, ref->name); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_buf_joinpath(&full_path, ref->owner->path_repository, ref->name) < 0) + return -1; - error = p_unlink(full_path.ptr); + result = p_unlink(full_path.ptr); git_buf_free(&full_path); /* done with path at this point */ - if (error < GIT_SUCCESS) - goto cleanup; + + if (result < 0) { + giterr_set(GITERR_OS, "Failed to unlink '%s'", full_path.ptr); + return -1; + } /* When deleting a loose reference, we have to ensure that an older * packed version of it doesn't exist */ - if (git_reference_lookup(&ref_in_pack, ref->owner, - ref->name) == GIT_SUCCESS) { + if (git_reference_lookup(&ref_in_pack, ref->owner, ref->name) == 0) { assert((ref_in_pack->flags & GIT_REF_PACKED) != 0); - error = git_reference_delete(ref_in_pack); + return git_reference_delete(ref_in_pack); } + + giterr_clear(); } -cleanup: - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to delete reference"); + return 0; } int git_reference_delete(git_reference *ref) { - int error = reference_delete(ref); - if (error < GIT_SUCCESS) - return error; - + int result = reference_delete(ref); git_reference_free(ref); - return GIT_SUCCESS; + return result; } - int git_reference_lookup(git_reference **ref_out, git_repository *repo, const char *name) { + return git_reference_lookup_resolved(ref_out, repo, name, 0); +} + +int git_reference_name_to_oid( + git_oid *out, git_repository *repo, const char *name) +{ int error; - char normalized_name[GIT_REFNAME_MAX]; - git_reference *ref = NULL; + git_reference *ref; + + if ((error = git_reference_lookup_resolved(&ref, repo, name, -1)) < 0) + return error; + + git_oid_cpy(out, git_reference_oid(ref)); + git_reference_free(ref); + return 0; +} + +int git_reference_lookup_resolved( + git_reference **ref_out, + git_repository *repo, + const char *name, + int max_nesting) +{ + git_reference *scan; + int result, nesting; assert(ref_out && repo && name); *ref_out = NULL; - error = normalize_name(normalized_name, sizeof(normalized_name), name, 0); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup reference"); + if (max_nesting > MAX_NESTING_LEVEL) + max_nesting = MAX_NESTING_LEVEL; + else if (max_nesting < 0) + max_nesting = DEFAULT_NESTING_LEVEL; - error = reference_alloc(&ref, repo, normalized_name); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup reference"); + scan = git__calloc(1, sizeof(git_reference)); + GITERR_CHECK_ALLOC(scan); - error = reference_lookup(ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to lookup reference"); + scan->name = git__calloc(GIT_REFNAME_MAX + 1, sizeof(char)); + GITERR_CHECK_ALLOC(scan->name); - *ref_out = ref; - return GIT_SUCCESS; + if ((result = normalize_name(scan->name, GIT_REFNAME_MAX, name, 0)) < 0) { + git_reference_free(scan); + return result; + } + + scan->target.symbolic = git__strdup(scan->name); + GITERR_CHECK_ALLOC(scan->target.symbolic); + + scan->owner = repo; + scan->flags = GIT_REF_SYMBOLIC; + + for (nesting = max_nesting; + nesting >= 0 && (scan->flags & GIT_REF_SYMBOLIC) != 0; + nesting--) + { + if (nesting != max_nesting) + strncpy(scan->name, scan->target.symbolic, GIT_REFNAME_MAX); + + scan->mtime = 0; + + if ((result = reference_lookup(scan)) < 0) + return result; /* lookup git_reference_free on scan already */ + } + + if ((scan->flags & GIT_REF_OID) == 0 && max_nesting != 0) { + giterr_set(GITERR_REFERENCE, + "Cannot resolve reference (>%u levels deep)", max_nesting); + git_reference_free(scan); + return -1; + } + + *ref_out = scan; + return 0; } /** @@ -1126,43 +1212,32 @@ int git_reference_create_symbolic( int force) { char normalized[GIT_REFNAME_MAX]; - int ref_exists, error = GIT_SUCCESS; git_reference *ref = NULL; - error = normalize_name(normalized, sizeof(normalized), name, 0); - if (error < GIT_SUCCESS) - goto cleanup; + if (normalize_name(normalized, sizeof(normalized), name, 0) < 0) + return -1; - if ((error = reference_exists(&ref_exists, repo, normalized) < GIT_SUCCESS)) - return git__rethrow(error, "Failed to create symbolic reference"); + if (reference_can_write(repo, normalized, NULL, force) < 0) + return -1; - if (ref_exists && !force) - return git__throw(GIT_EEXISTS, - "Failed to create symbolic reference. Reference already exists"); - - error = reference_alloc(&ref, repo, normalized); - if (error < GIT_SUCCESS) - goto cleanup; + if (reference_alloc(&ref, repo, normalized) < 0) + return -1; ref->flags |= GIT_REF_SYMBOLIC; /* set the target; this will normalize the name automatically * and write the reference on disk */ - error = git_reference_set_target(ref, target); - if (error < GIT_SUCCESS) - goto cleanup; - + if (git_reference_set_target(ref, target) < 0) { + git_reference_free(ref); + return -1; + } if (ref_out == NULL) { git_reference_free(ref); } else { *ref_out = ref; } - return GIT_SUCCESS; - -cleanup: - git_reference_free(ref); - return git__rethrow(error, "Failed to create symbolic reference"); + return 0; } int git_reference_create_oid( @@ -1172,34 +1247,25 @@ int git_reference_create_oid( const git_oid *id, int force) { - int error = GIT_SUCCESS, ref_exists; git_reference *ref = NULL; char normalized[GIT_REFNAME_MAX]; - error = normalize_name(normalized, sizeof(normalized), name, 1); - if (error < GIT_SUCCESS) - goto cleanup; - - if ((error = reference_exists(&ref_exists, repo, normalized) < GIT_SUCCESS)) - return git__rethrow(error, "Failed to create OID reference"); + if (normalize_name(normalized, sizeof(normalized), name, 1) < 0) + return -1; - if (ref_exists && !force) - return git__throw(GIT_EEXISTS, - "Failed to create OID reference. Reference already exists"); + if (reference_can_write(repo, normalized, NULL, force) < 0) + return -1; - if ((error = reference_available(repo, name, NULL)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to create reference"); - - error = reference_alloc(&ref, repo, name); - if (error < GIT_SUCCESS) - goto cleanup; + if (reference_alloc(&ref, repo, name) < 0) + return -1; ref->flags |= GIT_REF_OID; /* set the oid; this will write the reference on disk */ - error = git_reference_set_oid(ref, id); - if (error < GIT_SUCCESS) - goto cleanup; + if (git_reference_set_oid(ref, id) < 0) { + git_reference_free(ref); + return -1; + } if (ref_out == NULL) { git_reference_free(ref); @@ -1207,13 +1273,8 @@ int git_reference_create_oid( *ref_out = ref; } - return GIT_SUCCESS; - -cleanup: - git_reference_free(ref); - return git__rethrow(error, "Failed to create reference OID"); + return 0; } - /* * Change the OID target of a reference. * @@ -1225,38 +1286,31 @@ cleanup: */ int git_reference_set_oid(git_reference *ref, const git_oid *id) { - int error = GIT_SUCCESS, exists; git_odb *odb = NULL; - if ((ref->flags & GIT_REF_OID) == 0) - return git__throw(GIT_EINVALIDREFSTATE, - "Failed to set OID target of reference. Not an OID reference"); + if ((ref->flags & GIT_REF_OID) == 0) { + giterr_set(GITERR_REFERENCE, "Cannot set OID on symbolic reference"); + return -1; + } assert(ref->owner); - error = git_repository_odb__weakptr(&odb, ref->owner); - if (error < GIT_SUCCESS) - return error; - - exists = git_odb_exists(odb, id); - - git_odb_free(odb); + if (git_repository_odb__weakptr(&odb, ref->owner) < 0) + return -1; /* Don't let the user create references to OIDs that * don't exist in the ODB */ - if (!exists) - return git__throw(GIT_ENOTFOUND, - "Failed to set OID target of reference. OID doesn't exist in ODB"); + if (!git_odb_exists(odb, id)) { + giterr_set(GITERR_REFERENCE, + "Target OID for the reference doesn't exist on the repository"); + return -1; + } /* Update the OID value on `ref` */ git_oid_cpy(&ref->target.oid, id); /* Write back to disk */ - error = loose_write(ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to set OID target of reference"); - - return GIT_SUCCESS; + return loose_write(ref); } /* @@ -1268,82 +1322,44 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id) */ int git_reference_set_target(git_reference *ref, const char *target) { - int error; char normalized[GIT_REFNAME_MAX]; - if ((ref->flags & GIT_REF_SYMBOLIC) == 0) - return git__throw(GIT_EINVALIDREFSTATE, - "Failed to set reference target. Not a symbolic reference"); + if ((ref->flags & GIT_REF_SYMBOLIC) == 0) { + giterr_set(GITERR_REFERENCE, + "Cannot set symbolic target on a direct reference"); + return -1; + } - error = normalize_name(normalized, sizeof(normalized), target, 0); - if (error < GIT_SUCCESS) - return git__rethrow(error, - "Failed to set reference target. Invalid target name"); + if (normalize_name(normalized, sizeof(normalized), target, 0)) + return -1; git__free(ref->target.symbolic); ref->target.symbolic = git__strdup(normalized); - if (ref->target.symbolic == NULL) - return GIT_ENOMEM; + GITERR_CHECK_ALLOC(ref->target.symbolic); return loose_write(ref); } int git_reference_rename(git_reference *ref, const char *new_name, int force) { - int error; + int result; git_buf aux_path = GIT_BUF_INIT; char normalized[GIT_REFNAME_MAX]; const char *head_target = NULL; - git_reference *existing_ref = NULL, *head = NULL; - - error = normalize_name(normalized, sizeof(normalized), - new_name, ref->flags & GIT_REF_OID); + git_reference *head = NULL; - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to rename reference. Invalid name"); + if (normalize_name(normalized, sizeof(normalized), + new_name, ref->flags & GIT_REF_OID) < 0) + return -1; - new_name = normalized; - - /* If we are forcing the rename, try to lookup a reference with the - * new one. If the lookup succeeds, we need to delete that ref - * before the renaming can proceed */ - if (force) { - error = git_reference_lookup(&existing_ref, ref->owner, new_name); - - if (error == GIT_SUCCESS) { - error = git_reference_delete(existing_ref); - if (error < GIT_SUCCESS) - return git__rethrow(error, - "Failed to rename reference. " - "The existing reference cannot be deleted"); - } else if (error != GIT_ENOTFOUND) - goto cleanup; - - /* If we're not forcing the rename, check if the reference exists. - * If it does, renaming cannot continue */ - } else { - int exists; - - error = reference_exists(&exists, ref->owner, normalized); - if (error < GIT_SUCCESS) - goto cleanup; - - if (exists) - return git__throw(GIT_EEXISTS, - "Failed to rename reference. Reference already exists"); - } - - if ((error = reference_available(ref->owner, new_name, ref->name)) < GIT_SUCCESS) - return git__rethrow(error, - "Failed to rename reference. Reference already exists"); + if (reference_can_write(ref->owner, normalized, ref->name, force) < 0) + return -1; /* Initialize path now so we won't get an allocation failure once - * we actually start removing things. - */ - error = git_buf_joinpath(&aux_path, ref->owner->path_repository, new_name); - if (error < GIT_SUCCESS) - goto cleanup; + * we actually start removing things. */ + if (git_buf_joinpath(&aux_path, ref->owner->path_repository, new_name) < 0) + return -1; /* * Now delete the old ref and remove an possibly existing directory @@ -1351,57 +1367,54 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force) * method deletes the ref from disk but doesn't free the pointer, so * we can still access the ref's attributes for creating the new one */ - if ((error = reference_delete(ref)) < GIT_SUCCESS) + if (reference_delete(ref) < 0) goto cleanup; - if (git_path_exists(aux_path.ptr) == GIT_SUCCESS) { - if (git_path_isdir(aux_path.ptr) == GIT_SUCCESS) { - if ((error = git_futils_rmdir_r(aux_path.ptr, 0)) < GIT_SUCCESS) - goto rollback; - } else goto rollback; - } - /* * Finally we can create the new reference. */ if (ref->flags & GIT_REF_SYMBOLIC) { - error = git_reference_create_symbolic( - NULL, ref->owner, new_name, ref->target.symbolic, 0); + result = git_reference_create_symbolic( + NULL, ref->owner, new_name, ref->target.symbolic, force); } else { - error = git_reference_create_oid( - NULL, ref->owner, new_name, &ref->target.oid, 0); + result = git_reference_create_oid( + NULL, ref->owner, new_name, &ref->target.oid, force); } - if (error < GIT_SUCCESS) + if (result < 0) goto rollback; /* * Check if we have to update HEAD. */ - error = git_reference_lookup(&head, ref->owner, GIT_HEAD_FILE); - if (error < GIT_SUCCESS) + if (git_reference_lookup(&head, ref->owner, GIT_HEAD_FILE) < 0) { + giterr_set(GITERR_REFERENCE, + "Failed to update HEAD after renaming reference"); goto cleanup; + } head_target = git_reference_target(head); if (head_target && !strcmp(head_target, ref->name)) { - error = git_reference_create_symbolic( - &head, ref->owner, "HEAD", new_name, 1); - - if (error < GIT_SUCCESS) + if (git_reference_create_symbolic(&head, ref->owner, "HEAD", new_name, 1) < 0) { + giterr_set(GITERR_REFERENCE, + "Failed to update HEAD after renaming reference"); goto cleanup; + } } /* * Rename the reflog file. */ - error = git_buf_join_n(&aux_path, '/', 3, ref->owner->path_repository, - GIT_REFLOG_DIR, ref->name); - if (error < GIT_SUCCESS) + if (git_buf_join_n(&aux_path, '/', 3, ref->owner->path_repository, GIT_REFLOG_DIR, ref->name) < 0) goto cleanup; - if (git_path_exists(aux_path.ptr) == GIT_SUCCESS) - error = git_reflog_rename(ref, new_name); + if (git_path_exists(aux_path.ptr) == true) { + if (git_reflog_rename(ref, new_name) < 0) + goto cleanup; + } else { + giterr_clear(); + } /* * Change the name of the reference given by the user. @@ -1412,92 +1425,49 @@ int git_reference_rename(git_reference *ref, const char *new_name, int force) /* The reference is no longer packed */ ref->flags &= ~GIT_REF_PACKED; + git_reference_free(head); + git_buf_free(&aux_path); + return 0; + cleanup: - /* We no longer need the newly created reference nor the head */ git_reference_free(head); git_buf_free(&aux_path); - return error == GIT_SUCCESS ? - GIT_SUCCESS : - git__rethrow(error, "Failed to rename reference"); + return -1; rollback: /* - * Try to create the old reference again. + * Try to create the old reference again, ignore failures */ if (ref->flags & GIT_REF_SYMBOLIC) - error = git_reference_create_symbolic( + git_reference_create_symbolic( NULL, ref->owner, ref->name, ref->target.symbolic, 0); else - error = git_reference_create_oid( + git_reference_create_oid( NULL, ref->owner, ref->name, &ref->target.oid, 0); /* The reference is no longer packed */ ref->flags &= ~GIT_REF_PACKED; git_buf_free(&aux_path); - - return error == GIT_SUCCESS ? - git__rethrow(GIT_ERROR, "Failed to rename reference. Did rollback") : - git__rethrow(error, "Failed to rename reference. Failed to rollback"); + return -1; } int git_reference_resolve(git_reference **ref_out, git_reference *ref) { - int error, i = 0; - git_repository *repo; - - assert(ref); - - *ref_out = NULL; - repo = ref->owner; - - /* If the reference is already resolved, we need to return a - * copy. Instead of duplicating `ref`, we look it up again to - * ensure the copy is out to date */ if (ref->flags & GIT_REF_OID) return git_reference_lookup(ref_out, ref->owner, ref->name); - - /* Otherwise, keep iterating until the reference is resolved */ - for (i = 0; i < MAX_NESTING_LEVEL; ++i) { - git_reference *new_ref; - - error = git_reference_lookup(&new_ref, repo, ref->target.symbolic); - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to resolve reference"); - - /* Free intermediate references, except for the original one - * we've received */ - if (i > 0) - git_reference_free(ref); - - ref = new_ref; - - /* When the reference we've just looked up is an OID, we've - * successfully resolved the symbolic ref */ - if (ref->flags & GIT_REF_OID) { - *ref_out = ref; - return GIT_SUCCESS; - } - } - - return git__throw(GIT_ENOMEM, - "Failed to resolve reference. Reference is too nested"); + else + return git_reference_lookup_resolved(ref_out, ref->owner, ref->target.symbolic, -1); } int git_reference_packall(git_repository *repo) { - int error; - - /* load the existing packfile */ - if ((error = packed_load(repo)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to pack references"); + if (packed_load(repo) < 0 || /* load the existing packfile */ + packed_loadloose(repo) < 0 || /* add all the loose refs */ + packed_write(repo) < 0) /* write back to disk */ + return -1; - /* update it in-memory with all the loose references */ - if ((error = packed_loadloose(repo)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to pack references"); - - /* write it back to disk */ - return packed_write(repo); + return 0; } int git_reference_foreach( @@ -1506,22 +1476,23 @@ int git_reference_foreach( int (*callback)(const char *, void *), void *payload) { - int error; + int result; struct dirent_list_data data; git_buf refs_path = GIT_BUF_INIT; /* list all the packed references first */ if (list_flags & GIT_REF_PACKED) { const char *ref_name; + void *ref; + GIT_UNUSED(ref); - if ((error = packed_load(repo)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to list references"); + if (packed_load(repo) < 0) + return -1; - GIT_HASHTABLE_FOREACH_KEY(repo->references.packfile, ref_name, - if ((error = callback(ref_name, payload)) < GIT_SUCCESS) - return git__throw(error, - "Failed to list references. User callback failed"); - ); + git_strmap_foreach(repo->references.packfile, ref_name, ref, { + if (callback(ref_name, payload) < 0) + return 0; + }); } /* now list the loose references, trying not to @@ -1533,15 +1504,13 @@ int git_reference_foreach( data.callback = callback; data.callback_payload = payload; - if ((error = git_buf_joinpath(&refs_path, - repo->path_repository, GIT_REFS_DIR)) < GIT_SUCCESS) - return git__rethrow(error, "Failed to alloc space for references"); - - error = git_path_direach(&refs_path, _dirent_loose_listall, &data); + if (git_buf_joinpath(&refs_path, repo->path_repository, GIT_REFS_DIR) < 0) + return -1; + result = git_path_direach(&refs_path, _dirent_loose_listall, &data); git_buf_free(&refs_path); - return error; + return result; } static int cb__reflist_add(const char *ref, void *data) @@ -1554,7 +1523,6 @@ int git_reference_listall( git_repository *repo, unsigned int list_flags) { - int error; git_vector ref_list; assert(array && repo); @@ -1562,33 +1530,25 @@ int git_reference_listall( array->strings = NULL; array->count = 0; - if (git_vector_init(&ref_list, 8, NULL) < GIT_SUCCESS) - return GIT_ENOMEM; + if (git_vector_init(&ref_list, 8, NULL) < 0) + return -1; - error = git_reference_foreach( - repo, list_flags, &cb__reflist_add, (void *)&ref_list); - - if (error < GIT_SUCCESS) { + if (git_reference_foreach( + repo, list_flags, &cb__reflist_add, (void *)&ref_list) < 0) { git_vector_free(&ref_list); - return error; + return -1; } array->strings = (char **)ref_list.contents; array->count = ref_list.length; - return GIT_SUCCESS; + return 0; } int git_reference_reload(git_reference *ref) { - int error = reference_lookup(ref); - - if (error < GIT_SUCCESS) - return git__rethrow(error, "Failed to reload reference"); - - return GIT_SUCCESS; + return reference_lookup(ref); } - void git_repository__refcache_free(git_refcache *refs) { assert(refs); @@ -1596,10 +1556,11 @@ void git_repository__refcache_free(git_refcache *refs) if (refs->packfile) { struct packref *reference; - GIT_HASHTABLE_FOREACH_VALUE( - refs->packfile, reference, git__free(reference)); + git_strmap_foreach_value(refs->packfile, reference, { + git__free(reference); + }); - git_hashtable_free(refs->packfile); + git_strmap_free(refs->packfile); } } @@ -1643,33 +1604,26 @@ static int normalize_name( /* A refname can not be empty */ if (name_end == name) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name is empty"); + goto invalid_name; /* A refname can not end with a dot or a slash */ if (*(name_end - 1) == '.' || *(name_end - 1) == '/') - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name ends with dot or slash"); + goto invalid_name; while (current < name_end && out_size) { if (!is_valid_ref_char(*current)) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. " - "Reference name contains invalid characters"); + goto invalid_name; if (buffer_out > buffer_out_start) { char prev = *(buffer_out - 1); /* A refname can not start with a dot nor contain a double dot */ if (*current == '.' && ((prev == '.') || (prev == '/'))) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. " - "Reference name starts with a dot or contains a double dot"); + goto invalid_name; /* '@{' is forbidden within a refname */ if (*current == '{' && prev == '@') - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name contains '@{'"); + goto invalid_name; /* Prevent multiple slashes from being added to the output */ if (*current == '/' && prev == '/') { @@ -1686,7 +1640,7 @@ static int normalize_name( } if (!out_size) - return git__throw(GIT_EINVALIDREFNAME, "Reference name is too long"); + goto invalid_name; /* Object id refname have to contain at least one slash, except * for HEAD in a detached state or MERGE_HEAD if we're in the @@ -1696,13 +1650,11 @@ static int normalize_name( strcmp(name, GIT_HEAD_FILE) != 0 && strcmp(name, GIT_MERGE_HEAD_FILE) != 0 && strcmp(name, GIT_FETCH_HEAD_FILE) != 0) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name contains no slashes"); + goto invalid_name; /* A refname can not end with ".lock" */ if (!git__suffixcmp(name, GIT_FILELOCK_EXTENSION)) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. Reference name ends with '.lock'"); + goto invalid_name; *buffer_out = '\0'; @@ -1712,11 +1664,13 @@ static int normalize_name( */ if (is_oid_ref && !(git__prefixcmp(buffer_out_start, GIT_REFS_DIR) || strcmp(buffer_out_start, GIT_HEAD_FILE))) - return git__throw(GIT_EINVALIDREFNAME, - "Failed to normalize name. " - "Reference name does not start with 'refs/'"); + goto invalid_name; + + return 0; - return GIT_SUCCESS; +invalid_name: + giterr_set(GITERR_REFERENCE, "The given reference name is not valid"); + return -1; } int git_reference__normalize_name( @@ -1734,3 +1688,20 @@ int git_reference__normalize_name_oid( { return normalize_name(buffer_out, out_size, name, 1); } + +#define GIT_REF_TYPEMASK (GIT_REF_OID | GIT_REF_SYMBOLIC) + +int git_reference_cmp(git_reference *ref1, git_reference *ref2) +{ + assert(ref1 && ref2); + + /* let's put symbolic refs before OIDs */ + if ((ref1->flags & GIT_REF_TYPEMASK) != (ref2->flags & GIT_REF_TYPEMASK)) + return (ref1->flags & GIT_REF_SYMBOLIC) ? -1 : 1; + + if (ref1->flags & GIT_REF_SYMBOLIC) + return strcmp(ref1->target.symbolic, ref2->target.symbolic); + + return git_oid_cmp(&ref1->target.oid, &ref2->target.oid); +} + |