libgit2/src/repository.c

/*
 * Copyright (C) 2009-2012 the libgit2 contributors
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */
#include <stdarg.h>

#include "git2/object.h"

#include "common.h"
#include "repository.h"
#include "commit.h"
#include "tag.h"
#include "blob.h"
#include "fileops.h"
#include "config.h"
#include "refs.h"

#define GIT_OBJECTS_INFO_DIR GIT_OBJECTS_DIR "info/"
#define GIT_OBJECTS_PACK_DIR GIT_OBJECTS_DIR "pack/"

#define GIT_FILE_CONTENT_PREFIX "gitdir: "

#define GIT_BRANCH_MASTER "master"

#define GIT_CONFIG_CORE_REPOSITORYFORMATVERSION "core.repositoryformatversion"
#define GIT_REPOSITORYFORMATVERSION 0

static void drop_odb(git_repository *repo)
{
	if (repo->_odb != NULL) {
		GIT_REFCOUNT_OWN(repo->_odb, NULL);
		git_odb_free(repo->_odb);
		repo->_odb = NULL;
	}
}

static void drop_config(git_repository *repo)
{
	if (repo->_config != NULL) {
		GIT_REFCOUNT_OWN(repo->_config, NULL);
		git_config_free(repo->_config);
		repo->_config = NULL;
	}

	git_repository__cvar_cache_clear(repo);
}

static void drop_index(git_repository *repo)
{
	if (repo->_index != NULL) {
		GIT_REFCOUNT_OWN(repo->_index, NULL);
		git_index_free(repo->_index);
		repo->_index = NULL;
	}
}

void git_repository_free(git_repository *repo)
{
	if (repo == NULL)
		return;

	git_cache_free(&repo->objects);
	git_repository__refcache_free(&repo->references);
	git_attr_cache_flush(repo);
	git_submodule_config_free(repo);

	git__free(repo->path_repository);
	git__free(repo->workdir);

	drop_config(repo);
	drop_index(repo);
	drop_odb(repo);

	git__free(repo);
}

/*
 * Git repository open methods
 *
 * Open a repository object from its path
 */
static bool valid_repository_path(git_buf *repository_path)
{
	/* Check OBJECTS_DIR first, since it will generate the longest path name */
	if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR) == false)
		return false;

	/* Ensure HEAD file exists */
	if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)
		return false;

	if (git_path_contains_dir(repository_path, GIT_REFS_DIR)  == false)
		return false;

	return true;
}

static git_repository *repository_alloc(void)
{
	git_repository *repo = git__malloc(sizeof(git_repository));
	if (!repo)
		return NULL;

	memset(repo, 0x0, sizeof(git_repository));

	if (git_cache_init(&repo->objects, GIT_DEFAULT_CACHE_SIZE, &git_object__free) < 0) {
		git__free(repo);
		return NULL;
	}

	/* set all the entries in the cvar cache to `unset` */
	git_repository__cvar_cache_clear(repo);

	return repo;
}

static int load_config_data(git_repository *repo)
{
	int is_bare;
	git_config *config;

	if (git_repository_config__weakptr(&config, repo) < 0)
		return -1;

	if (git_config_get_bool(config, "core.bare", &is_bare) < 0)
		return -1; /* FIXME: We assume that a missing core.bare
					  variable is an error. Is this right? */

	repo->is_bare = is_bare;
	return 0;
}

static int load_workdir(git_repository *repo)
{
	git_buf workdir_buf = GIT_BUF_INIT;

	if (repo->is_bare)
		return 0;

	git_path_dirname_r(&workdir_buf, repo->path_repository);
	git_path_to_dir(&workdir_buf);

	if (git_buf_oom(&workdir_buf))
		return -1;

	repo->workdir = git_buf_detach(&workdir_buf);
	git_buf_free(&workdir_buf);

	return 0;
}

