/*

 * Copyright (C) the libgit2 contributors. All rights reserved.

 *

 * 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 <ctype.h>

#include "git2/object.h"

#include "git2/refdb.h"

#include "git2/sys/repository.h"

#include "common.h"

#include "repository.h"

#include "commit.h"

#include "tag.h"

#include "blob.h"

#include "fileops.h"

#include "sysdir.h"

#include "filebuf.h"

#include "index.h"

#include "config.h"

#include "refs.h"

#include "filter.h"

#include "odb.h"

#include "remote.h"

#include "merge.h"

#include "diff_driver.h"

#include "annotated_commit.h"

#include "submodule.h"

#include "worktree.h"

#include "strmap.h"

#ifdef GIT_WIN32

# include "win32/w32_util.h"

#endif

bool git_repository__fsync_gitdir = false;

static const struct {

    git_repository_item_t parent;

    const char *name;

    bool directory;

} items[] = {

	{ GIT_REPOSITORY_ITEM_GITDIR, NULL, true },

	{ GIT_REPOSITORY_ITEM_WORKDIR, NULL, true },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, NULL, true },

	{ GIT_REPOSITORY_ITEM_GITDIR, "index", false },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "objects", true },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "refs", true },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "packed-refs", false },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "remotes", true },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "config", false },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "info", true },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "hooks", true },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "logs", true },

	{ GIT_REPOSITORY_ITEM_GITDIR, "modules", true },

	{ GIT_REPOSITORY_ITEM_COMMONDIR, "worktrees", true }

};

static int check_repositoryformatversion(git_config *config);

#define GIT_COMMONDIR_FILE "commondir"

#define GIT_GITDIR_FILE "gitdir"

#define GIT_FILE_CONTENT_PREFIX "gitdir:"

#define GIT_BRANCH_MASTER "master"

#define GIT_REPO_VERSION 0

git_buf git_repository__reserved_names_win32[] = {

	{ DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },

	{ GIT_DIR_SHORTNAME, 0, CONST_STRLEN(GIT_DIR_SHORTNAME) }

};

size_t git_repository__reserved_names_win32_len = 2;

git_buf git_repository__reserved_names_posix[] = {

	{ DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },

};

size_t git_repository__reserved_names_posix_len = 1;

static void set_odb(git_repository *repo, git_odb *odb)

{

	if (odb) {

		GIT_REFCOUNT_OWN(odb, repo);

		GIT_REFCOUNT_INC(odb);

	}

	if ((odb = git__swap(repo->_odb, odb)) != NULL) {

		GIT_REFCOUNT_OWN(odb, NULL);

		git_odb_free(odb);

	}

}

static void set_refdb(git_repository *repo, git_refdb *refdb)

{

	if (refdb) {

		GIT_REFCOUNT_OWN(refdb, repo);

		GIT_REFCOUNT_INC(refdb);

	}

	if ((refdb = git__swap(repo->_refdb, refdb)) != NULL) {

		GIT_REFCOUNT_OWN(refdb, NULL);

		git_refdb_free(refdb);

	}

}

static void set_config(git_repository *repo, git_config *config)

{

	if (config) {

		GIT_REFCOUNT_OWN(config, repo);

		GIT_REFCOUNT_INC(config);

	}

	if ((config = git__swap(repo->_config, config)) != NULL) {

		GIT_REFCOUNT_OWN(config, NULL);

		git_config_free(config);

	}

	git_repository__cvar_cache_clear(repo);

}

static void set_index(git_repository *repo, git_index *index)

{

	if (index) {

		GIT_REFCOUNT_OWN(index, repo);

		GIT_REFCOUNT_INC(index);

	}

	if ((index = git__swap(repo->_index, index)) != NULL) {

		GIT_REFCOUNT_OWN(index, NULL);

		git_index_free(index);

	}

}

void git_repository__cleanup(git_repository *repo)

{

	assert(repo);

	git_repository_submodule_cache_clear(repo);

	git_cache_clear(&repo->objects);

	git_attr_cache_flush(repo);

	set_config(repo, NULL);

	set_index(repo, NULL);

	set_odb(repo, NULL);

	set_refdb(repo, NULL);

}

void git_repository_free(git_repository *repo)

{

	size_t i;

	if (repo == NULL)

		return;

	git_repository__cleanup(repo);

	git_cache_free(&repo->objects);

	git_diff_driver_registry_free(repo->diff_drivers);

	repo->diff_drivers = NULL;

	for (i = 0; i < repo->reserved_names.size; i++)

		git_buf_free(git_array_get(repo->reserved_names, i));

	git_array_clear(repo->reserved_names);

	git__free(repo->gitlink);

	git__free(repo->gitdir);

	git__free(repo->commondir);

	git__free(repo->workdir);

	git__free(repo->namespace);

	git__free(repo->ident_name);

	git__free(repo->ident_email);

	git__memzero(repo, sizeof(*repo));

	git__free(repo);

}

/*

 * Git repository open methods

 *

 * Open a repository object from its path

 */

