diff --git a/src/refs.c b/src/refs.c index c4d3d6ae6..56bb88351 100644 --- a/src/refs.c +++ b/src/refs.c @@ -145,11 +145,11 @@ static int reference_create( *ref_out = reference; - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create reference"); cleanup: reference_free(reference); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create reference"); } static int reference_read(gitfo_buf *file_content, time_t *mtime, const char *repo_path, const char *ref_name) @@ -215,7 +215,7 @@ cleanup: git_hashtable_remove(ref->owner->references.loose_cache, ref->name); } - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to update loose reference"); } static int loose_parse_symbolic(git_reference *ref, gitfo_buf *file_content) @@ -349,7 +349,7 @@ static int loose_lookup( cleanup: gitfo_free_buf(&ref_file); reference_free(ref); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to lookup loose reference"); } static int loose_write(git_reference *ref) @@ -365,7 +365,7 @@ static int loose_write(git_reference *ref) git__joinpath(ref_path, ref->owner->path_repository, ref->name); if ((error = git_filebuf_open(&file, ref_path, GIT_FILEBUF_FORCE)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to write loose reference"); if (ref->type & GIT_REF_OID) { reference_oid *ref_oid = (reference_oid *)ref; @@ -408,12 +408,12 @@ static int loose_write(git_reference *ref) ref->mtime = st.st_mtime; free(ref_contents); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write loose reference"); unlock: git_filebuf_cleanup(&file); free(ref_contents); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write loose reference"); } @@ -436,25 +436,25 @@ static int packed_parse_peel( /* Ensure it's not the first entry of the file */ if (tag_ref == NULL) - return GIT_EPACKEDREFSCORRUPTED; + return git__throw(GIT_EPACKEDREFSCORRUPTED, "Failed to parse packed reference. Reference is the first entry of the file"); /* Ensure reference is a tag */ if (git__prefixcmp(tag_ref->ref.name, GIT_REFS_TAGS_DIR) != 0) - return GIT_EPACKEDREFSCORRUPTED; + return git__throw(GIT_EPACKEDREFSCORRUPTED, "Failed to parse packed reference. Reference is not a tag"); if (buffer + GIT_OID_HEXSZ >= buffer_end) - return GIT_EPACKEDREFSCORRUPTED; + return git__throw(GIT_EPACKEDREFSCORRUPTED, "Failed to parse packed reference. Buffer too small"); /* Is this a valid object id? */ if (git_oid_mkstr(&tag_ref->peel_target, buffer) < GIT_SUCCESS) - return GIT_EPACKEDREFSCORRUPTED; + return git__throw(GIT_EPACKEDREFSCORRUPTED, "Failed to parse packed reference. Not a valid object ID"); buffer = buffer + GIT_OID_HEXSZ; if (*buffer == '\r') buffer++; if (*buffer != '\n') - return GIT_EPACKEDREFSCORRUPTED; + return git__throw(GIT_EPACKEDREFSCORRUPTED, "Failed to parse packed reference. Buffer not terminated correctly"); *buffer_out = buffer + 1; tag_ref->ref.type |= GIT_REF_HAS_PEEL; @@ -517,7 +517,7 @@ static int packed_parse_oid( cleanup: reference_free((git_reference *)ref); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse OID of packed reference"); } static int packed_load(git_repository *repo) @@ -609,7 +609,7 @@ cleanup: git_hashtable_free(ref_cache->packfile); ref_cache->packfile = NULL; gitfo_free_buf(&packfile); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to load packed references"); } @@ -669,7 +669,7 @@ static int _dirent_loose_load(void *data, char *full_path) reference_free(old_ref); } - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to load loose dirent"); } /* @@ -738,7 +738,7 @@ static int packed_write_ref(reference_oid *ref, git_filebuf *file) error = git_filebuf_printf(file, "%s %s\n", oid, ref->ref.name); } - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write packed reference"); } /* @@ -769,7 +769,7 @@ static int packed_find_peel(reference_oid *ref) */ error = git_object_lookup(&object, ref->ref.owner, &ref->oid, GIT_OBJ_ANY); if (error < GIT_SUCCESS) - return GIT_EOBJCORRUPTED; + return git__throw(GIT_EOBJCORRUPTED, "Failed to find packed reference"); /* * If the tagged object is a Tag object, we need to resolve it; @@ -842,7 +842,7 @@ static int packed_remove_loose(git_repository *repo, git_vector *packing_list) */ } - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to remove loose packed reference"); } static int packed_sort(const void *a, const void *b) @@ -870,7 +870,7 @@ static int packed_write(git_repository *repo) total_refs = repo->references.packfile->key_count; if ((error = git_vector_init(&packing_list, total_refs, packed_sort)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to write packed reference"); /* Load all the packfile into a vector */ { @@ -888,13 +888,13 @@ static int packed_write(git_repository *repo) /* Now we can open the file! */ git__joinpath(pack_file_path, repo->path_repository, GIT_PACKEDREFS_FILE); if ((error = git_filebuf_open(&pack_file, pack_file_path, 0)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to write packed reference"); /* 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) - return error; + return git__rethrow(error, "Failed to write packed reference"); for (i = 0; i < packing_list.length; ++i) { reference_oid *ref = (reference_oid *)git_vector_get(&packing_list, i); @@ -931,7 +931,7 @@ cleanup: git_vector_free(&packing_list); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write packed reference"); } /***************************************** @@ -945,7 +945,7 @@ static int reference_create_symbolic(git_reference **ref_out, git_repository *re git_reference *ref = NULL, *old_ref = NULL; if (git_reference_lookup(&ref, repo, name) == GIT_SUCCESS && !force) - return GIT_EEXISTS; + return git__throw(GIT_EEXISTS, "Failed to create symbolic reference. Reference already exists"); /* * If they old ref was of the same type, then we can just update @@ -988,11 +988,11 @@ static int reference_create_symbolic(git_reference **ref_out, git_repository *re *ref_out = ref; - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create symbolic reference"); cleanup: reference_free(ref); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create symbolic reference"); } static int reference_create_oid(git_reference **ref_out, git_repository *repo, const char *name, const git_oid *id, int force) @@ -1001,7 +1001,7 @@ static int reference_create_oid(git_reference **ref_out, git_repository *repo, c git_reference *ref = NULL, *old_ref = NULL; if(git_reference_lookup(&ref, repo, name) == GIT_SUCCESS && !force) - return GIT_EEXISTS; + return git__throw(GIT_EEXISTS, "Failed to create reference OID. Reference already exists"); /* * If they old ref was of the same type, then we can just update @@ -1035,11 +1035,11 @@ static int reference_create_oid(git_reference **ref_out, git_repository *repo, c *ref_out = ref; - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create reference OID"); cleanup: reference_free(ref); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create reference OID"); } /* @@ -1067,17 +1067,17 @@ static int reference_rename(git_reference *ref, const char *new_name, int force) /* Ensure the name is valid */ error = normalize_name(normalized_name, new_name, ref->type & GIT_REF_OID); if (error < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to rename reference"); /* Ensure we're not going to overwrite an existing reference unless the user has allowed us */ error = git_reference_lookup(&looked_up_ref, ref->owner, new_name); if (error == GIT_SUCCESS && !force) - return GIT_EEXISTS; + return git__throw(GIT_EEXISTS, "Failed to rename reference. Reference already exists"); if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) - return error; + return git__rethrow(error, "Failed to rename reference"); old_name = ref->name; @@ -1137,13 +1137,13 @@ static int reference_rename(git_reference *ref, const char *new_name, int force) reference_free(old_ref); free(old_name); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to rename reference"); cleanup: /* restore the old name if this failed */ free(ref->name); ref->name = old_name; - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to rename reference"); rename_loose_to_old_name: /* If we hit this point. Something *bad* happened! Think "Ghostbusters @@ -1166,7 +1166,7 @@ rename_loose_to_old_name: free(ref->name); ref->name = old_name; - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to rename reference"); } /***************************************** @@ -1187,7 +1187,7 @@ int git_reference_lookup(git_reference **ref_out, git_repository *repo, const ch error = normalize_name(normalized_name, name, 0); if (error < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to lookup reference"); /* First, check has been previously loaded and cached */ *ref_out = git_hashtable_lookup(repo->references.loose_cache, normalized_name); @@ -1204,7 +1204,7 @@ int git_reference_lookup(git_reference **ref_out, git_repository *repo, const ch /* The loose lookup has failed, but not because the reference wasn't found; * probably the loose reference is corrupted. this is bad. */ if (error != GIT_ENOTFOUND) - return error; + return git__rethrow(error, "Failed to lookup reference"); /* * If we cannot find a loose reference, we look into the packfile @@ -1213,7 +1213,7 @@ int git_reference_lookup(git_reference **ref_out, git_repository *repo, const ch /* load all the packed references */ error = packed_load(repo); if (error < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to lookup reference"); /* Look up on the packfile */ *ref_out = git_hashtable_lookup(repo->references.packfile, normalized_name); @@ -1221,7 +1221,7 @@ int git_reference_lookup(git_reference **ref_out, git_repository *repo, const ch return GIT_SUCCESS; /* The reference doesn't exist anywhere */ - return GIT_ENOTFOUND; + return git__throw(GIT_ENOTFOUND, "Failed to lookup reference. Reference doesn't exist"); } int git_reference_create_symbolic(git_reference **ref_out, git_repository *repo, const char *name, const char *target) @@ -1329,7 +1329,7 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id) int error = GIT_SUCCESS; if ((ref->type & GIT_REF_OID) == 0) - return GIT_EINVALIDREFSTATE; + return git__throw(GIT_EINVALIDREFSTATE, "Failed to set OID target of reference. Not an OID reference"); ref_oid = (reference_oid *)ref; @@ -1338,7 +1338,7 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id) /* Don't let the user create references to OIDs that * don't exist in the ODB */ if (!git_odb_exists(git_repository_database(ref->owner), id)) - return GIT_ENOTFOUND; + return git__throw(GIT_ENOTFOUND, "Failed to set OID target of reference. OID doesn't exist in ODB"); /* duplicate the reference; * this copy will stay on the packfile cache */ @@ -1379,7 +1379,7 @@ int git_reference_set_oid(git_reference *ref, const git_oid *id) cleanup: reference_free((git_reference *)ref_old); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to set OID target of reference"); } /* @@ -1394,7 +1394,7 @@ int git_reference_set_target(git_reference *ref, const char *target) reference_symbolic *ref_sym; if ((ref->type & GIT_REF_SYMBOLIC) == 0) - return GIT_EINVALIDREFSTATE; + return git__throw(GIT_EINVALIDREFSTATE, "Failed to set reference target. Not a symbolic reference"); ref_sym = (reference_symbolic *)ref; @@ -1435,7 +1435,7 @@ int git_reference_delete(git_reference *ref) if (ref->type & GIT_REF_PACKED) { /* load the existing packfile */ if ((error = packed_load(ref->owner)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to delete reference"); git_hashtable_remove(ref->owner->references.packfile, ref->name); error = packed_write(ref->owner); @@ -1458,7 +1458,7 @@ int git_reference_delete(git_reference *ref) cleanup: reference_free(ref); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to delete reference"); } int git_reference_rename(git_reference *ref, const char *new_name) @@ -1480,7 +1480,7 @@ int git_reference_resolve(git_reference **resolved_ref, git_reference *ref) *resolved_ref = NULL; if ((error = loose_update(ref)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to resolve reference"); repo = ref->owner; @@ -1495,10 +1495,10 @@ int git_reference_resolve(git_reference **resolved_ref, git_reference *ref) ref_sym = (reference_symbolic *)ref; if ((error = git_reference_lookup(&ref, repo, ref_sym->target)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to resolve reference"); } - return GIT_ETOONESTEDSYMREF; + return git__throw(GIT_ETOONESTEDSYMREF, "Failed to resolve reference. Reference is too nested"); } int git_reference_packall(git_repository *repo) @@ -1507,11 +1507,11 @@ int git_reference_packall(git_repository *repo) /* load the existing packfile */ if ((error = packed_load(repo)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to pack references"); /* update it in-memory with all the loose references */ if ((error = packed_loadloose(repo)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to pack references"); /* write it back to disk */ return packed_write(repo); @@ -1529,11 +1529,11 @@ int git_reference_listcb(git_repository *repo, unsigned int list_flags, int (*ca void *GIT_UNUSED(_unused); if ((error = packed_load(repo)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to list references"); GIT_HASHTABLE_FOREACH(repo->references.packfile, ref_name, _unused, if ((error = callback(ref_name, payload)) < GIT_SUCCESS) - return error; + return git__rethrow(error, "Failed to list references"); ); } @@ -1573,7 +1573,7 @@ int git_reference_listall(git_strarray *array, git_repository *repo, unsigned in if (error < GIT_SUCCESS) { git_vector_free(&ref_list); - return error; + return git__rethrow(error, "Failed to list references"); } array->strings = (char **)ref_list.contents; @@ -1632,7 +1632,7 @@ void git_repository__refcache_free(git_refcache *refs) static int check_valid_ref_char(char ch) { if (ch <= ' ') - return GIT_ERROR; + return git__throw(GIT_ERROR, "Not a valid reference char"); switch (ch) { case '~': @@ -1642,7 +1642,7 @@ static int check_valid_ref_char(char ch) case '?': case '[': case '*': - return GIT_ERROR; + return git__throw(GIT_ERROR, "Not a valid reference char"); break; default: @@ -1665,26 +1665,26 @@ static int normalize_name(char *buffer_out, const char *name, int is_oid_ref) /* A refname can not be empty */ if (name_end == name) - return GIT_EINVALIDREFNAME; + return git__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name is empty"); /* A refname can not end with a dot or a slash */ if (*(name_end - 1) == '.' || *(name_end - 1) == '/') - return GIT_EINVALIDREFNAME; + return git__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name ends with dot or slash"); while (current < name_end) { if (check_valid_ref_char(*current)) - return GIT_EINVALIDREFNAME; + return git__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name contains invalid characters"); 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_EINVALIDREFNAME; + return git__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name starts with a dot or contains a double dot"); /* '@{' is forbidden within a refname */ if (*current == '{' && prev == '@') - return GIT_EINVALIDREFNAME; + return git__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name contains '@{'"); /* Prevent multiple slashes from being added to the output */ if (*current == '/' && prev == '/') { @@ -1703,11 +1703,11 @@ static int normalize_name(char *buffer_out, const char *name, int is_oid_ref) * for HEAD in a detached state or MERGE_HEAD if we're in the * middle of a merge */ if (is_oid_ref && !contains_a_slash && (strcmp(name, GIT_HEAD_FILE) && strcmp(name, GIT_MERGE_HEAD_FILE))) - return GIT_EINVALIDREFNAME; + return git__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name contains no slashes"); /* A refname can not end with ".lock" */ if (!git__suffixcmp(name, GIT_FILELOCK_EXTENSION)) - return GIT_EINVALIDREFNAME; + return git__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name ends with '.lock'"); *buffer_out = '\0'; @@ -1718,9 +1718,9 @@ static int normalize_name(char *buffer_out, const char *name, int is_oid_ref) if (is_oid_ref && !(git__prefixcmp(buffer_out_start, GIT_REFS_DIR) || strcmp(buffer_out_start, GIT_HEAD_FILE))) - return GIT_EINVALIDREFNAME; + return git__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name does not start with 'refs/'"); - return error; + return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to normalize name"); } int git_reference__normalize_name(char *buffer_out, const char *name)