int git_repository_open(git_repository **repo_out, const char *path)
{
	git_buf path_buf = GIT_BUF_INIT;
	git_repository *repo = NULL;
	int res;

	res = git_path_prettify_dir(&path_buf, path, NULL);
	if (res < 0)
		return res;

	/**
	 * Check if the path we've been given is actually the path
	 * of the working dir, by testing if it contains a `.git`
	 * folder inside of it.
	 */
	if (git_path_contains_dir(&path_buf, GIT_DIR) == true)
		git_buf_joinpath(&path_buf, path_buf.ptr, GIT_DIR);

	if (valid_repository_path(&path_buf) == false) {
		giterr_set(GITERR_REPOSITORY,
			"The given path (%s) is not a valid Git repository", git_buf_cstr(&path_buf));
		git_buf_free(&path_buf);
		return GIT_ENOTFOUND;
	}

	repo = repository_alloc();
	GITERR_CHECK_ALLOC(repo);

	repo->path_repository = git_buf_detach(&path_buf);
	GITERR_CHECK_ALLOC(repo->path_repository);

	if (load_config_data(repo) < 0)
		goto cleanup;

	if (load_workdir(repo) < 0)
		goto cleanup;

	*repo_out = repo;
	return 0;

 cleanup:
	git_repository_free(repo);
	git_buf_free(&path_buf);
	return -1;
}

static int load_config(
		git_config **out,
		git_repository *repo,
		const char *global_config_path,
		const char *system_config_path)
{
	git_buf config_path = GIT_BUF_INIT;
	git_config *cfg = NULL;

	assert(repo && out);

	if (git_config_new(&cfg) < 0)
		return -1;

	if (git_buf_joinpath(
		&config_path, repo->path_repository, GIT_CONFIG_FILENAME_INREPO) < 0)
		goto on_error;

	if (git_config_add_file_ondisk(cfg, config_path.ptr, 3) < 0)
		goto on_error;

	git_buf_free(&config_path);

	if (global_config_path != NULL) {
		if (git_config_add_file_ondisk(cfg, global_config_path, 2) < 0)
			goto on_error;
	}

	if (system_config_path != NULL) {
		if (git_config_add_file_ondisk(cfg, system_config_path, 1) < 0)
			goto on_error;
	}

	*out = cfg;
	return 0;

on_error:
	git_buf_free(&config_path);
	git_config_free(cfg);
	*out = NULL;
	return -1;
}

int git_repository_config__weakptr(git_config **out, git_repository *repo)
{
	if (repo->_config == NULL) {
		git_buf global_buf = GIT_BUF_INIT, system_buf = GIT_BUF_INIT;
		int res;

		const char *global_config_path = NULL;
		const char *system_config_path = NULL;

		if (git_config_find_global_r(&global_buf) == 0)
			global_config_path = global_buf.ptr;

		if (git_config_find_system_r(&system_buf) == 0)
			system_config_path = system_buf.ptr;

		res = load_config(&repo->_config, repo, global_config_path, system_config_path);

		git_buf_free(&global_buf);
		git_buf_free(&system_buf);

		if (res < 0)
			return -1;

		GIT_REFCOUNT_OWN(repo->_config, repo);
	}

	*out = repo->_config;
	return 0;
}

int git_repository_config(git_config **out, git_repository *repo)
{
	if (git_repository_config__weakptr(out, repo) < 0)
		return -1;

	GIT_REFCOUNT_INC(*out);
	return 0;
}

void git_repository_set_config(git_repository *repo, git_config *config)
{
	assert(repo && config);

	drop_config(repo);

	repo->_config = config;
	GIT_REFCOUNT_OWN(repo->_config, repo);
}

int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
{
	assert(repo && out);

	if (repo->_odb == NULL) {
		git_buf odb_path = GIT_BUF_INIT;
		int res;

		if (git_buf_joinpath(&odb_path, repo->path_repository, GIT_OBJECTS_DIR) < 0)
			return -1;

		res = git_odb_open(&repo->_odb, odb_path.ptr);
		git_buf_free(&odb_path); /* done with path */

		if (res < 0)
			return -1;

		GIT_REFCOUNT_OWN(repo->_odb, repo);
	}

	*out = repo->_odb;
	return 0;
}