static bool valid_repository_path(git_buf *repository_path, git_buf *common_path)

{

	/* Check if we have a separate commondir (e.g. we have a

	 * worktree) */

	if (git_path_contains_file(repository_path, GIT_COMMONDIR_FILE)) {

		git_buf common_link  = GIT_BUF_INIT;

		git_buf_joinpath(&common_link, repository_path->ptr, GIT_COMMONDIR_FILE);

		git_futils_readbuffer(&common_link, common_link.ptr);

		git_buf_rtrim(&common_link);

		if (git_path_is_relative(common_link.ptr)) {

			git_buf_joinpath(common_path, repository_path->ptr, common_link.ptr);

		} else {

			git_buf_swap(common_path, &common_link);

		}

		git_buf_free(&common_link);

	}

	else {

		git_buf_set(common_path, repository_path->ptr, repository_path->size);

	}

	/* Make sure the commondir path always has a trailing * slash */

	if (git_buf_rfind(common_path, '/') != (ssize_t)common_path->size - 1)

		git_buf_putc(common_path, '/');

	/* Ensure HEAD file exists */

	if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)

		return false;

	/* Check files in common dir */

	if (git_path_contains_dir(common_path, GIT_OBJECTS_DIR) == false)

		return false;

	if (git_path_contains_dir(common_path, GIT_REFS_DIR) == false)

		return false;

	return true;

}

static git_repository *repository_alloc(void)

{

	git_repository *repo = git__calloc(1, sizeof(git_repository));

	if (repo == NULL ||

		git_cache_init(&repo->objects) < 0)

		goto on_error;

	git_array_init_to_size(repo->reserved_names, 4);

	if (!repo->reserved_names.ptr)

		goto on_error;

	/* set all the entries in the cvar cache to `unset` */

	git_repository__cvar_cache_clear(repo);

	return repo;

on_error:

	if (repo)

		git_cache_free(&repo->objects);

	git__free(repo);

	return NULL;

}

int git_repository_new(git_repository **out)

{

	git_repository *repo;

	*out = repo = repository_alloc();

	GITERR_CHECK_ALLOC(repo);

	repo->is_bare = 1;

	repo->is_worktree = 0;

	return 0;

}

static int load_config_data(git_repository *repo, const git_config *config)

{

	int is_bare;

	/* Try to figure out if it's bare, default to non-bare if it's not set */

	if (git_config_get_bool(&is_bare, config, "core.bare") < 0)

		repo->is_bare = 0;

	else

		repo->is_bare = is_bare;

	return 0;

}

static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)

{

	int error;

	git_config_entry *ce;

	git_buf worktree = GIT_BUF_INIT;

	git_buf path = GIT_BUF_INIT;

	if (repo->is_bare)

		return 0;

	if ((error = git_config__lookup_entry(

			&ce, config, "core.worktree", false)) < 0)

		return error;

	if (repo->is_worktree) {

		char *gitlink = git_worktree__read_link(repo->gitdir, GIT_GITDIR_FILE);

		if (!gitlink) {

			error = -1;

			goto cleanup;

		}

		git_buf_attach(&worktree, gitlink, 0);

		if ((git_path_dirname_r(&worktree, worktree.ptr)) < 0 ||

		    git_path_to_dir(&worktree) < 0) {

			error = -1;

			goto cleanup;

		}

		repo->workdir = git_buf_detach(&worktree);

	}

	else if (ce && ce->value) {

		if ((error = git_path_prettify_dir(

				&worktree, ce->value, repo->gitdir)) < 0)

			goto cleanup;

		repo->workdir = git_buf_detach(&worktree);

	}

	else if (parent_path && git_path_isdir(parent_path->ptr))

		repo->workdir = git_buf_detach(parent_path);

	else {

		if (git_path_dirname_r(&worktree, repo->gitdir) < 0 ||

		    git_path_to_dir(&worktree) < 0) {

			error = -1;

			goto cleanup;

		}

		repo->workdir = git_buf_detach(&worktree);

	}

	GITERR_CHECK_ALLOC(repo->workdir);

cleanup:

	git_buf_free(&path);

	git_config_entry_free(ce);

	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 size_t 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 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] == '/' || !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)

