/* * 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(git_fbuffer *file_content, time_t *mtime, const char *repo_path, const char *ref_name, int *updated); /* loose refs */ static int loose_parse_symbolic(git_reference *ref, git_fbuffer *file_content); static int loose_parse_oid(git_reference *ref, git_fbuffer *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); /* internal helpers */ static int reference_available(git_repository *repo, const char *ref, const char *old_ref); /* name normalization */ static int check_valid_ref_char(char ch); static int normalize_name(char *buffer_out, size_t out_size, 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[GIT_REFNAME_MAX]; 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__throw(GIT_EINVALIDARGS, "Invalid reference type. Use either GIT_REF_OID or GIT_REF_SYMBOLIC as type specifier"); reference = git__malloc(size); if (reference == NULL) return GIT_ENOMEM; memset(reference, 0x0, size); reference->owner = repo; reference->type = type; error = normalize_name(normalized, sizeof(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 == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create reference"); cleanup: reference_free(reference); return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create reference"); } static int reference_read(git_fbuffer *file_content, time_t *mtime, const char *repo_path, const char *ref_name, int *updated) { char path[GIT_PATH_MAX]; assert(file_content && repo_path && ref_name); /* Determine the full path of the file */ git_path_join(path, repo_path, ref_name); return git_futils_readbuffer_updated(file_content, path, mtime, updated); return GIT_SUCCESS; } /***************************************** * Internal methods - Loose references *****************************************/ static int loose_update(git_reference *ref) { int error, updated; git_fbuffer ref_file = GIT_FBUFFER_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, &updated); if (error < GIT_SUCCESS) goto cleanup; if (!updated) 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__throw(GIT_EOBJCORRUPTED, "Invalid reference type (%d) for loose reference", ref->type); cleanup: git_futils_freebuffer(&ref_file); if (error != GIT_SUCCESS) { reference_free(ref); git_hashtable_remove(ref->owner->references.loose_cache, ref->name); } return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to update loose reference"); } static int loose_parse_symbolic(git_reference *ref, git_fbuffer *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__throw(GIT_EOBJCORRUPTED, "Failed to parse loose reference. Object too short"); /* * 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__throw(GIT_EOBJCORRUPTED, "Failed to parse loose reference. Missing EOL"); *eol = '\0'; if (eol[-1] == '\r') eol[-1] = '\0'; return GIT_SUCCESS; } static int loose_parse_oid(git_reference *ref, git_fbuffer *file_content) { int error; 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__throw(GIT_EOBJCORRUPTED, "Failed to parse loose reference. Reference too short"); if ((error = git_oid_fromstr(&ref_oid->oid, buffer)) < GIT_SUCCESS) return git__rethrow(GIT_EOBJCORRUPTED, "Failed to parse loose reference."); buffer = buffer + GIT_OID_HEXSZ; if (*buffer == '\r') buffer++; if (*buffer != '\n') return git__throw(GIT_EOBJCORRUPTED, "Failed to parse loose reference. Missing EOL"); return GIT_SUCCESS; } static git_rtype loose_guess_rtype(const char *full_path) { git_fbuffer ref_file = GIT_FBUFFER_INIT; git_rtype type; type = GIT_REF_INVALID; if (git_futils_readbuffer(&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; } git_futils_freebuffer(&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; git_fbuffer ref_file = GIT_FBUFFER_INIT; git_reference *ref = NULL; time_t ref_time = 0; *ref_out = NULL; error = reference_read(&ref_file, &ref_time, repo->path_repository, name, NULL); 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; git_futils_freebuffer(&ref_file); return GIT_SUCCESS; cleanup: git_futils_freebuffer(&ref_file); reference_free(ref); return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to lookup loose reference"); } static int loose_write(git_reference *ref) { git_filebuf file; char ref_path[GIT_PATH_MAX]; int error; struct stat st; git_path_join(ref_path, ref->owner->path_repository, ref->name); if ((error = git_filebuf_open(&file, ref_path, GIT_FILEBUF_FORCE)) < GIT_SUCCESS) return git__rethrow(error, "Failed to write loose reference"); if (ref->type & GIT_REF_OID) { reference_oid *ref_oid = (reference_oid *)ref; char oid[GIT_OID_HEXSZ + 1]; memset(oid, 0x0, sizeof(oid)); git_oid_fmt(oid, &ref_oid->oid); error = git_filebuf_printf(&file, "%s\n", oid); if (error < GIT_SUCCESS) goto unlock; } else if (ref->type & GIT_REF_SYMBOLIC) { /* GIT_REF_SYMBOLIC */ reference_symbolic *ref_sym = (reference_symbolic *)ref; error = git_filebuf_printf(&file, GIT_SYMREF "%s\n", ref_sym->target); } else { error = git__throw(GIT_EOBJCORRUPTED, "Failed to write reference. Invalid reference type"); goto unlock; } error = git_filebuf_commit(&file); if (p_stat(ref_path, &st) == GIT_SUCCESS) ref->mtime = st.st_mtime; return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write loose reference"); unlock: git_filebuf_cleanup(&file); return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write loose reference"); } /***************************************** * 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__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__throw(GIT_EPACKEDREFSCORRUPTED, "Failed to parse packed reference. Reference is not a tag"); if (buffer + GIT_OID_HEXSZ >= buffer_end) return git__throw(GIT_EPACKEDREFSCORRUPTED, "Failed to parse packed reference. Buffer too small"); /* Is this a valid object id? */ if (git_oid_fromstr(&tag_ref->peel_target, buffer) < GIT_SUCCESS) 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__throw(GIT_EPACKEDREFSCORRUPTED, "Failed to parse packed reference. Buffer not terminated correctly"); *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[GIT_REFNAME_MAX]; 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_fromstr(&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 == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to parse OID of packed reference"); } static int packed_load(git_repository *repo) { int error = GIT_SUCCESS, updated; git_fbuffer packfile = GIT_FBUFFER_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, reftable_hash, (git_hash_keyeq_ptr)strcmp); if (ref_cache->packfile == NULL) { error = GIT_ENOMEM; goto cleanup; } } error = reference_read(&packfile, &ref_cache->packfile_time, repo->path_repository, GIT_PACKEDREFS_FILE, &updated); /* * If we couldn't find the file, we need to clear the table and * return. On any other error, we return that error. If everything * went fine and the file wasn't updated, then there's nothing new * 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; } /* * At this point, we want to refresh the packed refs. We already * have the contents in our buffer. */ git_hashtable_clear(ref_cache->packfile); 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; } } git_futils_freebuffer(&packfile); return GIT_SUCCESS; cleanup: git_hashtable_free(ref_cache->packfile); ref_cache->packfile = NULL; git_futils_freebuffer(&packfile); return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to load packed references"); } struct dirent_list_data { git_repository *repo; size_t repo_path_len; unsigned int list_flags; int (*callback)(const char *, void *); void *callback_payload; }; 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 (git_futils_isdir(full_path) == GIT_SUCCESS) return git_futils_direach(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 != GIT_REF_LISTALL) { if ((data->list_flags & loose_guess_rtype(full_path)) == 0) return GIT_SUCCESS; /* we are filtering out this reference */ } return data->callback(file_path, data->callback_payload); } 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 (git_futils_isdir(full_path) == GIT_SUCCESS) return git_futils_direach(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 == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to load loose dirent"); } /* * 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_path_join(refs_path, repository->path_repository, GIT_REFS_DIR); /* Remove any loose references from the cache */ { const void *GIT_UNUSED(_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 git_futils_direach(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 == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write packed reference"); } /* * 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_object *object; 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 tagged object in the repository */ error = git_object_lookup(&object, ref->ref.owner, &ref->oid, GIT_OBJ_ANY); if (error < GIT_SUCCESS) return git__throw(GIT_EOBJCORRUPTED, "Failed to find packed reference"); /* * If the tagged object is a Tag object, we need to resolve it; * if the ref is actually a 'weak' ref, we don't need to resolve * anything. */ if (git_object_type(object) == GIT_OBJ_TAG) { git_tag *tag = (git_tag *)object; /* * 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 */ } git_object_close(object); 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_path_join(full_path, repo->path_repository, ref->name); if (git_futils_exists(full_path) == GIT_SUCCESS && p_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 == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to remove loose packed reference"); } 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 git__rethrow(error, "Failed to write packed reference"); /* Load all the packfile into a vector */ { git_reference *reference; const void *GIT_UNUSED(_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_path_join(pack_file_path, repo->path_repository, GIT_PACKEDREFS_FILE); if ((error = git_filebuf_open(&pack_file, pack_file_path, 0)) < GIT_SUCCESS) 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 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); /* 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) { error = git__throw(GIT_EOBJCORRUPTED, "A reference cannot be peeled"); 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 (p_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 == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to write packed reference"); } static int _reference_available_cb(const char *ref, void *data) { const char *new, *old; git_vector *refs; assert(ref && data); refs = (git_vector *)data; new = (const char *)git_vector_get(refs, 0); old = (const char *)git_vector_get(refs, 1); 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; } return GIT_SUCCESS; } static int reference_available(git_repository *repo, const char *ref, const char* old_ref) { int error; git_vector refs; if (git_vector_init(&refs, 2, NULL) < GIT_SUCCESS) return GIT_ENOMEM; git_vector_insert(&refs, (void *)ref); git_vector_insert(&refs, (void *)old_ref); error = git_reference_foreach(repo, GIT_REF_LISTALL, _reference_available_cb, (void *)&refs); git_vector_free(&refs); return error == GIT_SUCCESS ? GIT_SUCCESS : git__throw(GIT_EEXISTS, "Reference name `%s` conflicts with existing reference", ref); } /***************************************** * External Library API *****************************************/ /** * Constructors */ int git_reference_lookup(git_reference **ref_out, git_repository *repo, const char *name) { int error; char normalized_name[GIT_REFNAME_MAX]; 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"); /* 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 git__rethrow(error, "Failed to lookup reference"); /* * 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 git__rethrow(error, "Failed to lookup reference"); /* 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__throw(GIT_ENOTFOUND, "Failed to lookup reference. Reference doesn't exist"); } /** * 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; } int git_reference_create_symbolic(git_reference **ref_out, git_repository *repo, const char *name, const char *target, int force) { char normalized[GIT_REFNAME_MAX]; int error = GIT_SUCCESS, updated = 0; git_reference *ref = NULL, *old_ref = NULL; if (git_reference_lookup(&ref, repo, name) == GIT_SUCCESS && !force) 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 * it (once we've checked that the target is valid). Otherwise we * need a new reference because we can't make a symbolic ref out * of an oid one. * If if didn't exist, then we need to create a new one anyway. */ if (ref && ref->type & GIT_REF_SYMBOLIC){ updated = 1; } else { 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, sizeof(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; /* * If we didn't update the ref, then we need to insert or replace * it in the loose cache. If we replaced a ref, free it. */ if (!updated){ error = git_hashtable_insert2(repo->references.loose_cache, ref->name, ref, (void **) &old_ref); if (error < GIT_SUCCESS) goto cleanup; if(old_ref) reference_free(old_ref); } *ref_out = ref; return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create symbolic reference"); cleanup: reference_free(ref); return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create symbolic reference"); } int git_reference_create_oid(git_reference **ref_out, git_repository *repo, const char *name, const git_oid *id, int force) { int error = GIT_SUCCESS, updated = 0; git_reference *ref = NULL, *old_ref = NULL; if(git_reference_lookup(&ref, repo, name) == GIT_SUCCESS && !force) return git__throw(GIT_EEXISTS, "Failed to create reference OID. Reference already exists"); if ((error = reference_available(repo, name, NULL)) < GIT_SUCCESS) return git__rethrow(error, "Failed to create reference"); /* * If they old ref was of the same type, then we can just update * it (once we've checked that the target is valid). Otherwise we * need a new reference because we can't make a symbolic ref out * of an oid one. * If if didn't exist, then we need to create a new one anyway. */ if (ref && ref-> type & GIT_REF_OID){ updated = 1; } else { 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; if(!updated){ error = git_hashtable_insert2(repo->references.loose_cache, ref->name, ref, (void **) &old_ref); if (error < GIT_SUCCESS) goto cleanup; if(old_ref) reference_free(old_ref); } *ref_out = ref; return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create reference OID"); cleanup: reference_free(ref); return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to create reference OID"); } /** * 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__throw(GIT_EINVALIDREFSTATE, "Failed to set OID target of reference. Not an OID reference"); ref_oid = (reference_oid *)ref; assert(ref->owner); /* 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__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 */ 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 == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to set OID target of reference"); } /* * 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__throw(GIT_EINVALIDREFSTATE, "Failed to set reference target. Not a symbolic reference"); 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 */ int git_reference_rename(git_reference *ref, const char *new_name, int force) { int error; char *old_name = NULL; char aux_path[GIT_PATH_MAX]; char normalized[GIT_REFNAME_MAX]; const char *target_ref = NULL; const char *head_target = NULL; const git_oid *target_oid = NULL; git_reference *new_ref = NULL, *old_ref = NULL, *head = NULL; assert(ref); error = normalize_name(normalized, sizeof(normalized), new_name, ref->type & GIT_REF_OID); if (error < GIT_SUCCESS) return git__rethrow(error, "Failed to rename reference. Invalid name"); new_name = normalized; error = git_reference_lookup(&new_ref, ref->owner, new_name); if (error == GIT_SUCCESS) { if (!force) return git__throw(GIT_EEXISTS, "Failed to rename reference. Reference already exists"); error = git_reference_delete(new_ref); } if (error < GIT_SUCCESS && error != GIT_ENOTFOUND) goto cleanup; if ((error = reference_available(ref->owner, new_name, ref->name)) < GIT_SUCCESS) return git__rethrow(error, "Failed to rename reference. Reference already exists"); /* * First, we backup the reference targets. Just keeping the old * reference won't work, since we may have to remove it to create * the new reference, e.g. when renaming foo/bar -> foo. */ old_name = git__strdup(ref->name); if (ref->type & GIT_REF_SYMBOLIC) { if ((target_ref = git_reference_target(ref)) == NULL) goto cleanup; } else { if ((target_oid = git_reference_oid(ref)) == NULL) goto cleanup; } /* * Now delete the old ref and remove an possibly existing directory * named `new_name`. */ if (ref->type & GIT_REF_PACKED) { ref->type &= ~GIT_REF_PACKED; git_hashtable_remove(ref->owner->references.packfile, old_name); if ((error = packed_write(ref->owner)) < GIT_SUCCESS) goto rollback; } else { git_path_join(aux_path, ref->owner->path_repository, old_name); if ((error = p_unlink(aux_path)) < GIT_SUCCESS) goto cleanup; git_hashtable_remove(ref->owner->references.loose_cache, old_name); } /* build new path */ git_path_join(aux_path, ref->owner->path_repository, new_name); if (git_futils_exists(aux_path) == GIT_SUCCESS) { if (git_futils_isdir(aux_path) == GIT_SUCCESS) { if ((error = git_futils_rmdir_r(aux_path, 0)) < GIT_SUCCESS) goto rollback; } else goto rollback; } /* * Crude hack: delete any logs till we support proper reflogs. * Otherwise git.git will possibly fail and leave a mess. git.git * writes reflogs by default in any repo with a working directory: * * "We only enable reflogs in repositories that have a working directory * associated with them, as shared/bare repositories do not have * an easy means to prune away old log entries, or may fail logging * entirely if the user's gecos information is not valid during a push. * This heuristic was suggested on the mailing list by Junio." * * Shawn O. Pearce - 0bee59186976b1d9e6b2dd77332480c9480131d5 * * TODO * */ git_path_join_n(aux_path, 3, ref->owner->path_repository, "logs", old_name); if (git_futils_isfile(aux_path) == GIT_SUCCESS) { if ((error = p_unlink(aux_path)) < GIT_SUCCESS) goto rollback; } /* * Finally we can create the new reference. */ if (ref->type & GIT_REF_SYMBOLIC) { if ((error = git_reference_create_symbolic(&new_ref, ref->owner, new_name, target_ref, 0)) < GIT_SUCCESS) goto rollback; } else { if ((error = git_reference_create_oid(&new_ref, ref->owner, new_name, target_oid, 0)) < GIT_SUCCESS) goto rollback; } free(ref->name); ref->name = new_ref->name; /* * No need in new_ref anymore. We created it to fix the change on disk. * TODO: Refactoring required. */ new_ref->name = NULL; reference_free(new_ref); if ((error = git_hashtable_insert2(ref->owner->references.loose_cache, ref->name, ref, (void **)&old_ref)) < GIT_SUCCESS) goto rollback; /* * Check if we have to update HEAD. */ if ((error = git_reference_lookup(&head, ref->owner, GIT_HEAD_FILE)) < GIT_SUCCESS) goto cleanup; head_target = git_reference_target(head); if (head_target && !strcmp(head_target, old_name)) if ((error = git_reference_create_symbolic(&head, ref->owner, "HEAD", ref->name, 1)) < GIT_SUCCESS) goto rollback; cleanup: free(old_name); return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to rename reference"); rollback: /* * Try to create the old reference again. */ if (ref->type & GIT_REF_SYMBOLIC) error = git_reference_create_symbolic(&new_ref, ref->owner, old_name, target_ref, 0); else error = git_reference_create_oid(&new_ref, ref->owner, old_name, target_oid, 0); ref->name = old_name; return error == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to rename reference. Failed to rollback"); } /* * 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) { /* load the existing packfile */ if ((error = packed_load(ref->owner)) < GIT_SUCCESS) return git__rethrow(error, "Failed to delete reference"); if (git_hashtable_remove(ref->owner->references.packfile, ref->name) < GIT_SUCCESS) return git__throw(GIT_ENOTFOUND, "Reference not found"); error = packed_write(ref->owner); } else { char full_path[GIT_PATH_MAX]; git_path_join(full_path, ref->owner->path_repository, ref->name); git_hashtable_remove(ref->owner->references.loose_cache, ref->name); error = p_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 == GIT_SUCCESS ? GIT_SUCCESS : git__rethrow(error, "Failed to delete reference"); } 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 git__rethrow(error, "Failed to resolve reference"); repo = ref->owner; for (i = 0; i < MAX_NESTING_LEVEL; ++i) { reference_symbolic *ref_sym; *resolved_ref = ref; if (ref->type & GIT_REF_OID) return GIT_SUCCESS; ref_sym = (reference_symbolic *)ref; if ((error = git_reference_lookup(&ref, repo, ref_sym->target)) < GIT_SUCCESS) return error; } return git__throw(GIT_ENOMEM, "Failed to resolve reference. Reference is too nested"); } 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"); /* 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); } int git_reference_foreach(git_repository *repo, unsigned int list_flags, int (*callback)(const char *, void *), void *payload) { int error; struct dirent_list_data data; char refs_path[GIT_PATH_MAX]; /* list all the packed references first */ if (list_flags & GIT_REF_PACKED) { const char *ref_name; void *GIT_UNUSED(_unused); if ((error = packed_load(repo)) < GIT_SUCCESS) 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 git__throw(error, "Failed to list references. User callback failed"); ); } /* now list the loose references, trying not to * duplicate the ref names already in the packed-refs file */ data.repo_path_len = strlen(repo->path_repository); data.list_flags = list_flags; data.repo = repo; data.callback = callback; data.callback_payload = payload; git_path_join(refs_path, repo->path_repository, GIT_REFS_DIR); return git_futils_direach(refs_path, GIT_PATH_MAX, _dirent_loose_listall, &data); } int cb__reflist_add(const char *ref, void *data) { return git_vector_insert((git_vector *)data, git__strdup(ref)); } int git_reference_listall(git_strarray *array, git_repository *repo, unsigned int list_flags) { int error; git_vector ref_list; assert(array && repo); array->strings = NULL; array->count = 0; if (git_vector_init(&ref_list, 8, NULL) < GIT_SUCCESS) return GIT_ENOMEM; error = git_reference_foreach(repo, list_flags, &cb__reflist_add, (void *)&ref_list); if (error < GIT_SUCCESS) { git_vector_free(&ref_list); return error; } array->strings = (char **)ref_list.contents; array->count = 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; refs->packfile_time = 0; return (refs->loose_cache) ? GIT_SUCCESS : GIT_ENOMEM; } void git_repository__refcache_free(git_refcache *refs) { git_reference *reference; const void *GIT_UNUSED(_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, size_t out_size, const char *name, int is_oid_ref) { const char *name_end, *buffer_out_start; const char *current; int contains_a_slash = 0; assert(name && buffer_out); buffer_out_start = buffer_out; current = name; name_end = name + strlen(name); /* Terminating null byte */ out_size--; /* A refname can not be empty */ if (name_end == name) 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__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name ends with dot or slash"); while (current < name_end && out_size) { if (check_valid_ref_char(*current)) 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__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__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name contains '@{'"); /* Prevent multiple slashes from being added to the output */ if (*current == '/' && prev == '/') { current++; continue; } } if (*current == '/') contains_a_slash = 1; *buffer_out++ = *current++; out_size--; } if (!out_size) return git__throw(GIT_EINVALIDREFNAME, "Reference name is too long"); /* 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 * middle of a merge */ if (is_oid_ref && !contains_a_slash && (strcmp(name, GIT_HEAD_FILE) && strcmp(name, GIT_MERGE_HEAD_FILE))) 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__throw(GIT_EINVALIDREFNAME, "Failed to normalize name. Reference name ends with '.lock'"); *buffer_out = '\0'; /* * For object id references, name has to start with refs/. Again, * we need to allow HEAD to be in a detached state. */ 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/'"); return GIT_SUCCESS; } int git_reference__normalize_name(char *buffer_out, size_t out_size, const char *name) { return normalize_name(buffer_out, out_size, name, 0); } int git_reference__normalize_name_oid(char *buffer_out, size_t out_size, const char *name) { return normalize_name(buffer_out, out_size, name, 1); }