| /* |
| * 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 "refs.h" |
| #include "hash.h" |
| #include "repository.h" |
| #include "fileops.h" |
| |
| #include <git2/tag.h> |
| #include <git2/object.h> |
| |
| #define MAX_NESTING_LEVEL 5 |
| |
| typedef struct { |
| git_reference ref; |
| git_oid oid; |
| git_oid peel_target; |
| } reference_oid; |
| |
| typedef struct { |
| git_reference ref; |
| char *target; |
| } reference_symbolic; |
| |
| static const int default_table_size = 32; |
| |
| static uint32_t reftable_hash(const void *key, int hash_id) |
| { |
| static uint32_t hash_seeds[GIT_HASHTABLE_HASHES] = { |
| 2147483647, |
| 0x5d20bb23, |
| 0x7daaab3c |
| }; |
| |
| return git__hash(key, strlen((const char *)key), hash_seeds[hash_id]); |
| } |
| |
| static void reference_free(git_reference *reference); |
| static int reference_create(git_reference **ref_out, git_repository *repo, const char *name, git_rtype type); |
| static int reference_read(gitfo_buf *file_content, time_t *mtime, const char *repo_path, const char *ref_name); |
| |
| /* loose refs */ |
| static int loose_parse_symbolic(git_reference *ref, gitfo_buf *file_content); |
| static int loose_parse_oid(git_reference *ref, gitfo_buf *file_content); |
| static int loose_lookup(git_reference **ref_out, git_repository *repo, const char *name, int skip_symbolic); |
| static int loose_write(git_reference *ref); |
| static int loose_update(git_reference *ref); |
| |
| /* packed refs */ |
| static int packed_parse_peel(reference_oid *tag_ref, const char **buffer_out, const char *buffer_end); |
| static int packed_parse_oid(reference_oid **ref_out, git_repository *repo, const char **buffer_out, const char *buffer_end); |
| static int packed_load(git_repository *repo); |
| static int packed_loadloose(git_repository *repository); |
| static int packed_write_ref(reference_oid *ref, git_filebuf *file); |
| static int packed_find_peel(reference_oid *ref); |
| static int packed_remove_loose(git_repository *repo, git_vector *packing_list); |
| static int packed_sort(const void *a, const void *b); |
| static int packed_write(git_repository *repo); |
| |
| /* name normalization */ |
| static int check_valid_ref_char(char ch); |
| static int normalize_name(char *buffer_out, const char *name, int is_oid_ref); |
| |
| /***************************************** |
| * Internal methods - Constructor/destructor |
| *****************************************/ |
| static void reference_free(git_reference *reference) |
| { |
| if (reference == NULL) |
| return; |
| |
| if (reference->name) |
| free(reference->name); |
| |
| if (reference->type == GIT_REF_SYMBOLIC) |
| free(((reference_symbolic *)reference)->target); |
| |
| free(reference); |
| } |
| |
| static int reference_create( |
| git_reference **ref_out, |
| git_repository *repo, |
| const char *name, |
| git_rtype type) |
| { |
| char normalized[MAX_GITDIR_TREE_STRUCTURE_PATH_LENGTH]; |
| int error = GIT_SUCCESS, size; |
| git_reference *reference = NULL; |
| |
| assert(ref_out && repo && name); |
| |
| if (type == GIT_REF_SYMBOLIC) |
| size = sizeof(reference_symbolic); |
| else if (type == GIT_REF_OID) |
| size = sizeof(reference_oid); |
| else |
| return GIT_EINVALIDREFSTATE; |
| |
| reference = git__malloc(size); |
| if (reference == NULL) |
| return GIT_ENOMEM; |
| |
| memset(reference, 0x0, size); |
| reference->owner = repo; |
| reference->type = type; |
| |
| error = normalize_name(normalized, name, (type & GIT_REF_OID)); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| reference->name = git__strdup(normalized); |
| if (reference->name == NULL) { |
| error = GIT_ENOMEM; |
| goto cleanup; |
| } |
| |
| *ref_out = reference; |
| |
| return error; |
| |
| cleanup: |
| reference_free(reference); |
| return error; |
| } |
| |
| static int reference_read(gitfo_buf *file_content, time_t *mtime, const char *repo_path, const char *ref_name) |
| { |
| struct stat st; |
| char path[GIT_PATH_MAX]; |
| |
| /* Determine the full path of the file */ |
| git__joinpath(path, repo_path, ref_name); |
| |
| if (gitfo_stat(path, &st) < 0) |
| return GIT_ENOTFOUND; |
| |
| if (S_ISDIR(st.st_mode)) |
| return GIT_EOBJCORRUPTED; |
| |
| if (mtime) |
| *mtime = st.st_mtime; |
| |
| if (file_content) |
| return gitfo_read_file(file_content, path); |
| |
| return GIT_SUCCESS; |
| } |
| |
| |
| |
| |
| /***************************************** |
| * Internal methods - Loose references |
| *****************************************/ |
| static int loose_update(git_reference *ref) |
| { |
| int error; |
| time_t ref_time; |
| gitfo_buf ref_file = GITFO_BUF_INIT; |
| |
| if (ref->type & GIT_REF_PACKED) |
| return packed_load(ref->owner); |
| |
| error = reference_read(NULL, &ref_time, ref->owner->path_repository, ref->name); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| if (ref_time == ref->mtime) |
| return GIT_SUCCESS; |
| |
| error = reference_read(&ref_file, &ref->mtime, ref->owner->path_repository, ref->name); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| if (ref->type == GIT_REF_SYMBOLIC) |
| error = loose_parse_symbolic(ref, &ref_file); |
| else if (ref->type == GIT_REF_OID) |
| error = loose_parse_oid(ref, &ref_file); |
| else |
| error = GIT_EINVALIDREFSTATE; |
| |
| gitfo_free_buf(&ref_file); |
| |
| cleanup: |
| if (error != GIT_SUCCESS) { |
| reference_free(ref); |
| git_hashtable_remove(ref->owner->references.loose_cache, ref->name); |
| } |
| |
| return error; |
| } |
| |
| static int loose_parse_symbolic(git_reference *ref, gitfo_buf *file_content) |
| { |
| const unsigned int header_len = strlen(GIT_SYMREF); |
| const char *refname_start; |
| char *eol; |
| reference_symbolic *ref_sym; |
| |
| refname_start = (const char *)file_content->data; |
| ref_sym = (reference_symbolic *)ref; |
| |
| if (file_content->len < (header_len + 1)) |
| return GIT_EREFCORRUPTED; |
| |
| /* |
| * Assume we have already checked for the header |
| * before calling this function |
| */ |
| |
| refname_start += header_len; |
| |
| free(ref_sym->target); |
| ref_sym->target = git__strdup(refname_start); |
| if (ref_sym->target == NULL) |
| return GIT_ENOMEM; |
| |
| /* remove newline at the end of file */ |
| eol = strchr(ref_sym->target, '\n'); |
| if (eol == NULL) |
| return GIT_EREFCORRUPTED; |
| |
| *eol = '\0'; |
| if (eol[-1] == '\r') |
| eol[-1] = '\0'; |
| |
| return GIT_SUCCESS; |
| } |
| |
| static int loose_parse_oid(git_reference *ref, gitfo_buf *file_content) |
| { |
| reference_oid *ref_oid; |
| char *buffer; |
| |
| buffer = (char *)file_content->data; |
| ref_oid = (reference_oid *)ref; |
| |
| /* File format: 40 chars (OID) + newline */ |
| if (file_content->len < GIT_OID_HEXSZ + 1) |
| return GIT_EREFCORRUPTED; |
| |
| if (git_oid_mkstr(&ref_oid->oid, buffer) < GIT_SUCCESS) |
| return GIT_EREFCORRUPTED; |
| |
| buffer = buffer + GIT_OID_HEXSZ; |
| if (*buffer == '\r') |
| buffer++; |
| |
| if (*buffer != '\n') |
| return GIT_EREFCORRUPTED; |
| |
| return GIT_SUCCESS; |
| } |
| |
| |
| static git_rtype loose_guess_rtype(const char *full_path) |
| { |
| gitfo_buf ref_file = GITFO_BUF_INIT; |
| git_rtype type; |
| |
| type = GIT_REF_INVALID; |
| |
| if (gitfo_read_file(&ref_file, full_path) == GIT_SUCCESS) { |
| if (git__prefixcmp((const char *)(ref_file.data), GIT_SYMREF) == 0) |
| type = GIT_REF_SYMBOLIC; |
| else |
| type = GIT_REF_OID; |
| } |
| |
| gitfo_free_buf(&ref_file); |
| return type; |
| } |
| |
| static int loose_lookup( |
| git_reference **ref_out, |
| git_repository *repo, |
| const char *name, |
| int skip_symbolic) |
| { |
| int error = GIT_SUCCESS; |
| gitfo_buf ref_file = GITFO_BUF_INIT; |
| git_reference *ref = NULL; |
| time_t ref_time; |
| |
| *ref_out = NULL; |
| |
| error = reference_read(&ref_file, &ref_time, repo->path_repository, name); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| if (git__prefixcmp((const char *)(ref_file.data), GIT_SYMREF) == 0) { |
| if (skip_symbolic) |
| return GIT_SUCCESS; |
| |
| error = reference_create(&ref, repo, name, GIT_REF_SYMBOLIC); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| error = loose_parse_symbolic(ref, &ref_file); |
| } else { |
| error = reference_create(&ref, repo, name, GIT_REF_OID); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| error = loose_parse_oid(ref, &ref_file); |
| } |
| |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| ref->mtime = ref_time; |
| *ref_out = ref; |
| return GIT_SUCCESS; |
| |
| cleanup: |
| gitfo_free_buf(&ref_file); |
| reference_free(ref); |
| return error; |
| } |
| |
| static int loose_write(git_reference *ref) |
| { |
| git_filebuf file; |
| char ref_path[GIT_PATH_MAX]; |
| int error, contents_size; |
| char *ref_contents = NULL; |
| struct stat st; |
| |
| assert((ref->type & GIT_REF_PACKED) == 0); |
| |
| 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; |
| |
| if (ref->type & GIT_REF_OID) { |
| reference_oid *ref_oid = (reference_oid *)ref; |
| |
| contents_size = GIT_OID_HEXSZ + 1; |
| ref_contents = git__malloc(contents_size); |
| if (ref_contents == NULL) { |
| error = GIT_ENOMEM; |
| goto unlock; |
| } |
| |
| git_oid_fmt(ref_contents, &ref_oid->oid); |
| |
| } else if (ref->type & GIT_REF_SYMBOLIC) { /* GIT_REF_SYMBOLIC */ |
| reference_symbolic *ref_sym = (reference_symbolic *)ref; |
| |
| contents_size = strlen(GIT_SYMREF) + strlen(ref_sym->target) + 1; |
| ref_contents = git__malloc(contents_size); |
| if (ref_contents == NULL) { |
| error = GIT_ENOMEM; |
| goto unlock; |
| } |
| |
| strcpy(ref_contents, GIT_SYMREF); |
| strcat(ref_contents, ref_sym->target); |
| } else { |
| error = GIT_EINVALIDREFSTATE; |
| goto unlock; |
| } |
| |
| /* TODO: win32 carriage return when writing references in Windows? */ |
| ref_contents[contents_size - 1] = '\n'; |
| |
| if ((error = git_filebuf_write(&file, ref_contents, contents_size)) < GIT_SUCCESS) |
| goto unlock; |
| |
| error = git_filebuf_commit(&file); |
| |
| if (gitfo_stat(ref_path, &st) == GIT_SUCCESS) |
| ref->mtime = st.st_mtime; |
| |
| free(ref_contents); |
| return error; |
| |
| unlock: |
| git_filebuf_cleanup(&file); |
| free(ref_contents); |
| return error; |
| } |
| |
| |
| |
| |
| |
| |
| /***************************************** |
| * Internal methods - Packed references |
| *****************************************/ |
| |
| static int packed_parse_peel( |
| reference_oid *tag_ref, |
| const char **buffer_out, |
| const char *buffer_end) |
| { |
| const char *buffer = *buffer_out + 1; |
| |
| assert(buffer[-1] == '^'); |
| |
| /* Ensure it's not the first entry of the file */ |
| if (tag_ref == NULL) |
| return GIT_EPACKEDREFSCORRUPTED; |
| |
| /* Ensure reference is a tag */ |
| if (git__prefixcmp(tag_ref->ref.name, GIT_REFS_TAGS_DIR) != 0) |
| return GIT_EPACKEDREFSCORRUPTED; |
| |
| if (buffer + GIT_OID_HEXSZ >= buffer_end) |
| return GIT_EPACKEDREFSCORRUPTED; |
| |
| /* Is this a valid object id? */ |
| if (git_oid_mkstr(&tag_ref->peel_target, buffer) < GIT_SUCCESS) |
| return GIT_EPACKEDREFSCORRUPTED; |
| |
| buffer = buffer + GIT_OID_HEXSZ; |
| if (*buffer == '\r') |
| buffer++; |
| |
| if (*buffer != '\n') |
| return GIT_EPACKEDREFSCORRUPTED; |
| |
| *buffer_out = buffer + 1; |
| tag_ref->ref.type |= GIT_REF_HAS_PEEL; |
| |
| return GIT_SUCCESS; |
| } |
| |
| static int packed_parse_oid( |
| reference_oid **ref_out, |
| git_repository *repo, |
| const char **buffer_out, |
| const char *buffer_end) |
| { |
| reference_oid *ref = NULL; |
| |
| const char *buffer = *buffer_out; |
| const char *refname_begin, *refname_end; |
| |
| int error = GIT_SUCCESS; |
| int refname_len; |
| char refname[MAX_GITDIR_TREE_STRUCTURE_PATH_LENGTH]; |
| git_oid id; |
| |
| refname_begin = (buffer + GIT_OID_HEXSZ + 1); |
| if (refname_begin >= buffer_end || |
| refname_begin[-1] != ' ') { |
| error = GIT_EPACKEDREFSCORRUPTED; |
| goto cleanup; |
| } |
| |
| /* Is this a valid object id? */ |
| if ((error = git_oid_mkstr(&id, buffer)) < GIT_SUCCESS) |
| goto cleanup; |
| |
| refname_end = memchr(refname_begin, '\n', buffer_end - refname_begin); |
| if (refname_end == NULL) { |
| error = GIT_EPACKEDREFSCORRUPTED; |
| goto cleanup; |
| } |
| |
| refname_len = refname_end - refname_begin; |
| |
| memcpy(refname, refname_begin, refname_len); |
| refname[refname_len] = 0; |
| |
| if (refname[refname_len - 1] == '\r') |
| refname[refname_len - 1] = 0; |
| |
| error = reference_create((git_reference **)&ref, repo, refname, GIT_REF_OID); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| git_oid_cpy(&ref->oid, &id); |
| ref->ref.type |= GIT_REF_PACKED; |
| |
| *ref_out = ref; |
| *buffer_out = refname_end + 1; |
| |
| return GIT_SUCCESS; |
| |
| cleanup: |
| reference_free((git_reference *)ref); |
| return error; |
| } |
| |
| static int packed_load(git_repository *repo) |
| { |
| int error = GIT_SUCCESS; |
| gitfo_buf packfile = GITFO_BUF_INIT; |
| const char *buffer_start, *buffer_end; |
| git_refcache *ref_cache = &repo->references; |
| |
| /* already loaded */ |
| if (repo->references.packfile != NULL) { |
| time_t packed_time; |
| |
| /* check if we can read the time of the index; |
| * if we can read it and it matches the time of the |
| * index we had previously loaded, we don't need to do |
| * anything else. |
| * |
| * if we cannot load the time (e.g. the packfile |
| * has disappeared) or the time is different, we |
| * have to reload the packfile */ |
| |
| if (!reference_read(NULL, &packed_time, repo->path_repository, GIT_PACKEDREFS_FILE) && |
| packed_time == ref_cache->packfile_time) |
| return GIT_SUCCESS; |
| |
| git_hashtable_clear(repo->references.packfile); |
| } else { |
| ref_cache->packfile = git_hashtable_alloc( |
| default_table_size, |
| reftable_hash, |
| (git_hash_keyeq_ptr)strcmp); |
| |
| if (ref_cache->packfile == NULL) |
| return GIT_ENOMEM; |
| } |
| |
| /* read the packfile from disk; |
| * store its modification time to check for future reloads */ |
| error = reference_read( |
| &packfile, |
| &ref_cache->packfile_time, |
| repo->path_repository, |
| GIT_PACKEDREFS_FILE); |
| |
| /* there is no packfile on disk; that's ok */ |
| if (error == GIT_ENOTFOUND) |
| return GIT_SUCCESS; |
| |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| buffer_start = (const char *)packfile.data; |
| buffer_end = (const char *)(buffer_start) + packfile.len; |
| |
| while (buffer_start < buffer_end && buffer_start[0] == '#') { |
| buffer_start = strchr(buffer_start, '\n'); |
| if (buffer_start == NULL) { |
| error = GIT_EPACKEDREFSCORRUPTED; |
| goto cleanup; |
| } |
| buffer_start++; |
| } |
| |
| while (buffer_start < buffer_end) { |
| reference_oid *ref = NULL; |
| |
| error = packed_parse_oid(&ref, repo, &buffer_start, buffer_end); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| if (buffer_start[0] == '^') { |
| error = packed_parse_peel(ref, &buffer_start, buffer_end); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| } |
| |
| error = git_hashtable_insert(ref_cache->packfile, ref->ref.name, ref); |
| if (error < GIT_SUCCESS) { |
| reference_free((git_reference *)ref); |
| goto cleanup; |
| } |
| } |
| |
| gitfo_free_buf(&packfile); |
| return GIT_SUCCESS; |
| |
| cleanup: |
| git_hashtable_free(ref_cache->packfile); |
| ref_cache->packfile = NULL; |
| gitfo_free_buf(&packfile); |
| return error; |
| } |
| |
| |
| |
| |
| struct dirent_list_data { |
| git_vector ref_list; |
| git_repository *repo; |
| size_t repo_path_len; |
| unsigned int list_flags; |
| }; |
| |
| static int _dirent_loose_listall(void *_data, char *full_path) |
| { |
| struct dirent_list_data *data = (struct dirent_list_data *)_data; |
| char *file_path = full_path + data->repo_path_len; |
| |
| if (gitfo_isdir(full_path) == GIT_SUCCESS) |
| return gitfo_dirent(full_path, GIT_PATH_MAX, _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; |
| |
| if ((data->list_flags & loose_guess_rtype(full_path)) == 0) |
| return GIT_SUCCESS; /* we are filtering out this reference */ |
| |
| return git_vector_insert(&data->ref_list, git__strdup(file_path)); |
| } |
| |
| static int _dirent_loose_load(void *data, char *full_path) |
| { |
| git_repository *repository = (git_repository *)data; |
| git_reference *reference, *old_ref; |
| char *file_path; |
| int error; |
| |
| if (gitfo_isdir(full_path) == GIT_SUCCESS) |
| return gitfo_dirent(full_path, GIT_PATH_MAX, _dirent_loose_load, repository); |
| |
| file_path = full_path + strlen(repository->path_repository); |
| error = loose_lookup(&reference, repository, file_path, 1); |
| if (error == GIT_SUCCESS && reference != NULL) { |
| reference->type |= GIT_REF_PACKED; |
| |
| if (git_hashtable_insert2(repository->references.packfile, reference->name, reference, (void **)&old_ref) < GIT_SUCCESS) { |
| reference_free(reference); |
| return GIT_ENOMEM; |
| } |
| |
| if (old_ref != NULL) |
| reference_free(old_ref); |
| } |
| |
| return error; |
| } |
| |
| /* |
| * Load all the loose references from the repository |
| * into the in-memory Packfile, and build a vector with |
| * all the references so it can be written back to |
| * disk. |
| */ |
| static int packed_loadloose(git_repository *repository) |
| { |
| char refs_path[GIT_PATH_MAX]; |
| |
| /* the packfile must have been previously loaded! */ |
| assert(repository->references.packfile); |
| |
| git__joinpath(refs_path, repository->path_repository, GIT_REFS_DIR); |
| |
| /* Remove any loose references from the cache */ |
| { |
| const void *_unused; |
| git_reference *reference; |
| |
| GIT_HASHTABLE_FOREACH(repository->references.loose_cache, _unused, reference, |
| reference_free(reference); |
| ); |
| } |
| |
| git_hashtable_clear(repository->references.loose_cache); |
| |
| /* |
| * Load all the loose files from disk into the Packfile table. |
| * This will overwrite any old packed entries with their |
| * updated loose versions |
| */ |
| return gitfo_dirent(refs_path, GIT_PATH_MAX, _dirent_loose_load, repository); |
| } |
| |
| /* |
| * Write a single reference into a packfile |
| */ |
| static int packed_write_ref(reference_oid *ref, git_filebuf *file) |
| { |
| int error; |
| char oid[GIT_OID_HEXSZ + 1]; |
| |
| git_oid_fmt(oid, &ref->oid); |
| oid[GIT_OID_HEXSZ] = 0; |
| |
| /* |
| * For references that peel to an object in the repo, we must |
| * write the resulting peel on a separate line, e.g. |
| * |
| * 6fa8a902cc1d18527e1355773c86721945475d37 refs/tags/libgit2-0.4 |
| * ^2ec0cb7959b0bf965d54f95453f5b4b34e8d3100 |
| * |
| * This obviously only applies to tags. |
| * The required peels have already been loaded into `ref->peel_target`. |
| */ |
| if (ref->ref.type & GIT_REF_HAS_PEEL) { |
| char peel[GIT_OID_HEXSZ + 1]; |
| git_oid_fmt(peel, &ref->peel_target); |
| peel[GIT_OID_HEXSZ] = 0; |
| |
| error = git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->ref.name, peel); |
| } else { |
| error = git_filebuf_printf(file, "%s %s\n", oid, ref->ref.name); |
| } |
| |
| return error; |
| } |
| |
| /* |
| * Find out what object this reference resolves to. |
| * |
| * For references that point to a 'big' tag (e.g. an |
| * actual tag object on the repository), we need to |
| * cache on the packfile the OID of the object to |
| * which that 'big tag' is pointing to. |
| */ |
| static int packed_find_peel(reference_oid *ref) |
| { |
| git_tag *tag; |
| int error; |
| |
| if (ref->ref.type & GIT_REF_HAS_PEEL) |
| return GIT_SUCCESS; |
| |
| /* |
| * Only applies to tags, i.e. references |
| * in the /refs/tags folder |
| */ |
| if (git__prefixcmp(ref->ref.name, GIT_REFS_TAGS_DIR) != 0) |
| return GIT_SUCCESS; |
| |
| /* |
| * Find the tag in the repository. The tag must exist, |
| * otherwise this reference is broken and we shouldn't |
| * pack it. |
| */ |
| error = git_tag_lookup(&tag, ref->ref.owner, &ref->oid); |
| if (error < GIT_SUCCESS) |
| return GIT_EOBJCORRUPTED; |
| |
| /* |
| * Find the object pointed at by this tag |
| */ |
| git_oid_cpy(&ref->peel_target, git_tag_target_oid(tag)); |
| ref->ref.type |= GIT_REF_HAS_PEEL; |
| |
| /* |
| * The reference has now cached the resolved OID, and is |
| * marked at such. When written to the packfile, it'll be |
| * accompanied by this resolved oid |
| */ |
| |
| return GIT_SUCCESS; |
| } |
| |
| /* |
| * Remove all loose references |
| * |
| * Once we have successfully written a packfile, |
| * all the loose references that were packed must be |
| * removed from disk. |
| * |
| * This is a dangerous method; make sure the packfile |
| * is well-written, because we are destructing references |
| * here otherwise. |
| */ |
| static int packed_remove_loose(git_repository *repo, git_vector *packing_list) |
| { |
| unsigned int i; |
| char full_path[GIT_PATH_MAX]; |
| int error = GIT_SUCCESS; |
| git_reference *reference; |
| |
| for (i = 0; i < packing_list->length; ++i) { |
| git_reference *ref = git_vector_get(packing_list, i); |
| |
| /* Ensure the packed reference doesn't exist |
| * in a (more up-to-date?) state as a loose reference |
| */ |
| reference = git_hashtable_lookup(ref->owner->references.loose_cache, ref->name); |
| if (reference != NULL) |
| continue; |
| |
| git__joinpath(full_path, repo->path_repository, ref->name); |
| |
| if (gitfo_exists(full_path) == GIT_SUCCESS && |
| gitfo_unlink(full_path) < GIT_SUCCESS) |
| error = GIT_EOSERR; |
| |
| /* |
| * if we fail to remove a single file, this is *not* good, |
| * but we should keep going and remove as many as possible. |
| * After we've removed as many files as possible, we return |
| * the error code anyway. |
| * |
| * TODO: mark this with a very special error code? |
| * GIT_EFAILTORMLOOSE |
| */ |
| } |
| |
| return error; |
| } |
| |
| static int packed_sort(const void *a, const void *b) |
| { |
| const git_reference *ref_a = *(const git_reference **)a; |
| const git_reference *ref_b = *(const git_reference **)b; |
| |
| return strcmp(ref_a->name, ref_b->name); |
| } |
| |
| /* |
| * Write all the contents in the in-memory packfile to disk. |
| */ |
| static int packed_write(git_repository *repo) |
| { |
| git_filebuf pack_file; |
| int error; |
| unsigned int i; |
| char pack_file_path[GIT_PATH_MAX]; |
| |
| git_vector packing_list; |
| size_t 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 error; |
| |
| /* Load all the packfile into a vector */ |
| { |
| git_reference *reference; |
| const void *_unused; |
| |
| GIT_HASHTABLE_FOREACH(repo->references.packfile, _unused, reference, |
| git_vector_insert(&packing_list, reference); /* cannot fail: vector already has the right size */ |
| ); |
| } |
| |
| /* sort the vector so the entries appear sorted on the packfile */ |
| git_vector_sort(&packing_list); |
| |
| /* 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; |
| |
| /* 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; |
| |
| for (i = 0; i < packing_list.length; ++i) { |
| reference_oid *ref = (reference_oid *)git_vector_get(&packing_list, i); |
| |
| /* only direct references go to the packfile; otherwise |
| * this is a disaster */ |
| assert(ref->ref.type & GIT_REF_OID); |
| |
| if ((error = packed_find_peel(ref)) < GIT_SUCCESS) |
| goto cleanup; |
| |
| if ((error = packed_write_ref(ref, &pack_file)) < GIT_SUCCESS) |
| goto cleanup; |
| } |
| |
| 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); |
| |
| /* 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; |
| |
| error = packed_remove_loose(repo, &packing_list); |
| |
| if (gitfo_stat(pack_file_path, &st) == GIT_SUCCESS) |
| repo->references.packfile_time = st.st_mtime; |
| } |
| } |
| else git_filebuf_cleanup(&pack_file); |
| |
| git_vector_free(&packing_list); |
| |
| return error; |
| } |
| |
| |
| |
| |
| /***************************************** |
| * External Library API |
| *****************************************/ |
| |
| /** |
| * Constructors |
| */ |
| int git_reference_lookup(git_reference **ref_out, git_repository *repo, const char *name) |
| { |
| int error; |
| char normalized_name[GIT_PATH_MAX]; |
| |
| assert(ref_out && repo && name); |
| |
| *ref_out = NULL; |
| |
| error = normalize_name(normalized_name, name, 0); |
| if (error < GIT_SUCCESS) |
| return error; |
| |
| /* First, check has been previously loaded and cached */ |
| *ref_out = git_hashtable_lookup(repo->references.loose_cache, normalized_name); |
| if (*ref_out != NULL) |
| return loose_update(*ref_out); |
| |
| /* Then check if there is a loose file for that reference.*/ |
| error = loose_lookup(ref_out, repo, normalized_name, 0); |
| |
| /* If the file exists, we store it on the cache */ |
| if (error == GIT_SUCCESS) |
| return git_hashtable_insert(repo->references.loose_cache, (*ref_out)->name, (*ref_out)); |
| |
| /* 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; |
| |
| /* |
| * If we cannot find a loose reference, we look into the packfile |
| * Load the packfile first if it hasn't been loaded |
| */ |
| /* load all the packed references */ |
| error = packed_load(repo); |
| if (error < GIT_SUCCESS) |
| return error; |
| |
| /* Look up on the packfile */ |
| *ref_out = git_hashtable_lookup(repo->references.packfile, normalized_name); |
| if (*ref_out != NULL) |
| return GIT_SUCCESS; |
| |
| /* The reference doesn't exist anywhere */ |
| return GIT_ENOTFOUND; |
| } |
| |
| int git_reference_create_symbolic(git_reference **ref_out, git_repository *repo, const char *name, const char *target) |
| { |
| char normalized[MAX_GITDIR_TREE_STRUCTURE_PATH_LENGTH]; |
| int error = GIT_SUCCESS; |
| git_reference *ref = NULL; |
| |
| error = reference_create(&ref, repo, name, GIT_REF_SYMBOLIC); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| /* The target can aither be the name of an object id reference or the name of another symbolic reference */ |
| error = normalize_name(normalized, target, 0); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| /* set the target; this will write the reference on disk */ |
| error = git_reference_set_target(ref, normalized); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| error = git_hashtable_insert(repo->references.loose_cache, ref->name, ref); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| *ref_out = ref; |
| |
| return error; |
| |
| cleanup: |
| reference_free(ref); |
| return error; |
| } |
| |
| int git_reference_create_oid(git_reference **ref_out, git_repository *repo, const char *name, const git_oid *id) |
| { |
| int error = GIT_SUCCESS; |
| git_reference *ref = NULL; |
| |
| error = reference_create(&ref, repo, name, GIT_REF_OID); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| /* set the oid; this will write the reference on disk */ |
| error = git_reference_set_oid(ref, id); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| error = git_hashtable_insert(repo->references.loose_cache, ref->name, ref); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| *ref_out = ref; |
| |
| return error; |
| |
| cleanup: |
| reference_free(ref); |
| return error; |
| } |
| |
| |
| /** |
| * Getters |
| */ |
| git_rtype git_reference_type(git_reference *ref) |
| { |
| assert(ref); |
| |
| if (ref->type & GIT_REF_OID) |
| return GIT_REF_OID; |
| |
| if (ref->type & GIT_REF_SYMBOLIC) |
| return GIT_REF_SYMBOLIC; |
| |
| return GIT_REF_INVALID; |
| } |
| |
| const char *git_reference_name(git_reference *ref) |
| { |
| assert(ref); |
| return ref->name; |
| } |
| |
| git_repository *git_reference_owner(git_reference *ref) |
| { |
| assert(ref); |
| return ref->owner; |
| } |
| |
| const git_oid *git_reference_oid(git_reference *ref) |
| { |
| assert(ref); |
| |
| if ((ref->type & GIT_REF_OID) == 0) |
| return NULL; |
| |
| if (loose_update(ref) < GIT_SUCCESS) |
| return NULL; |
| |
| return &((reference_oid *)ref)->oid; |
| } |
| |
| const char *git_reference_target(git_reference *ref) |
| { |
| assert(ref); |
| |
| if ((ref->type & GIT_REF_SYMBOLIC) == 0) |
| return NULL; |
| |
| if (loose_update(ref) < GIT_SUCCESS) |
| return NULL; |
| |
| return ((reference_symbolic *)ref)->target; |
| } |
| |
| /** |
| * Setters |
| */ |
| |
| /* |
| * Change the OID target of a reference. |
| * |
| * For loose references, just change the oid in memory |
| * and overwrite the file in disk. |
| * |
| * For packed files, this is not pretty: |
| * For performance reasons, we write the new reference |
| * loose on disk (it replaces the old on the packfile), |
| * but we cannot invalidate the pointer to the reference, |
| * and most importantly, the `packfile` object must stay |
| * consistent with the representation of the packfile |
| * on disk. This is what we need to: |
| * |
| * 1. Copy the reference |
| * 2. Change the oid on the original |
| * 3. Write the original to disk |
| * 4. Write the original to the loose cache |
| * 5. Replace the original with the copy (old reference) in the packfile cache |
| */ |
| int git_reference_set_oid(git_reference *ref, const git_oid *id) |
| { |
| reference_oid *ref_oid; |
| reference_oid *ref_old = NULL; |
| int error = GIT_SUCCESS; |
| |
| if ((ref->type & GIT_REF_OID) == 0) |
| return GIT_EINVALIDREFSTATE; |
| |
| ref_oid = (reference_oid *)ref; |
| |
| /* duplicate the reference; |
| * this copy will stay on the packfile cache */ |
| if (ref->type & GIT_REF_PACKED) { |
| ref_old = git__malloc(sizeof(reference_oid)); |
| if (ref_old == NULL) |
| return GIT_ENOMEM; |
| |
| ref_old->ref.name = git__strdup(ref->name); |
| if (ref_old->ref.name == NULL) { |
| free(ref_old); |
| return GIT_ENOMEM; |
| } |
| } |
| |
| git_oid_cpy(&ref_oid->oid, id); |
| ref->type &= ~GIT_REF_HAS_PEEL; |
| |
| error = loose_write(ref); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| if (ref->type & GIT_REF_PACKED) { |
| /* insert the original on the loose cache */ |
| error = git_hashtable_insert(ref->owner->references.loose_cache, ref->name, ref); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| ref->type &= ~GIT_REF_PACKED; |
| |
| /* replace the original in the packfile with the copy */ |
| error = git_hashtable_insert(ref->owner->references.packfile, ref_old->ref.name, ref_old); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| } |
| |
| return GIT_SUCCESS; |
| |
| cleanup: |
| reference_free((git_reference *)ref_old); |
| return error; |
| } |
| |
| /* |
| * Change the target of a symbolic reference. |
| * |
| * This is easy because symrefs cannot be inside |
| * a pack. We just change the target in memory |
| * and overwrite the file on disk. |
| */ |
| 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; |
| |
| ref_sym = (reference_symbolic *)ref; |
| |
| free(ref_sym->target); |
| ref_sym->target = git__strdup(target); |
| if (ref_sym->target == NULL) |
| return GIT_ENOMEM; |
| |
| return loose_write(ref); |
| } |
| |
| /** |
| * Other |
| */ |
| |
| /* |
| * Delete a reference. |
| * |
| * If the reference is packed, this is an expensive |
| * operation. We need to remove the reference from |
| * the memory cache and then rewrite the whole pack |
| * |
| * If the reference is loose, we remove it on |
| * the filesystem and update the in-memory cache |
| * accordingly. We also make sure that an older version |
| * of it doesn't exist as a packed reference. If this |
| * is the case, this packed reference is removed as well. |
| * |
| * This obviously invalidates the `ref` pointer. |
| */ |
| int git_reference_delete(git_reference *ref) |
| { |
| int error; |
| git_reference *reference; |
| |
| assert(ref); |
| |
| if (ref->type & GIT_REF_PACKED) { |
| git_hashtable_remove(ref->owner->references.packfile, ref->name); |
| error = packed_write(ref->owner); |
| } else { |
| char full_path[GIT_PATH_MAX]; |
| git__joinpath(full_path, ref->owner->path_repository, ref->name); |
| git_hashtable_remove(ref->owner->references.loose_cache, ref->name); |
| error = gitfo_unlink(full_path); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| /* When deleting a loose reference, we have to ensure that an older |
| * packed version of it doesn't exist |
| */ |
| if (!git_reference_lookup(&reference, ref->owner, ref->name)) { |
| assert((reference->type & GIT_REF_PACKED) != 0); |
| error = git_reference_delete(reference); |
| } |
| } |
| |
| cleanup: |
| reference_free(ref); |
| return error; |
| } |
| |
| /* |
| * Rename a reference |
| * |
| * If the reference is packed, we need to rewrite the |
| * packfile to remove the reference from it and create |
| * the reference back as a loose one. |
| * |
| * If the reference is loose, we just rename it on |
| * the filesystem. |
| * |
| * We also need to re-insert the reference on its corresponding |
| * in-memory cache, since the caches are indexed by refname. |
| */ |
| int git_reference_rename(git_reference *ref, const char *new_name) |
| { |
| int error; |
| char *old_name; |
| char old_path[GIT_PATH_MAX], new_path[GIT_PATH_MAX], normalized_name[MAX_GITDIR_TREE_STRUCTURE_PATH_LENGTH]; |
| git_reference *looked_up_ref; |
| |
| assert(ref); |
| |
| /* Ensure the name is valid */ |
| error = normalize_name(normalized_name, new_name, ref->type & GIT_REF_OID); |
| if (error < GIT_SUCCESS) |
| return error; |
| |
| /* Ensure we're not going to overwrite an existing reference */ |
| error = git_reference_lookup(&looked_up_ref, ref->owner, new_name); |
| if (error == GIT_SUCCESS) |
| return GIT_EINVALIDREFNAME; |
| |
| if (error != GIT_ENOTFOUND) |
| return error; |
| |
| |
| old_name = ref->name; |
| ref->name = git__strdup(new_name); |
| |
| if (ref->name == NULL) { |
| ref->name = old_name; |
| return GIT_ENOMEM; |
| } |
| |
| if (ref->type & GIT_REF_PACKED) { |
| /* write the packfile to disk; note |
| * that the state of the in-memory cache is not |
| * consistent, because the reference is indexed |
| * by its old name but it already has the new one. |
| * This doesn't affect writing, though, and allows |
| * us to rollback if writing fails |
| */ |
| |
| ref->type &= ~GIT_REF_PACKED; |
| |
| /* Create the loose ref under its new name */ |
| error = loose_write(ref); |
| if (error < GIT_SUCCESS) { |
| ref->type |= GIT_REF_PACKED; |
| goto cleanup; |
| } |
| |
| /* Remove from the packfile cache in order to avoid packing it back |
| * Note : we do not rely on git_reference_delete() because this would |
| * invalidate the reference. |
| */ |
| git_hashtable_remove(ref->owner->references.packfile, old_name); |
| |
| /* Recreate the packed-refs file without the reference */ |
| error = packed_write(ref->owner); |
| if (error < GIT_SUCCESS) |
| goto rename_loose_to_old_name; |
| |
| } else { |
| git__joinpath(old_path, ref->owner->path_repository, old_name); |
| git__joinpath(new_path, ref->owner->path_repository, ref->name); |
| |
| error = gitfo_mv_force(old_path, new_path); |
| if (error < GIT_SUCCESS) |
| goto cleanup; |
| |
| /* Once succesfully renamed, remove from the cache the reference known by its old name*/ |
| git_hashtable_remove(ref->owner->references.loose_cache, old_name); |
| } |
| |
| /* Store the renamed reference into the loose ref cache */ |
| error = git_hashtable_insert(ref->owner->references.loose_cache, ref->name, ref); |
| |
| free(old_name); |
| return error; |
| |
| cleanup: |
| /* restore the old name if this failed */ |
| free(ref->name); |
| ref->name = old_name; |
| return error; |
| |
| rename_loose_to_old_name: |
| /* If we hit this point. Something *bad* happened! Think "Ghostbusters |
| * crossing the streams" definition of bad. |
| * Either the packed-refs has been correctly generated and something else |
| * has gone wrong, or the writing of the new packed-refs has failed, and |
| * we're stuck with the old one. As a loose ref always takes priority over |
| * a packed ref, we'll eventually try and rename the generated loose ref to |
| * its former name. It even that fails, well... we might have lost the reference |
| * for good. :-/ |
| */ |
| |
| git__joinpath(old_path, ref->owner->path_repository, ref->name); |
| git__joinpath(new_path, ref->owner->path_repository, old_name); |
| |
| /* No error checking. We'll return the initial error */ |
| gitfo_mv_force(old_path, new_path); |
| |
| /* restore the old name */ |
| free(ref->name); |
| ref->name = old_name; |
| |
| return error; |
| } |
| |
| int git_reference_resolve(git_reference **resolved_ref, git_reference *ref) |
| { |
| git_repository *repo; |
| int error, i; |
| |
| assert(resolved_ref && ref); |
| *resolved_ref = NULL; |
| |
| if ((error = loose_update(ref)) < GIT_SUCCESS) |
| return error; |
| |
| repo = ref->owner; |
| |
| for (i = 0; i < MAX_NESTING_LEVEL; ++i) { |
| reference_symbolic *ref_sym; |
| |
| if (ref->type & GIT_REF_OID) { |
| *resolved_ref = ref; |
| return GIT_SUCCESS; |
| } |
| |
| ref_sym = (reference_symbolic *)ref; |
| if ((error = git_reference_lookup(&ref, repo, ref_sym->target)) < GIT_SUCCESS) |
| return error; |
| } |
| |
| return GIT_ETOONESTEDSYMREF; |
| } |
| |
| int git_reference_packall(git_repository *repo) |
| { |
| int error; |
| |
| /* load the existing packfile */ |
| if ((error = packed_load(repo)) < GIT_SUCCESS) |
| return error; |
| |
| /* update it in-memory with all the loose references */ |
| if ((error = packed_loadloose(repo)) < GIT_SUCCESS) |
| return error; |
| |
| /* write it back to disk */ |
| return packed_write(repo); |
| } |
| |
| int git_reference_listall(git_strarray *array, git_repository *repo, unsigned int list_flags) |
| { |
| int error; |
| struct dirent_list_data data; |
| char refs_path[GIT_PATH_MAX]; |
| |
| array->strings = NULL; |
| array->count = 0; |
| |
| git_vector_init(&data.ref_list, 8, NULL); |
| data.repo_path_len = strlen(repo->path_repository); |
| data.list_flags = list_flags; |
| data.repo = repo; |
| |
| /* list all the packed references first */ |
| if (list_flags & GIT_REF_PACKED) { |
| const char *ref_name; |
| void *_unused; |
| |
| if ((error = packed_load(repo)) < GIT_SUCCESS) { |
| git_vector_free(&data.ref_list); |
| return error; |
| } |
| |
| GIT_HASHTABLE_FOREACH(repo->references.packfile, ref_name, _unused, |
| git_vector_insert(&data.ref_list, git__strdup(ref_name)); |
| ); |
| } |
| |
| /* now list the loose references, trying not to |
| * duplicate the ref names already in the packed-refs file */ |
| git__joinpath(refs_path, repo->path_repository, GIT_REFS_DIR); |
| error = gitfo_dirent(refs_path, GIT_PATH_MAX, _dirent_loose_listall, &data); |
| |
| if (error < GIT_SUCCESS) { |
| git_vector_free(&data.ref_list); |
| return error; |
| } |
| |
| array->strings = (char **)data.ref_list.contents; |
| array->count = data.ref_list.length; |
| return GIT_SUCCESS; |
| } |
| |
| |
| |
| |
| /***************************************** |
| * Init/free (repository API) |
| *****************************************/ |
| int git_repository__refcache_init(git_refcache *refs) |
| { |
| assert(refs); |
| |
| refs->loose_cache = git_hashtable_alloc( |
| default_table_size, |
| reftable_hash, |
| (git_hash_keyeq_ptr)strcmp); |
| |
| /* packfile loaded lazily */ |
| refs->packfile = NULL; |
| |
| return (refs->loose_cache) ? GIT_SUCCESS : GIT_ENOMEM; |
| } |
| |
| void git_repository__refcache_free(git_refcache *refs) |
| { |
| git_reference *reference; |
| const void *_unused; |
| |
| assert(refs); |
| |
| GIT_HASHTABLE_FOREACH(refs->loose_cache, _unused, reference, |
| reference_free(reference); |
| ); |
| |
| git_hashtable_free(refs->loose_cache); |
| |
| if (refs->packfile) { |
| GIT_HASHTABLE_FOREACH(refs->packfile, _unused, reference, |
| reference_free(reference); |
| ); |
| |
| git_hashtable_free(refs->packfile); |
| } |
| } |
| |
| |
| |
| /***************************************** |
| * Name normalization |
| *****************************************/ |
| static int check_valid_ref_char(char ch) |
| { |
| if (ch <= ' ') |
| return GIT_ERROR; |
| |
| switch (ch) { |
| case '~': |
| case '^': |
| case ':': |
| case '\\': |
| case '?': |
| case '[': |
| case '*': |
| return GIT_ERROR; |
| break; |
| |
| default: |
| return GIT_SUCCESS; |
| } |
| } |
| |
| static int normalize_name(char *buffer_out, const char *name, int is_oid_ref) |
| { |
| int error = GIT_SUCCESS; |
| const char *name_end, *buffer_out_start; |
| char *current; |
| int contains_a_slash = 0; |
| |
| assert(name && buffer_out); |
| |
| buffer_out_start = buffer_out; |
| current = (char *)name; |
| name_end = name + strlen(name); |
| |
| /* A refname can not be empty */ |
| if (name_end == name) |
| return GIT_EINVALIDREFNAME; |
| |
| /* A refname can not end with a dot or a slash */ |
| if (*(name_end - 1) == '.' || *(name_end - 1) == '/') |
| return GIT_EINVALIDREFNAME; |
| |
| while (current < name_end) { |
| if (check_valid_ref_char(*current)) |
| return GIT_EINVALIDREFNAME; |
| |
| 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; |
| |
| /* '@{' is forbidden within a refname */ |
| if (*current == '{' && prev == '@') |
| return GIT_EINVALIDREFNAME; |
| |
| /* Prevent multiple slashes from being added to the output */ |
| if (*current == '/' && prev == '/') { |
| current++; |
| continue; |
| } |
| } |
| |
| if (*current == '/') |
| contains_a_slash = 1; |
| |
| *buffer_out++ = *current++; |
| } |
| |
| /* Object id refname have to contain at least one slash */ |
| if (is_oid_ref && !contains_a_slash) |
| return GIT_EINVALIDREFNAME; |
| |
| /* A refname can not end with ".lock" */ |
| if (!git__suffixcmp(name, GIT_FILELOCK_EXTENSION)) |
| return GIT_EINVALIDREFNAME; |
| |
| *buffer_out = '\0'; |
| |
| /* For object id references, name has to start with refs/(heads|tags|remotes) */ |
| if (is_oid_ref && !(!git__prefixcmp(buffer_out_start, GIT_REFS_HEADS_DIR) || |
| !git__prefixcmp(buffer_out_start, GIT_REFS_TAGS_DIR) || !git__prefixcmp(buffer_out_start, GIT_REFS_REMOTES_DIR))) |
| return GIT_EINVALIDREFNAME; |
| |
| return error; |
| } |
| |
| int git_reference__normalize_name(char *buffer_out, const char *name) |
| { |
| return normalize_name(buffer_out, name, 0); |
| } |
| |
| int git_reference__normalize_name_oid(char *buffer_out, const char *name) |
| { |
| return normalize_name(buffer_out, name, 1); |
| } |
| |
| |