{

	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;;

	/* apparently on Windows, some people use backslashes in paths */

	git_path_mkposix(file.ptr);

	if (git_buf_len(&file) <= prefix_len ||

		memcmp(git_buf_cstr(&file), 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 = git_buf_cstr(&file) + prefix_len;

		while (*gitlink && git__isspace(*gitlink)) gitlink++;

		error = git_path_prettify_dir(

			path_out, gitlink, git_buf_cstr(path_out));

	}

	git_buf_free(&file;;

	return error;

}

static int find_repo(

	git_buf *gitdir_path,

	git_buf *workdir_path,

	git_buf *gitlink_path,

	git_buf *commondir_path,

	const char *start_path,

	uint32_t flags,

	const char *ceiling_dirs)

{

	int error;

	git_buf path = GIT_BUF_INIT;

	git_buf repo_link = GIT_BUF_INIT;

	git_buf common_link = GIT_BUF_INIT;

	struct stat st;

	dev_t initial_device = 0;

	int min_iterations;

	bool in_dot_git;

	size_t ceiling_offset = 0;

	git_buf_clear(gitdir_path);

	error = git_path_prettify(&path, start_path, NULL);

	if (error < 0)

		return error;

	/* in_dot_git toggles each loop:

	 * /a/b/c/.git, /a/b/c, /a/b/.git, /a/b, /a/.git, /a

	 * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT, we

	 * assume we started with /a/b/c.git and don't append .git the first

	 * time through.

	 * min_iterations indicates the number of iterations left before going

	 * further counts as a search. */

	if (flags & (GIT_REPOSITORY_OPEN_BARE | GIT_REPOSITORY_OPEN_NO_DOTGIT)) {

		in_dot_git = true;

		min_iterations = 1;

	} else {

		in_dot_git = false;

		min_iterations = 2;

	}

	for (;;) {

		if (!(flags & GIT_REPOSITORY_OPEN_NO_DOTGIT)) {

			if (!in_dot_git) {

				error = git_buf_joinpath(&path, path.ptr, DOT_GIT);

				if (error < 0)

					break;

			}

			in_dot_git = !in_dot_git;

		}

		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))

				break;

			if (S_ISDIR(st.st_mode)) {

				if (valid_repository_path(&path, &common_link)) {

					git_path_to_dir(&path);

					git_buf_set(gitdir_path, path.ptr, path.size);

					if (gitlink_path)

						git_buf_attach(gitlink_path,

							git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0);

					if (commondir_path)

						git_buf_swap(&common_link, commondir_path);

					break;

				}

			}

			else if (S_ISREG(st.st_mode) && git__suffixcmp(path.ptr, "/" DOT_GIT) == 0) {

				error = read_gitfile(&repo_link, path.ptr);

				if (error < 0)

					break;

				if (valid_repository_path(&repo_link, &common_link)) {

					git_buf_swap(gitdir_path, &repo_link);

					if (gitlink_path)

						error = git_buf_put(gitlink_path, path.ptr, path.size);

					if (commondir_path)

						git_buf_swap(&common_link, commondir_path);

				}

				break;

			}

		}

		/* Move up one directory. If we're in_dot_git, we'll search the

		 * parent itself next. If we're !in_dot_git, we'll search .git

		 * in the parent directory next (added at the top of the loop). */

		if (git_path_dirname_r(&path, path.ptr) < 0) {

			error = -1;

			break;

		}

		/* Once we've checked the directory (and .git if applicable),

		 * find the ceiling for a search. */

		if (min_iterations && (--min_iterations == 0))

			ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);

		/* Check if we should stop searching here. */

		if (min_iterations == 0

		    && (path.ptr[ceiling_offset] == 0

			|| (flags & GIT_REPOSITORY_OPEN_NO_SEARCH)))

			break;

	}

	if (!error && workdir_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {

		if (!git_buf_len(gitdir_path))

			git_buf_clear(workdir_path);

		else {

			git_path_dirname_r(workdir_path, path.ptr);

			git_path_to_dir(workdir_path);

		}

		if (git_buf_oom(workdir_path))

			return -1;

	}

	/* If we didn't find the repository, and we don't have any other error

	 * to report, report that. */

	if (!git_buf_len(gitdir_path) && !error) {

		giterr_set(GITERR_REPOSITORY,

			"could not find repository from '%s'", start_path);

		error = GIT_ENOTFOUND;

	}

	git_buf_free(&path);

	git_buf_free(&repo_link);

	git_buf_free(&common_link);

	return error;

}

int git_repository_open_bare(

	git_repository **repo_ptr,

	const char *bare_path)