int git_repository_odb(git_odb **out, git_repository *repo)
{
	if (git_repository_odb__weakptr(out, repo) < 0)
		return -1;

	GIT_REFCOUNT_INC(*out);
	return 0;
}

void git_repository_set_odb(git_repository *repo, git_odb *odb)
{
	assert(repo && odb);

	drop_odb(repo);

	repo->_odb = odb;
	GIT_REFCOUNT_OWN(repo->_odb, repo);
}

int git_repository_index__weakptr(git_index **out, git_repository *repo)
{
	assert(out && repo);

	if (repo->_index == NULL) {
		int res;
		git_buf index_path = GIT_BUF_INIT;

		if (git_buf_joinpath(&index_path, repo->path_repository, GIT_INDEX_FILE) < 0)
			return -1;

		res = git_index_open(&repo->_index, index_path.ptr);
		git_buf_free(&index_path); /* done with path */

		if (res < 0)
			return -1;

		GIT_REFCOUNT_OWN(repo->_index, repo);
	}

	*out = repo->_index;
	return 0;
}

int git_repository_index(git_index **out, git_repository *repo)
{
	if (git_repository_index__weakptr(out, repo) < 0)
		return -1;

	GIT_REFCOUNT_INC(*out);
	return 0;
}

void git_repository_set_index(git_repository *repo, git_index *index)
{
	assert(repo && index);

	drop_index(repo);

	repo->_index = index;
	GIT_REFCOUNT_OWN(repo->_index, repo);
}


static int retrieve_device(dev_t *device_out, const char *path)
{
	int error;
	struct stat path_info;

	assert(device_out);

	if ((error = git_path_lstat(path, &path_info)) == 0)
		*device_out = path_info.st_dev;

	return error;
}

/*
 * This function returns furthest offset into path where a ceiling dir
 * is found, so we can stop processing the path at that point.
 *
 * Note: converting this to use git_bufs instead of GIT_PATH_MAX buffers on
 * the stack could remove directories name limits, but at the cost of doing
 * repeated malloc/frees inside the loop below, so let's not do it now.
 */
static int retrieve_ceiling_directories_offset(
	const char *path,
	const char *ceiling_directories)
{
	char buf[GIT_PATH_MAX + 1];
	char buf2[GIT_PATH_MAX + 1];
	const char *ceil, *sep;
	int len, max_len = -1;
	int min_len;

	assert(path);

	min_len = git_path_root(path) + 1;

	if (ceiling_directories == NULL || min_len == 0)
		return min_len;

	for (sep = ceil = ceiling_directories; *sep; ceil = sep + 1) {
		for (sep = ceil; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++);
		len = sep - ceil;

		if (len == 0 || len >= (int)sizeof(buf) || git_path_root(ceil) == -1)
			continue;

		strncpy(buf, ceil, len);
		buf[len] = '\0';

		if (p_realpath(buf, buf2) == NULL)
			continue;

		len = strlen(buf2);
		if (len > 0 && buf2[len-1] == '/')
			buf[--len] = '\0';

		if (!strncmp(path, buf2, len) &&
			path[len] == '/' &&
			len > max_len)
		{
			max_len = len;
		}
	}

	return max_len <= min_len ? min_len : max_len;
}

/*
 * Read the contents of `file_path` and set `path_out` to the repo dir that
 * it points to.  Before calling, set `path_out` to the base directory that
 * should be used if the contents of `file_path` are a relative path.
 */
