hlibgit2-0.1: libgit2/src/refs.c
/*
* 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);
}