thodg/libgit2/src/repository.c

• Show log

  Commit

• Hash : 2bc8fa02
  Author :
  Date : 2012-04-17T10:14:24
  

  Implement git_pool paged memory allocator This adds a `git_pool` object that can do simple paged memory allocation with free for the entire pool at once. Using this, you can replace many small allocations with large blocks that can then cheaply be doled out in small pieces. This is best used when you plan to free the small blocks all at once - for example, if they represent the parsed state from a file or data stream that are either all kept or all discarded. There are two real patterns of usage for `git_pools`: either for "string" allocation, where the item size is a single byte and you end up just packing the allocations in together, or for "fixed size" allocation where you are allocating a large object (e.g. a `git_oid`) and you generally just allocation single objects that can be tightly packed. Of course, you can use it for other things, but those two cases are the easiest.

Download

• 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 <ctype.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 *parent_path)
  {
  	int         error;
  	git_config *config;
  	const char *worktree;
  	git_buf     worktree_buf = GIT_BUF_INIT;
  
  	if (repo->is_bare)
  		return 0;
  
  	if (git_repository_config__weakptr(&config, repo) < 0)
  		return -1;
  
  	error = git_config_get_string(config, "core.worktree", &worktree);
  	if (!error && worktree != NULL)
  		repo->workdir = git__strdup(worktree);
  	else if (error != GIT_ENOTFOUND)
  		return error;
  	else {
  		giterr_clear();
  
  		if (parent_path && git_path_isdir(parent_path->ptr))
  			repo->workdir = git_buf_detach(parent_path);
  		else {
  			git_path_dirname_r(&worktree_buf, repo->path_repository);
  			git_path_to_dir(&worktree_buf);
  			repo->workdir = git_buf_detach(&worktree_buf);
  		}
  	}
  
  	GITERR_CHECK_ALLOC(repo->workdir);
  
  	return 0;
  }
  
  /*
   * 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 find_ceiling_dir_offset(
  	const char *path,
  	const char *ceiling_directories)
  {
  	char buf[GIT_PATH_MAX + 1];
  	char buf2[GIT_PATH_MAX + 1];
  	const char *ceil, *sep;
  	size_t len, max_len = 0, min_len;
  
  	assert(path);
  
  	min_len = (size_t)(git_path_root(path) + 1);
  
  	if (ceiling_directories == NULL || min_len == 0)
  		return (int)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 >= 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 (int)(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)
  {
  	int     error = 0;
  	git_buf file = GIT_BUF_INIT;
  	size_t  prefix_len = strlen(GIT_FILE_CONTENT_PREFIX);
  
  	assert(path_out && file_path);
  
  	if (git_futils_readbuffer(&file, file_path) < 0)
  		return -1;
  
  	git_buf_rtrim(&file);
  
  	if (file.size <= prefix_len ||
  		memcmp(file.ptr, GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
  	{
  		giterr_set(GITERR_REPOSITORY, "The `.git` file at '%s' is malformed", file_path);
  		error = -1;
  	}
  	else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
  		const char *gitlink = ((const char *)file.ptr) + prefix_len;
  		while (*gitlink && isspace(*gitlink)) gitlink++;
  		error = git_path_prettify_dir(path_out, gitlink, path_out->ptr);
  	}
  
  	git_buf_free(&file);
  	return error;
  }
  
  static int find_repo(
  	git_buf *repo_path,
  	git_buf *parent_path,
  	const char *start_path,
  	uint32_t flags,
  	const char *ceiling_dirs)
  {
  	int error;
  	git_buf path = GIT_BUF_INIT;
  	struct stat st;
  	dev_t initial_device = 0;
  	bool try_with_dot_git = false;
  	int ceiling_offset;
  
  	git_buf_free(repo_path);
  
  	if ((error = git_path_prettify_dir(&path, start_path, NULL)) < 0)
  		return error;
  
  	ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);
  
  	if ((error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0)
  		return error;
  
  	while (!error && !repo_path->size) {
  		if (p_stat(path.ptr, &st) == 0) {
  			/* check that we have not crossed device boundaries */
  			if (initial_device == 0)
  				initial_device = st.st_dev;
  			else if (st.st_dev != initial_device &&
  				(flags & GIT_REPOSITORY_OPEN_CROSS_FS) == 0)
  				break;
  
  			if (S_ISDIR(st.st_mode)) {
  				if (valid_repository_path(&path)) {
  					git_path_to_dir(&path);
  					git_buf_set(repo_path, path.ptr, path.size);
  					break;
  				}
  			}
  			else if (S_ISREG(st.st_mode)) {
  				git_buf repo_link = GIT_BUF_INIT;
  
  				if (!(error = read_gitfile(&repo_link, path.ptr))) {
  					if (valid_repository_path(&repo_link))
  						git_buf_swap(repo_path, &repo_link);
  
  					git_buf_free(&repo_link);
  					break;
  				}
  				git_buf_free(&repo_link);
  			}
  		}
  
  		/* move up one directory level */
  		if (git_path_dirname_r(&path, path.ptr) < 0) {
  			error = -1;
  			break;
  		}
  
  		if (try_with_dot_git) {
  			/* if we tried original dir with and without .git AND either hit
  			 * directory ceiling or NO_SEARCH was requested, then be done.
  			 */
  			if (path.ptr[ceiling_offset] == '\0' ||
  				(flags & GIT_REPOSITORY_OPEN_NO_SEARCH) != 0)
  				break;
  			/* otherwise look first for .git item */
  			error = git_buf_joinpath(&path, path.ptr, DOT_GIT);
  		}
  		try_with_dot_git = !try_with_dot_git;
  	}
  
  	if (!error && parent_path != NULL) {
  		if (!repo_path->size)
  			git_buf_clear(parent_path);
  		else {
  			git_path_dirname_r(parent_path, path.ptr);
  			git_path_to_dir(parent_path);
  		}
  		if (git_buf_oom(parent_path))
  			return -1;
  	}
  
  	git_buf_free(&path);
  
  	if (!repo_path->size && !error) {
  		giterr_set(GITERR_REPOSITORY,
  			"Could not find repository from '%s'", start_path);
  		error = GIT_ENOTFOUND;
  	}
  
  	return error;
  }
  
  int git_repository_open_ext(
  	git_repository **repo_ptr,
  	const char *start_path,
  	uint32_t flags,
  	const char *ceiling_dirs)
  {
  	int error;
  	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT;
  	git_repository *repo;
  
  	*repo_ptr = NULL;
  
  	if ((error = find_repo(&path, &parent, start_path, flags, ceiling_dirs)) < 0)
  		return error;
  
  	repo = repository_alloc();
  	GITERR_CHECK_ALLOC(repo);
  
  	repo->path_repository = git_buf_detach(&path);
  	GITERR_CHECK_ALLOC(repo->path_repository);
  
  	if ((error = load_config_data(repo)) < 0 ||
  		(error = load_workdir(repo, &parent)) < 0)
  	{
  		git_repository_free(repo);
  		return error;
  	}
  
  	git_buf_free(&parent);
  	*repo_ptr = repo;
  	return 0;
  }
  
  int git_repository_open(git_repository **repo_out, const char *path)
  {
  	return git_repository_open_ext(
  		repo_out, path, GIT_REPOSITORY_OPEN_NO_SEARCH, NULL);
  }
  
  int git_repository_discover(
  	char *repository_path,
  	size_t size,
  	const char *start_path,
  	int across_fs,
  	const char *ceiling_dirs)
  {
  	git_buf path = GIT_BUF_INIT;
  	uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;
  
  	assert(start_path && repository_path && size > 0);
  
  	*repository_path = '\0';
  
  	if (find_repo(&path, NULL, start_path, flags, ceiling_dirs) < 0)
  		return -1;
  
  	if (size < (size_t)(path.size + 1)) {
  		giterr_set(GITERR_REPOSITORY,
  			"The given buffer is too long to store the discovered path");
  		git_buf_free(&path);
  		return -1;
  	}
  
  	/* success: we discovered a repository */
  	git_buf_copy_cstr(repository_path, size, &path);
  	git_buf_free(&path);
  	return 0;
  }
  
  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);
  	GIT_REFCOUNT_INC(odb);
  }
  
  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);
  	GIT_REFCOUNT_INC(index);
  }
  
  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)
  {
  	return git_reference_lookup_resolved(head_out, repo, GIT_HEAD_FILE, -1);
  }
  
  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;
  
  	git__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;
  }
  

Download