static int read_gitfile(git_buf *path_out, const char *file_path, const char *base_path)
{
	git_buf file = GIT_BUF_INIT;

	assert(path_out && file_path);

	if (git_futils_readbuffer(&file, file_path) < 0)
		return -1;

	git_buf_rtrim(&file);

	if (git__prefixcmp((char *)file.ptr, GIT_FILE_CONTENT_PREFIX) != 0 ||
		strlen(GIT_FILE_CONTENT_PREFIX) == file.size) {
		git_buf_free(&file);
		giterr_set(GITERR_REPOSITORY, "The `.git` file at '%s' is corrupted", file_path);
		return -1;
	}

	if (git_path_prettify_dir(path_out,
		((char *)file.ptr) + strlen(GIT_FILE_CONTENT_PREFIX), base_path) < 0) {
		git_buf_free(&file);
		giterr_set(GITERR_REPOSITORY,
			"The `.git` file at '%s' points to an invalid path.", file_path);
		return -1;
	}

	git_buf_free(&file);
	return 0;
}

int git_repository_discover(
	char *repository_path,
	size_t size,
	const char *start_path,
	int across_fs,
	const char *ceiling_dirs)
{
	int res, ceiling_offset;
	git_buf bare_path = GIT_BUF_INIT;
	git_buf normal_path = GIT_BUF_INIT;
	git_buf *found_path = NULL;
	dev_t current_device = 0;

	assert(start_path && repository_path);

	*repository_path = '\0';

	res = git_path_prettify_dir(&bare_path, start_path, NULL);
	if (res < 0)
		return res;

	if (!across_fs) {
		if (retrieve_device(&current_device, bare_path.ptr) < 0)
			goto on_error;
	}

	ceiling_offset = retrieve_ceiling_directories_offset(bare_path.ptr, ceiling_dirs);

	while(1) {
		if (git_buf_joinpath(&normal_path, bare_path.ptr, DOT_GIT) < 0)
			goto on_error;

		/**
		 * If the `.git` file is regular instead of
		 * a directory, it should contain the path of the actual git repository
		 */
		if (git_path_isfile(normal_path.ptr) == true) {
			git_buf gitfile_path = GIT_BUF_INIT;

			if (read_gitfile(&gitfile_path, normal_path.ptr, bare_path.ptr) < 0) {
				git_buf_free(&gitfile_path);
				goto on_error;
			}

			if (valid_repository_path(&gitfile_path) == false) {
				git_buf_free(&gitfile_path);
				giterr_set(GITERR_REPOSITORY,
					"The `.git` file found at '%s' points to an invalid git folder", normal_path.ptr);
				goto on_error;
			}

			git_buf_swap(&normal_path, &gitfile_path);
			found_path = &normal_path;

			git_buf_free(&gitfile_path);
			break;
		}

		/**
		 * If the `.git` file is a folder, we check inside of it
		 */
		if (git_path_isdir(normal_path.ptr) == true) {
			if (valid_repository_path(&normal_path) == true) {
				found_path = &normal_path;
				break;
			}
		}

		/**
		 * Otherwise, the repository may be bare, let's check
		 * the root anyway
		 */
		if (valid_repository_path(&bare_path) == true) {
			found_path = &bare_path;
			break;
		}

		/**
		 * If we didn't find it, walk up the tree
		 */
		if (git_path_dirname_r(&normal_path, bare_path.ptr) < 0)
			goto on_error;

		git_buf_swap(&bare_path, &normal_path);

		if (!across_fs) {
			dev_t new_device;
			if (retrieve_device(&new_device, bare_path.ptr) < 0)
				goto on_error;

			if (current_device != new_device)
				goto on_not_found;

			current_device = new_device;
		}

		/* nothing has been found, lets try the parent directory
		 * but stop if we hit one of the ceiling directories
		 */
		if (bare_path.ptr[ceiling_offset] == '\0')
			goto on_not_found;
	}

	assert(found_path);

	if (git_path_to_dir(found_path) < 0)
		goto on_error;

	if (size < (size_t)(found_path->size + 1)) {
		giterr_set(GITERR_REPOSITORY,
			"The given buffer is too long to store the discovered path");
		goto on_error;
	}

	/* success: we discovered a repository */
	git_buf_copy_cstr(repository_path, size, found_path);

	git_buf_free(&bare_path);
	git_buf_free(&normal_path);
	return 0;

on_error: /* unrecoverable error */
	git_buf_free(&bare_path);
	git_buf_free(&normal_path);
	return -1;

on_not_found: /* failed to discover the repository */
	git_buf_free(&bare_path);
	git_buf_free(&normal_path);
	return GIT_ENOTFOUND;
}