{

	int error;

	git_buf path = GIT_BUF_INIT, common_path = GIT_BUF_INIT;

	git_repository *repo = NULL;

	if ((error = git_path_prettify_dir(&path, bare_path, NULL)) < 0)

		return error;

	if (!valid_repository_path(&path, &common_path)) {

		git_buf_free(&path);

		git_buf_free(&common_path);

		giterr_set(GITERR_REPOSITORY, "path is not a repository: %s", bare_path);

		return GIT_ENOTFOUND;

	}

	repo = repository_alloc();

	GITERR_CHECK_ALLOC(repo);

	repo->gitdir = git_buf_detach(&path);

	GITERR_CHECK_ALLOC(repo->gitdir);

	repo->commondir = git_buf_detach(&common_path);

	GITERR_CHECK_ALLOC(repo->commondir);

	/* of course we're bare! */

	repo->is_bare = 1;

	repo->is_worktree = 0;

	repo->workdir = NULL;

	*repo_ptr = repo;

	return 0;

}

static int _git_repository_open_ext_from_env(

	git_repository **out,

	const char *start_path)

{

	git_repository *repo = NULL;

	git_index *index = NULL;

	git_odb *odb = NULL;

	git_buf dir_buf = GIT_BUF_INIT;

	git_buf ceiling_dirs_buf = GIT_BUF_INIT;

	git_buf across_fs_buf = GIT_BUF_INIT;

	git_buf index_file_buf = GIT_BUF_INIT;

	git_buf namespace_buf = GIT_BUF_INIT;

	git_buf object_dir_buf = GIT_BUF_INIT;

	git_buf alts_buf = GIT_BUF_INIT;

	git_buf work_tree_buf = GIT_BUF_INIT;

	git_buf common_dir_buf = GIT_BUF_INIT;

	const char *ceiling_dirs = NULL;

	unsigned flags = 0;

	int error;

	if (!start_path) {

		error = git__getenv(&dir_buf, "GIT_DIR");

		if (error == GIT_ENOTFOUND) {

			giterr_clear();

			start_path = ".";

		} else if (error < 0)

			goto error;

		else {

			start_path = git_buf_cstr(&dir_buf);

			flags |= GIT_REPOSITORY_OPEN_NO_SEARCH;

			flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT;

		}

	}

	error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES");

	if (error == GIT_ENOTFOUND)

		giterr_clear();

	else if (error < 0)

		goto error;

	else

		ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);

	error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM");

	if (error == GIT_ENOTFOUND)

		giterr_clear();

	else if (error < 0)

		goto error;

	else {

		int across_fs = 0;

		error = git_config_parse_bool(&across_fs, git_buf_cstr(&across_fs_buf));

		if (error < 0)

			goto error;

		if (across_fs)

			flags |= GIT_REPOSITORY_OPEN_CROSS_FS;

	}

	error = git__getenv(&index_file_buf, "GIT_INDEX_FILE");

	if (error == GIT_ENOTFOUND)

		giterr_clear();

	else if (error < 0)

		goto error;

	else {

		error = git_index_open(&index, git_buf_cstr(&index_file_buf));

		if (error < 0)

			goto error;

	}

	error = git__getenv(&namespace_buf, "GIT_NAMESPACE");

	if (error == GIT_ENOTFOUND)

		giterr_clear();

	else if (error < 0)

		goto error;

	error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");

	if (error == GIT_ENOTFOUND)

		giterr_clear();

	else if (error < 0)

		goto error;

	else {

		error = git_odb_open(&odb, git_buf_cstr(&object_dir_buf));

		if (error < 0)

			goto error;

	}

	error = git__getenv(&work_tree_buf, "GIT_WORK_TREE");

	if (error == GIT_ENOTFOUND)

		giterr_clear();

	else if (error < 0)

		goto error;

	else {

		giterr_set(GITERR_INVALID, "GIT_WORK_TREE unimplemented");

		error = GIT_ERROR;

		goto error;

	}

	error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");

	if (error == GIT_ENOTFOUND)

		giterr_clear();

	else if (error < 0)

		goto error;

	else {

		giterr_set(GITERR_INVALID, "GIT_COMMON_DIR unimplemented");

		error = GIT_ERROR;

		goto error;

	}

	error = git_repository_open_ext(&repo, start_path, flags, ceiling_dirs);

	if (error < 0)

		goto error;

	if (odb)

		git_repository_set_odb(repo, odb);

	error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES");

	if (error == GIT_ENOTFOUND) {

		giterr_clear();

		error = 0;

	} else if (error < 0)

		goto error;

        else {

		const char *end;

		char *alt, *sep;

		if (!odb) {

			error = git_repository_odb(&odb, repo);

			if (error < 0)

				goto error;

		}

		end = git_buf_cstr(&alts_buf) + git_buf_len(&alts_buf);

		for (sep = alt = alts_buf.ptr; sep != end; alt = sep+1) {

			for (sep = alt; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++)

				;

			if (*sep)

				*sep = '\0';

			error = git_odb_add_disk_alternate(odb, alt);

			if (error < 0)

				goto error;

		}

	}

	if (git_buf_len(&namespace_buf)) {

		error = git_repository_set_namespace(repo, git_buf_cstr(&namespace_buf));

		if (error < 0)

			goto error;

	}

	git_repository_set_index(repo, index);

	if (out) {

		*out = repo;

		goto success;

	}