static int check_repositoryformatversion(git_repository *repo)
{
	git_config *config;
	int version;

	if (git_repository_config__weakptr(&config, repo) < 0)
		return -1;

	if (git_config_get_int32(config, GIT_CONFIG_CORE_REPOSITORYFORMATVERSION, &version) < 0)
		return -1;

	if (GIT_REPOSITORYFORMATVERSION < version) {
		giterr_set(GITERR_REPOSITORY,
			"Unsupported repository version %d. Only versions up to %d are supported.",
			version, GIT_REPOSITORYFORMATVERSION);
		return -1;
	}

	return 0;
}

static int repo_init_reinit(git_repository **repo_out, const char *repository_path, int is_bare)
{
	git_repository *repo = NULL;

	GIT_UNUSED(is_bare);

	if (git_repository_open(&repo, repository_path) < 0)
		return -1;

	if (check_repositoryformatversion(repo) < 0) {
		git_repository_free(repo);
		return -1;
	}

	/* TODO: reinitialize the templates */

	*repo_out = repo;
	return 0;
}

static int repo_init_createhead(const char *git_dir)
{
	git_buf ref_path = GIT_BUF_INIT;
	git_filebuf ref = GIT_FILEBUF_INIT;

	if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 ||
		git_filebuf_open(&ref, ref_path.ptr, 0) < 0 ||
		git_filebuf_printf(&ref, "ref: refs/heads/master\n") < 0 ||
		git_filebuf_commit(&ref, GIT_REFS_FILE_MODE) < 0)
		return -1;

	git_buf_free(&ref_path);
	return 0;
}

static int repo_init_config(const char *git_dir, int is_bare)
{
	git_buf cfg_path = GIT_BUF_INIT;
	git_config *config = NULL;

#define SET_REPO_CONFIG(type, name, val) {\
	if (git_config_set_##type(config, name, val) < 0) { \
		git_buf_free(&cfg_path); \
		git_config_free(config); \
		return -1; } \
}

	if (git_buf_joinpath(&cfg_path, git_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
		return -1;

	if (git_config_open_ondisk(&config, cfg_path.ptr) < 0) {
		git_buf_free(&cfg_path);
		return -1;
	}

	SET_REPO_CONFIG(bool, "core.bare", is_bare);
	SET_REPO_CONFIG(int32, GIT_CONFIG_CORE_REPOSITORYFORMATVERSION, GIT_REPOSITORYFORMATVERSION);
	/* TODO: what other defaults? */

	git_buf_free(&cfg_path);
	git_config_free(config);
	return 0;
}

static int repo_init_structure(const char *git_dir, int is_bare)
{
	int i;
	struct { const char *dir; mode_t mode; } dirs[] = {
		{ GIT_OBJECTS_INFO_DIR, GIT_OBJECT_DIR_MODE }, /* '/objects/info/' */
		{ GIT_OBJECTS_PACK_DIR, GIT_OBJECT_DIR_MODE }, /* '/objects/pack/' */
		{ GIT_REFS_HEADS_DIR, GIT_REFS_DIR_MODE },     /* '/refs/heads/' */
		{ GIT_REFS_TAGS_DIR, GIT_REFS_DIR_MODE },      /* '/refs/tags/' */
		{ NULL, 0 }
	};

	/* Make the base directory */
	if (git_futils_mkdir_r(git_dir, NULL, is_bare ? GIT_BARE_DIR_MODE : GIT_DIR_MODE) < 0)
		return -1;

	/* Hides the ".git" directory */
	if (!is_bare) {
#ifdef GIT_WIN32
		if (p_hide_directory__w32(git_dir) < 0) {
			giterr_set(GITERR_REPOSITORY,
				"Failed to mark Git repository folder as hidden");
			return -1;
		}
#endif
	}

	/* Make subdirectories as needed */
	for (i = 0; dirs[i].dir != NULL; ++i) {
		if (git_futils_mkdir_r(dirs[i].dir, git_dir, dirs[i].mode) < 0)
			return -1;
	}

	/* TODO: what's left? templates? */
	return 0;
}

int git_repository_init(git_repository **repo_out, const char *path, unsigned is_bare)
{
	git_buf repository_path = GIT_BUF_INIT;

	assert(repo_out && path);

	if (git_buf_joinpath(&repository_path, path, is_bare ? "" : GIT_DIR) < 0)
		return -1;

	if (git_path_isdir(repository_path.ptr) == true) {
		if (valid_repository_path(&repository_path) == true) {
			int res = repo_init_reinit(repo_out, repository_path.ptr, is_bare);
			git_buf_free(&repository_path);
			return res;
		}
	}

	if (repo_init_structure(repository_path.ptr, is_bare) < 0 ||
		repo_init_config(repository_path.ptr, is_bare) < 0 || 
		repo_init_createhead(repository_path.ptr) < 0 ||
		git_repository_open(repo_out, repository_path.ptr) < 0) {
		git_buf_free(&repository_path);
		return -1;
	}

	git_buf_free(&repository_path);
	return 0;
}

int git_repository_head_detached(git_repository *repo)
{
	git_reference *ref;
	git_odb *odb = NULL;
	int exists;

	if (git_repository_odb__weakptr(&odb, repo) < 0)
		return -1;

	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
		return -1;

	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
		git_reference_free(ref);
		return 0;
	}

	exists = git_odb_exists(odb, git_reference_oid(ref));

	git_reference_free(ref);
	return exists;
}

int git_repository_head(git_reference **head_out, git_repository *repo)
{
	git_reference *ref, *resolved_ref;
	int error;

	*head_out = NULL;

	error = git_reference_lookup(&ref, repo, GIT_HEAD_FILE);
	if (error < 0)
		return error;

	error = git_reference_resolve(&resolved_ref, ref);
	if (error < 0) {
		git_reference_free(ref);
		return error;
	}

	git_reference_free(ref);
	*head_out = resolved_ref;
	return 0;
}

int git_repository_head_orphan(git_repository *repo)
{
	git_reference *ref = NULL;
	int error;

	error = git_repository_head(&ref, repo);
	git_reference_free(ref);

	if (error == GIT_ENOTFOUND)
		return 1;

	if (error < 0)
		return -1;

	return 0;
}

int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL, *branch = NULL;
	int error;

	if (git_reference_lookup(&head, repo, "HEAD") < 0)
		return -1;

	if (git_reference_type(head) != GIT_REF_SYMBOLIC) {
		git_reference_free(head);
		return 0;
	}

	if (strcmp(git_reference_target(head), "refs/heads/master") != 0) {
		git_reference_free(head);
		return 0;
	}

	error = git_reference_resolve(&branch, head);

	git_reference_free(head);
	git_reference_free(branch);

	if (error == GIT_ENOTFOUND)
		return 1;

	if (error < 0)
		return -1;

	return 0;
}

const char *git_repository_path(git_repository *repo)
{
	assert(repo);
	return repo->path_repository;
}

const char *git_repository_workdir(git_repository *repo)
{
	assert(repo);

	if (repo->is_bare)
		return NULL;

	return repo->workdir;
}

int git_repository_set_workdir(git_repository *repo, const char *workdir)
{
	git_buf path = GIT_BUF_INIT;

	assert(repo && workdir);

	if (git_path_prettify_dir(&path, workdir, NULL) < 0)
		return -1;

	free(repo->workdir);

	repo->workdir = git_buf_detach(&path);
	repo->is_bare = 0;
	return 0;
}

int git_repository_is_bare(git_repository *repo)
{
	assert(repo);
	return repo->is_bare;
}