error:

	git_repository_free(repo);

success:

	git_odb_free(odb);

	git_index_free(index);

	git_buf_free(&common_dir_buf);

	git_buf_free(&work_tree_buf);

	git_buf_free(&alts_buf);

	git_buf_free(&object_dir_buf);

	git_buf_free(&namespace_buf);

	git_buf_free(&index_file_buf);

	git_buf_free(&across_fs_buf);

	git_buf_free(&ceiling_dirs_buf);

	git_buf_free(&dir_buf);

	return error;

}

static int repo_is_worktree(unsigned *out, const git_repository *repo)

{

	git_buf gitdir_link = GIT_BUF_INIT;

	int error;

	/* Worktrees cannot have the same commondir and gitdir */

	if (repo->commondir && repo->gitdir

	    && !strcmp(repo->commondir, repo->gitdir)) {

		*out = 0;

		return 0;

	}

	if ((error = git_buf_joinpath(&gitdir_link, repo->gitdir, "gitdir")) < 0)

		return -1;

	/* A 'gitdir' file inside a git directory is currently

	 * only used when the repository is a working tree. */

	*out = !!git_path_exists(gitdir_link.ptr);

	git_buf_free(&gitdir_link);

	return error;

}

int git_repository_open_ext(

	git_repository **repo_ptr,

	const char *start_path,

	unsigned int flags,

	const char *ceiling_dirs)

{

	int error;

	unsigned is_worktree;

	git_buf gitdir = GIT_BUF_INIT, workdir = GIT_BUF_INIT,

		gitlink = GIT_BUF_INIT, commondir = GIT_BUF_INIT;

	git_repository *repo;

	git_config *config = NULL;

	if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)

		return _git_repository_open_ext_from_env(repo_ptr, start_path);

	if (repo_ptr)

		*repo_ptr = NULL;

	error = find_repo(

		&gitdir, &workdir, &gitlink, &commondir, start_path, flags, ceiling_dirs);

	if (error < 0 || !repo_ptr)

		return error;

	repo = repository_alloc();

	GITERR_CHECK_ALLOC(repo);

	repo->gitdir = git_buf_detach(&gitdir);

	GITERR_CHECK_ALLOC(repo->gitdir);

	if (gitlink.size) {

		repo->gitlink = git_buf_detach(&gitlink);

		GITERR_CHECK_ALLOC(repo->gitlink);

	}

	if (commondir.size) {

		repo->commondir = git_buf_detach(&commondir);

		GITERR_CHECK_ALLOC(repo->commondir);

	}

	if ((error = repo_is_worktree(&is_worktree, repo)) < 0)

		goto cleanup;

	repo->is_worktree = is_worktree;

	/*

	 * We'd like to have the config, but git doesn't particularly

	 * care if it's not there, so we need to deal with that.

	 */

	error = git_repository_config_snapshot(&config, repo);

	if (error < 0 && error != GIT_ENOTFOUND)

		goto cleanup;

	if (config && (error = check_repositoryformatversion(config)) < 0)

		goto cleanup;

	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)

		repo->is_bare = 1;

	else {

		if (config &&

		    ((error = load_config_data(repo, config)) < 0 ||

		     (error = load_workdir(repo, config, &workdir)) < 0))

			goto cleanup;

	}

cleanup:

	git_buf_free(&gitdir);

	git_buf_free(&workdir);

	git_config_free(config);

	if (error < 0)

		git_repository_free(repo);

	else

		*repo_ptr = repo;

	return error;

}

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_open_from_worktree(git_repository **repo_out, git_worktree *wt)

{

	git_buf path = GIT_BUF_INIT;

	git_repository *repo = NULL;

	int len, err;

	assert(repo_out && wt);

	*repo_out = NULL;

	len = strlen(wt->gitlink_path);