/*
 * 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 "repository.h"

#include <ctype.h>

#include "git2/object.h"
#include "git2/sys/repository.h"

#include "buf.h"
#include "common.h"
#include "commit.h"
#include "grafts.h"
#include "tag.h"
#include "blob.h"
#include "futils.h"
#include "sysdir.h"
#include "filebuf.h"
#include "index.h"
#include "config.h"
#include "refs.h"
#include "filter.h"
#include "odb.h"
#include "refdb.h"
#include "remote.h"
#include "merge.h"
#include "diff_driver.h"
#include "annotated_commit.h"
#include "submodule.h"
#include "worktree.h"
#include "path.h"
#include "strmap.h"

#ifdef GIT_WIN32
# include "win32/w32_util.h"
#endif

bool git_repository__validate_ownership = true;
bool git_repository__fsync_gitdir = false;

static const struct {
    git_repository_item_t parent;
	git_repository_item_t fallback;
    const char *name;
    bool directory;
} items[] = {
	{ GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
	{ GIT_REPOSITORY_ITEM_WORKDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM__LAST, NULL, true },
	{ GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, "index", false },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "objects", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "refs", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "packed-refs", false },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "remotes", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "config", false },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "info", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "hooks", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "logs", true },
	{ GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, "modules", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "worktrees", true }
};

static int check_repositoryformatversion(int *version, git_config *config);
static int check_extensions(git_config *config, int version);
static int load_global_config(git_config **config, bool use_env);
static int load_objectformat(git_repository *repo, git_config *config);

#define GIT_COMMONDIR_FILE "commondir"
#define GIT_GITDIR_FILE "gitdir"

#define GIT_FILE_CONTENT_PREFIX "gitdir:"

#define GIT_BRANCH_DEFAULT "master"

#define GIT_REPO_VERSION_DEFAULT 0
#define GIT_REPO_VERSION_MAX 1

git_str 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_str 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_atomic_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_atomic_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_atomic_swap(repo->_config, config)) != NULL) {
		GIT_REFCOUNT_OWN(config, NULL);
		git_config_free(config);
	}

	git_repository__configmap_lookup_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_atomic_swap(repo->_index, index)) != NULL) {
		GIT_REFCOUNT_OWN(index, NULL);
		git_index_free(index);
	}
}

int git_repository__cleanup(git_repository *repo)
{
	GIT_ASSERT_ARG(repo);

	git_repository_submodule_cache_clear(repo);
	git_cache_clear(&repo->objects);
	git_attr_cache_flush(repo);
	git_grafts_free(repo->grafts);
	repo->grafts = NULL;
	git_grafts_free(repo->shallow_grafts);
	repo->shallow_grafts = NULL;

	set_config(repo, NULL);
	set_index(repo, NULL);
	set_odb(repo, NULL);
	set_refdb(repo, NULL);

	return 0;
}

void git_repository_free(git_repository *repo)
{
	size_t i;

	if (repo == NULL)
		return;

	git_repository__cleanup(repo);

	git_cache_dispose(&repo->objects);

	git_diff_driver_registry_free(repo->diff_drivers);
	repo->diff_drivers = NULL;

	for (i = 0; i < repo->reserved_names.size; i++)
		git_str_dispose(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);
}

/* Check if we have a separate commondir (e.g. we have a worktree) */
static int lookup_commondir(
	bool *separate,
	git_str *commondir,
	git_str *repository_path,
	uint32_t flags)
{
	git_str common_link = GIT_STR_INIT;
	int error;

	/* Environment variable overrides configuration */
	if ((flags & GIT_REPOSITORY_OPEN_FROM_ENV)) {
		error = git__getenv(commondir, "GIT_COMMON_DIR");

		if (!error || error != GIT_ENOTFOUND)
			goto done;
	}

	/*
	 * If there's no commondir file, the repository path is the
	 * common path, but it needs a trailing slash.
	 */
	if (!git_fs_path_contains_file(repository_path, GIT_COMMONDIR_FILE)) {
		if ((error = git_str_set(commondir, repository_path->ptr, repository_path->size)) == 0)
		    error = git_fs_path_to_dir(commondir);

		*separate = false;
		goto done;
	}

	*separate = true;

	if ((error = git_str_joinpath(&common_link, repository_path->ptr, GIT_COMMONDIR_FILE)) < 0 ||
	    (error = git_futils_readbuffer(&common_link, common_link.ptr)) < 0)
		goto done;

	git_str_rtrim(&common_link);
	if (git_fs_path_is_relative(common_link.ptr)) {
		if ((error = git_str_joinpath(commondir, repository_path->ptr, common_link.ptr)) < 0)
			goto done;
	} else {
		git_str_swap(commondir, &common_link);
	}

	/* Make sure the commondir path always has a trailing slash */
	error = git_fs_path_prettify_dir(commondir, commondir->ptr, NULL);

done:
	git_str_dispose(&common_link);
	return error;
}

GIT_INLINE(int) validate_repo_path(git_str *path)
{
	/*
	 * The longest static path in a repository (or commondir) is the
	 * packed refs file.  (Loose refs may be longer since they
	 * include the reference name, but will be validated when the
	 * path is constructed.)
	 */
	static size_t suffix_len =
		CONST_STRLEN("objects/pack/pack-.pack.lock") +
		GIT_OID_MAX_HEXSIZE;

	return git_fs_path_validate_str_length_with_suffix(
		path, suffix_len);
}

/*
 * Git repository open methods
 *
 * Open a repository object from its path
 */
static int is_valid_repository_path(
	bool *out,
	git_str *repository_path,
	git_str *common_path,
	uint32_t flags)
{
	bool separate_commondir = false;
	int error;

	*out = false;

	if ((error = lookup_commondir(&separate_commondir,
			common_path, repository_path, flags)) < 0)
		return error;

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

	/* Check files in common dir */
	if (git_fs_path_contains_dir(common_path, GIT_OBJECTS_DIR) == false)
		return 0;
	if (git_fs_path_contains_dir(common_path, GIT_REFS_DIR) == false)
		return 0;

	/* Ensure the repo (and commondir) are valid paths */
	if ((error = validate_repo_path(common_path)) < 0 ||
	    (separate_commondir &&
	     (error = validate_repo_path(repository_path)) < 0))
		return error;

	*out = true;
	return 0;
}

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 configmap cache to `unset` */
	git_repository__configmap_lookup_cache_clear(repo);

	return repo;

on_error:
	if (repo)
		git_cache_dispose(&repo->objects);

	git__free(repo);
	return NULL;
}

int git_repository_new(git_repository **out)
{
	git_repository *repo;

	*out = repo = repository_alloc();
	GIT_ERROR_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;

	int err = git_config_get_bool(&is_bare, config, "core.bare");
	if (err < 0 && err != GIT_ENOTFOUND)
		return err;

	/* Try to figure out if it's bare, default to non-bare if it's not set */
	if (err != GIT_ENOTFOUND)
		repo->is_bare = is_bare && !repo->is_worktree;
	else
		repo->is_bare = 0;

	return 0;
}

static int load_workdir(
	git_repository *repo,
	git_config *config,
	git_str *parent_path)
{
	git_config_entry *ce = NULL;
	git_str worktree = GIT_STR_INIT;
	git_str path = GIT_STR_INIT;
	git_str workdir_env = GIT_STR_INIT;
	const char *value = NULL;
	int error;

	if (repo->is_bare)
		return 0;

	/* Environment variables are preferred */
	if (repo->use_env) {
		error = git__getenv(&workdir_env, "GIT_WORK_TREE");

		if (error == 0)
			value = workdir_env.ptr;
		else if (error == GIT_ENOTFOUND)
			error = 0;
		else
			goto cleanup;
	}

	/* Examine configuration values if necessary */
	if (!value) {
		if ((error = git_config__lookup_entry(&ce, config,
				"core.worktree", false)) < 0)
			return error;

		if (ce && ce->value)
			value = ce->value;
	}

	if (repo->is_worktree) {
		char *gitlink = git_worktree__read_link(repo->gitdir, GIT_GITDIR_FILE);
		if (!gitlink) {
			error = -1;
			goto cleanup;
		}

		git_str_attach(&worktree, gitlink, 0);

		if ((git_fs_path_dirname_r(&worktree, worktree.ptr)) < 0 ||
		    git_fs_path_to_dir(&worktree) < 0) {
			error = -1;
			goto cleanup;
		}

		repo->workdir = git_str_detach(&worktree);
	} else if (value) {
		if (!*value) {
			git_error_set(GIT_ERROR_NET, "working directory cannot be set to empty path");
			error = -1;
			goto cleanup;
		}

		if ((error = git_fs_path_prettify_dir(&worktree,
				value, repo->gitdir)) < 0)
			goto cleanup;

		repo->workdir = git_str_detach(&worktree);
	} else if (parent_path && git_fs_path_isdir(parent_path->ptr)) {
		repo->workdir = git_str_detach(parent_path);
	} else {
		if (git_fs_path_dirname_r(&worktree, repo->gitdir) < 0 ||
		    git_fs_path_to_dir(&worktree) < 0) {
			error = -1;
			goto cleanup;
		}

		repo->workdir = git_str_detach(&worktree);
	}

	GIT_ERROR_CHECK_ALLOC(repo->workdir);

cleanup:
	git_str_dispose(&path);
	git_str_dispose(&workdir_env);
	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_strs 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;

	GIT_ASSERT_ARG(path);

	min_len = (size_t)(git_fs_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_fs_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_str *path_out, const char *file_path)
{
	int     error = 0;
	git_str file = GIT_STR_INIT;
	size_t  prefix_len = strlen(GIT_FILE_CONTENT_PREFIX);

	GIT_ASSERT_ARG(path_out);
	GIT_ASSERT_ARG(file_path);

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

	git_str_rtrim(&file);
	/* apparently on Windows, some people use backslashes in paths */
	git_fs_path_mkposix(file.ptr);

	if (git_str_len(&file) <= prefix_len ||
		memcmp(git_str_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
	{
		git_error_set(GIT_ERROR_REPOSITORY,
			"the `.git` file at '%s' is malformed", file_path);
		error = -1;
	}
	else if ((error = git_fs_path_dirname_r(path_out, file_path)) >= 0) {
		const char *gitlink = git_str_cstr(&file) + prefix_len;
		while (*gitlink && git__isspace(*gitlink)) gitlink++;

		error = git_fs_path_prettify_dir(
			path_out, gitlink, git_str_cstr(path_out));
	}

	git_str_dispose(&file);
	return error;
}

typedef struct {
	const char *repo_path;
	git_str tmp;
	bool *is_safe;
} validate_ownership_data;

static int validate_ownership_cb(const git_config_entry *entry, void *payload)
{
	validate_ownership_data *data = payload;

	if (strcmp(entry->value, "") == 0) {
		*data->is_safe = false;
	} else if (strcmp(entry->value, "*") == 0) {
		*data->is_safe = true;
	} else {
		const char *test_path = entry->value;

#ifdef GIT_WIN32
		/*
		 * Git for Windows does some truly bizarre things with
		 * paths that start with a forward slash; and expects you
		 * to escape that with `%(prefix)`. This syntax generally
		 * means to add the prefix that Git was installed to -- eg
		 * `/usr/local` -- unless it's an absolute path, in which
		 * case the leading `%(prefix)/` is just removed. And Git
		 * for Windows expects you to use this syntax for absolute
		 * Unix-style paths (in "Git Bash" or Windows Subsystem for
		 * Linux).
		 *
		 * Worse, the behavior used to be that a leading `/` was
		 * not absolute. It would indicate that Git for Windows
		 * should add the prefix. So `//` is required for absolute
		 * Unix-style paths. Yes, this is truly horrifying.
		 *
		 * Emulate that behavior, I guess, but only for absolute
		 * paths. We won't deal with the Git install prefix. Also,
		 * give WSL users an escape hatch where they don't have to
		 * think about this and can use the literal path that the
		 * filesystem APIs provide (`//wsl.localhost/...`).
		 */
		if (strncmp(test_path, "%(prefix)//", strlen("%(prefix)//")) == 0)
			test_path += strlen("%(prefix)/");
		else if (strncmp(test_path, "//", 2) == 0 &&
		         strncmp(test_path, "//wsl.localhost/", strlen("//wsl.localhost/")) != 0)
			test_path++;
#endif

		if (git_fs_path_prettify_dir(&data->tmp, test_path, NULL) == 0 &&
		    strcmp(data->tmp.ptr, data->repo_path) == 0)
			*data->is_safe = true;
	}

	return 0;
}

static int validate_ownership_config(
	bool *is_safe,
	const char *path,
	bool use_env)
{
	validate_ownership_data ownership_data = {
		path, GIT_STR_INIT, is_safe
	};
	git_config *config;
	int error;

	if (load_global_config(&config, use_env) != 0)
		return 0;

	error = git_config_get_multivar_foreach(config,
		"safe.directory", NULL,
		validate_ownership_cb,
		&ownership_data);

	if (error == GIT_ENOTFOUND)
		error = 0;

	git_config_free(config);
	git_str_dispose(&ownership_data.tmp);

	return error;
}

static int validate_ownership_path(bool *is_safe, const char *path)
{
	git_fs_path_owner_t owner_level =
		GIT_FS_PATH_OWNER_CURRENT_USER |
		GIT_FS_PATH_USER_IS_ADMINISTRATOR |
		GIT_FS_PATH_OWNER_RUNNING_SUDO;
	int error = 0;

	if (path)
		error = git_fs_path_owner_is(is_safe, path, owner_level);

	if (error == GIT_ENOTFOUND) {
		*is_safe = true;
		error = 0;
	} else if (error == GIT_EINVALID) {
		*is_safe = false;
		error = 0;
	}

	return error;
}

static int validate_ownership(git_repository *repo)
{
	const char *validation_paths[3] = { NULL }, *path;
	size_t validation_len = 0, i;
	bool is_safe = false;
	int error = 0;

	/*
	 * If there's a worktree, validate the permissions to it *and*
	 * the git directory, and use the worktree as the configuration
	 * key for allowlisting the directory. In a bare setup, only
	 * look at the gitdir and use that as the allowlist. So we
	 * examine all `validation_paths` but use only the first as
	 * the configuration lookup.
	 */

	if (repo->workdir)
		validation_paths[validation_len++] = repo->workdir;

	if (repo->gitlink)
		validation_paths[validation_len++] = repo->gitlink;

	validation_paths[validation_len++] = repo->gitdir;

	for (i = 0; i < validation_len; i++) {
		path = validation_paths[i];

		if ((error = validate_ownership_path(&is_safe, path)) < 0)
			goto done;

		if (!is_safe)
			break;
	}

	if (is_safe ||
	    (error = validate_ownership_config(
			&is_safe, validation_paths[0], repo->use_env)) < 0)
		goto done;

	if (!is_safe) {
		git_error_set(GIT_ERROR_CONFIG,
			"repository path '%s' is not owned by current user",
			path);
		error = GIT_EOWNER;
	}

done:
	return error;
}

struct repo_paths {
	git_str gitdir;
	git_str workdir;
	git_str gitlink;
	git_str commondir;
};

#define REPO_PATHS_INIT { GIT_STR_INIT }

GIT_INLINE(void) repo_paths_dispose(struct repo_paths *paths)
{
	git_str_dispose(&paths->gitdir);
	git_str_dispose(&paths->workdir);
	git_str_dispose(&paths->gitlink);
	git_str_dispose(&paths->commondir);
}

static int find_repo_traverse(
	struct repo_paths *out,
	const char *start_path,
	const char *ceiling_dirs,
	uint32_t flags)
{
	git_str path = GIT_STR_INIT;
	git_str repo_link = GIT_STR_INIT;
	git_str common_link = GIT_STR_INIT;
	struct stat st;
	dev_t initial_device = 0;
	int min_iterations;
	bool in_dot_git, is_valid;
	size_t ceiling_offset = 0;
	int error;

	git_str_clear(&out->gitdir);

	if ((error = git_fs_path_prettify(&path, start_path, NULL)) < 0)
		return error;

	/*
	 * In each loop we look first for a `.git` dir within the
	 * directory, then to see if the directory itself is a repo.
	 *
	 * In other words: if we start in /a/b/c, then we look at:
	 * /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) {
				if ((error = git_str_joinpath(&path, path.ptr, DOT_GIT)) < 0)
					goto out;
			}
			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 ((error = is_valid_repository_path(&is_valid, &path, &common_link, flags)) < 0)
					goto out;

				if (is_valid) {
					if ((error = git_fs_path_to_dir(&path)) < 0 ||
					    (error = git_str_set(&out->gitdir, path.ptr, path.size)) < 0)
						goto out;

					if ((error = git_str_attach(&out->gitlink, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0)
						goto out;

					git_str_swap(&common_link, &out->commondir);

					break;
				}
			} else if (S_ISREG(st.st_mode) && git__suffixcmp(path.ptr, "/" DOT_GIT) == 0) {
				if ((error = read_gitfile(&repo_link, path.ptr)) < 0 ||
				    (error = is_valid_repository_path(&is_valid, &repo_link, &common_link, flags)) < 0)
					goto out;

				if (is_valid) {
					git_str_swap(&out->gitdir, &repo_link);

					if ((error = git_str_put(&out->gitlink, path.ptr, path.size)) < 0)
						goto out;

					git_str_swap(&common_link, &out->commondir);
				}
				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 ((error = git_fs_path_dirname_r(&path, path.ptr)) < 0)
			goto out;

		/*
		 * 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 (!(flags & GIT_REPOSITORY_OPEN_BARE)) {
		if (!git_str_len(&out->gitdir))
			git_str_clear(&out->workdir);
		else if ((error = git_fs_path_dirname_r(&out->workdir, path.ptr)) < 0 ||
			 (error = git_fs_path_to_dir(&out->workdir)) < 0)
			goto out;
	}

	/* If we didn't find the repository, and we don't have any other
	 * error to report, report that. */
	if (!git_str_len(&out->gitdir)) {
		git_error_set(GIT_ERROR_REPOSITORY, "could not find repository at '%s'", start_path);
		error = GIT_ENOTFOUND;
		goto out;
	}

out:
	if (error)
		repo_paths_dispose(out);

	git_str_dispose(&path);
	git_str_dispose(&repo_link);
	git_str_dispose(&common_link);
	return error;
}

static int load_grafts(git_repository *repo)
{
	git_str path = GIT_STR_INIT;
	int error;

	if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
	    (error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 ||
	    (error = git_grafts_open_or_refresh(&repo->grafts, path.ptr, repo->oid_type)) < 0)
		goto error;

	git_str_clear(&path);

	if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0 ||
	    (error = git_grafts_open_or_refresh(&repo->shallow_grafts, path.ptr, repo->oid_type)) < 0)
		goto error;

error:
	git_str_dispose(&path);
	return error;
}

static int find_repo(
	struct repo_paths *out,
	const char *start_path,
	const char *ceiling_dirs,
	uint32_t flags)
{
	bool use_env = !!(flags & GIT_REPOSITORY_OPEN_FROM_ENV);
	git_str gitdir_buf = GIT_STR_INIT,
	        ceiling_dirs_buf = GIT_STR_INIT,
	        across_fs_buf = GIT_STR_INIT;
	int error;

	if (use_env && !start_path) {
		error = git__getenv(&gitdir_buf, "GIT_DIR");

		if (!error) {
			start_path = gitdir_buf.ptr;
			flags |= GIT_REPOSITORY_OPEN_NO_SEARCH;
			flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT;
		} else if (error == GIT_ENOTFOUND) {
			start_path = ".";
		} else {
			goto done;
		}
	}

	if (use_env && !ceiling_dirs) {
		error = git__getenv(&ceiling_dirs_buf,
			"GIT_CEILING_DIRECTORIES");

		if (!error)
			ceiling_dirs = ceiling_dirs_buf.ptr;
		else if (error != GIT_ENOTFOUND)
			goto done;
	}

	if (use_env) {
		error = git__getenv(&across_fs_buf,
			"GIT_DISCOVERY_ACROSS_FILESYSTEM");

		if (!error) {
			int across_fs = 0;

			if ((error = git_config_parse_bool(&across_fs,
				git_str_cstr(&across_fs_buf))) < 0)
				goto done;

			if (across_fs)
				flags |= GIT_REPOSITORY_OPEN_CROSS_FS;
		} else if (error != GIT_ENOTFOUND) {
			goto done;
		}
	}

	error = find_repo_traverse(out, start_path, ceiling_dirs, flags);

done:
	git_str_dispose(&gitdir_buf);
	git_str_dispose(&ceiling_dirs_buf);
	git_str_dispose(&across_fs_buf);

	return error;
}

static int obtain_config_and_set_oid_type(
	git_config **config_ptr,
	git_repository *repo)
{
	int error;
	git_config *config = NULL;
	int version = 0;

	/*
	 * 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 out;

	if (config &&
	    (error = check_repositoryformatversion(&version, config)) < 0)
		goto out;

	if ((error = check_extensions(config, version)) < 0)
		goto out;

	if (version > 0) {
		if ((error = load_objectformat(repo, config)) < 0)
			goto out;
	} else {
		repo->oid_type = GIT_OID_DEFAULT;
	}

out:
	*config_ptr = config;

	return error;
}

int git_repository_open_bare(
	git_repository **repo_ptr,
	const char *bare_path)
{
	git_str path = GIT_STR_INIT, common_path = GIT_STR_INIT;
	git_repository *repo = NULL;
	bool is_valid;
	int error;
	git_config *config;

	if ((error = git_fs_path_prettify_dir(&path, bare_path, NULL)) < 0 ||
	    (error = is_valid_repository_path(&is_valid, &path, &common_path, 0)) < 0)
		return error;

	if (!is_valid) {
		git_str_dispose(&path);
		git_str_dispose(&common_path);
		git_error_set(GIT_ERROR_REPOSITORY, "path is not a repository: %s", bare_path);
		return GIT_ENOTFOUND;
	}

	repo = repository_alloc();
	GIT_ERROR_CHECK_ALLOC(repo);

	repo->gitdir = git_str_detach(&path);
	GIT_ERROR_CHECK_ALLOC(repo->gitdir);
	repo->commondir = git_str_detach(&common_path);
	GIT_ERROR_CHECK_ALLOC(repo->commondir);

	/* of course we're bare! */
	repo->is_bare = 1;
	repo->is_worktree = 0;
	repo->workdir = NULL;

	if ((error = obtain_config_and_set_oid_type(&config, repo)) < 0)
		goto cleanup;

	*repo_ptr = repo;

cleanup:
	git_config_free(config);

	return error;
}

static int repo_load_namespace(git_repository *repo)
{
	git_str namespace_buf = GIT_STR_INIT;
	int error;

	if (!repo->use_env)
		return 0;

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

	if (error == 0)
		repo->namespace = git_str_detach(&namespace_buf);
	else if (error != GIT_ENOTFOUND)
		return error;

	return 0;
}

static int repo_is_worktree(unsigned *out, const git_repository *repo)
{
	git_str gitdir_link = GIT_STR_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_str_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_fs_path_exists(gitdir_link.ptr);

	git_str_dispose(&gitdir_link);
	return error;
}

int git_repository_open_ext(
	git_repository **repo_ptr,
	const char *start_path,
	unsigned int flags,
	const char *ceiling_dirs)
{
	struct repo_paths paths = { GIT_STR_INIT };
	git_repository *repo = NULL;
	git_config *config = NULL;
	unsigned is_worktree;
	int error;

	if (repo_ptr)
		*repo_ptr = NULL;

	error = find_repo(&paths, start_path, ceiling_dirs, flags);

	if (error < 0 || !repo_ptr)
		goto cleanup;

	repo = repository_alloc();
	GIT_ERROR_CHECK_ALLOC(repo);

	repo->use_env = !!(flags & GIT_REPOSITORY_OPEN_FROM_ENV);

	repo->gitdir = git_str_detach(&paths.gitdir);
	GIT_ERROR_CHECK_ALLOC(repo->gitdir);

	if (paths.gitlink.size) {
		repo->gitlink = git_str_detach(&paths.gitlink);
		GIT_ERROR_CHECK_ALLOC(repo->gitlink);
	}
	if (paths.commondir.size) {
		repo->commondir = git_str_detach(&paths.commondir);
		GIT_ERROR_CHECK_ALLOC(repo->commondir);
	}

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

	repo->is_worktree = is_worktree;

	error = obtain_config_and_set_oid_type(&config, repo);
	if (error < 0)
		goto cleanup;

	if ((error = load_grafts(repo)) < 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, &paths.workdir)) < 0))
			goto cleanup;
	}

	if ((error = repo_load_namespace(repo)) < 0)
		goto cleanup;

	/*
	 * Ensure that the git directory and worktree are
	 * owned by the current user.
	 */
	if (git_repository__validate_ownership &&
	    (error = validate_ownership(repo)) < 0)
		goto cleanup;

cleanup:
	repo_paths_dispose(&paths);
	git_config_free(config);

	if (error < 0)
		git_repository_free(repo);
	else if (repo_ptr)
		*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_str path = GIT_STR_INIT;
	git_repository *repo = NULL;
	size_t len;
	int err;

	GIT_ASSERT_ARG(repo_out);
	GIT_ASSERT_ARG(wt);

	*repo_out = NULL;
	len = strlen(wt->gitlink_path);

	if (len <= 4 || strcasecmp(wt->gitlink_path + len - 4, ".git")) {
		err = -1;
		goto out;
	}

	if ((err = git_str_set(&path, wt->gitlink_path, len - 4)) < 0)
		goto out;

	if ((err = git_repository_open(&repo, path.ptr)) < 0)
		goto out;

	*repo_out = repo;

out:
	git_str_dispose(&path);

	return err;
}

int git_repository__wrap_odb(
	git_repository **out,
	git_odb *odb,
	git_oid_t oid_type)
{
	git_repository *repo;

	repo = repository_alloc();
	GIT_ERROR_CHECK_ALLOC(repo);

	repo->oid_type = oid_type;

	git_repository_set_odb(repo, odb);
	*out = repo;

	return 0;
}

#ifdef GIT_EXPERIMENTAL_SHA256
int git_repository_wrap_odb(
	git_repository **out,
	git_odb *odb,
	git_oid_t oid_type)
{
	return git_repository__wrap_odb(out, odb, oid_type);
}
#else
int git_repository_wrap_odb(git_repository **out, git_odb *odb)
{
	return git_repository__wrap_odb(out, odb, GIT_OID_DEFAULT);
}
#endif

int git_repository_discover(
	git_buf *out,
	const char *start_path,
	int across_fs,
	const char *ceiling_dirs)
{
	struct repo_paths paths = { GIT_STR_INIT };
	uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;
	int error;

	GIT_ASSERT_ARG(start_path);

	if ((error = find_repo(&paths, start_path, ceiling_dirs, flags)) == 0)
		error = git_buf_fromstr(out, &paths.gitdir);

	repo_paths_dispose(&paths);
	return error;
}

static int load_config(
	git_config **out,
	git_repository *repo,
	const char *global_config_path,
	const char *xdg_config_path,
	const char *system_config_path,
	const char *programdata_path)
{
	int error;
	git_str config_path = GIT_STR_INIT;
	git_config *cfg = NULL;

	GIT_ASSERT_ARG(out);

	if ((error = git_config_new(&cfg)) < 0)
		return error;

	if (repo) {
		if ((error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0)
			error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0);

		if (error && error != GIT_ENOTFOUND)
			goto on_error;

		git_str_dispose(&config_path);
	}

	if (global_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, global_config_path, GIT_CONFIG_LEVEL_GLOBAL, repo, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;

	if (xdg_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, xdg_config_path, GIT_CONFIG_LEVEL_XDG, repo, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;

	if (system_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, system_config_path, GIT_CONFIG_LEVEL_SYSTEM, repo, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;

	if (programdata_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, programdata_path, GIT_CONFIG_LEVEL_PROGRAMDATA, repo, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;

	git_error_clear(); /* clear any lingering ENOTFOUND errors */

	*out = cfg;
	return 0;

on_error:
	git_str_dispose(&config_path);
	git_config_free(cfg);
	*out = NULL;
	return error;
}

static const char *path_unless_empty(git_str *buf)
{
	return git_str_len(buf) > 0 ? git_str_cstr(buf) : NULL;
}

GIT_INLINE(int) config_path_system(git_str *out, bool use_env)
{
	if (use_env) {
		git_str no_system_buf = GIT_STR_INIT;
		int no_system = 0;
		int error;

		error = git__getenv(&no_system_buf, "GIT_CONFIG_NOSYSTEM");

		if (error && error != GIT_ENOTFOUND)
			return error;

		error = git_config_parse_bool(&no_system, no_system_buf.ptr);
		git_str_dispose(&no_system_buf);

		if (no_system)
			return 0;

		error = git__getenv(out, "GIT_CONFIG_SYSTEM");

		if (error == 0 || error != GIT_ENOTFOUND)
			return 0;
	}

	git_config__find_system(out);
	return 0;
}

GIT_INLINE(int) config_path_global(git_str *out, bool use_env)
{
	if (use_env) {
		int error = git__getenv(out, "GIT_CONFIG_GLOBAL");

		if (error == 0 || error != GIT_ENOTFOUND)
			return 0;
	}

	git_config__find_global(out);
	return 0;
}

int git_repository_config__weakptr(git_config **out, git_repository *repo)
{
	int error = 0;

	if (repo->_config == NULL) {
		git_str system_buf = GIT_STR_INIT;
		git_str global_buf = GIT_STR_INIT;
		git_str xdg_buf = GIT_STR_INIT;
		git_str programdata_buf = GIT_STR_INIT;
		bool use_env = repo->use_env;
		git_config *config;

		if (!(error = config_path_system(&system_buf, use_env)) &&
		    !(error = config_path_global(&global_buf, use_env))) {
			git_config__find_xdg(&xdg_buf);
			git_config__find_programdata(&programdata_buf);
		}

		if (!error) {
			/*
			 * If there is no global file, open a backend
			 * for it anyway.
			 */
			if (git_str_len(&global_buf) == 0)
				git_config__global_location(&global_buf);

			error = load_config(
				&config, repo,
				path_unless_empty(&global_buf),
				path_unless_empty(&xdg_buf),
				path_unless_empty(&system_buf),
				path_unless_empty(&programdata_buf));
		}

		if (!error) {
			GIT_REFCOUNT_OWN(config, repo);

			if (git_atomic_compare_and_swap(&repo->_config, NULL, config) != NULL) {
				GIT_REFCOUNT_OWN(config, NULL);
				git_config_free(config);
			}
		}

		git_str_dispose(&global_buf);
		git_str_dispose(&xdg_buf);
		git_str_dispose(&system_buf);
		git_str_dispose(&programdata_buf);
	}

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

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

int git_repository_config_snapshot(git_config **out, git_repository *repo)
{
	int error;
	git_config *weak;

	if ((error = git_repository_config__weakptr(&weak, repo)) < 0)
		return error;

	return git_config_snapshot(out, weak);
}

int git_repository_set_config(git_repository *repo, git_config *config)
{
	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(config);

	set_config(repo, config);
	return 0;
}

static int repository_odb_path(git_str *out, git_repository *repo)
{
	int error = GIT_ENOTFOUND;

	if (repo->use_env)
		error = git__getenv(out, "GIT_OBJECT_DIRECTORY");

	if (error == GIT_ENOTFOUND)
		error = git_repository__item_path(out, repo,
			GIT_REPOSITORY_ITEM_OBJECTS);

	return error;
}

static int repository_odb_alternates(
	git_odb *odb,
	git_repository *repo)
{
	git_str alternates = GIT_STR_INIT;
	char *sep, *alt;
	int error;

	if (!repo->use_env)
		return 0;

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

	if (error != 0)
		return (error == GIT_ENOTFOUND) ? 0 : error;

	alt = alternates.ptr;

	while (*alt) {
		sep = strchr(alt, GIT_PATH_LIST_SEPARATOR);

		if (sep)
			*sep = '\0';

		error = git_odb_add_disk_alternate(odb, alt);

		if (sep)
			alt = sep + 1;
		else
			break;
	}

	git_str_dispose(&alternates);
	return 0;
}

int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
{
	int error = 0;

	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(out);

	*out = git_atomic_load(repo->_odb);
	if (*out == NULL) {
		git_str odb_path = GIT_STR_INIT;
		git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT;
		git_odb *odb;

		odb_opts.oid_type = repo->oid_type;

		if ((error = repository_odb_path(&odb_path, repo)) < 0 ||
		    (error = git_odb__new(&odb, &odb_opts)) < 0 ||
		    (error = repository_odb_alternates(odb, repo)) < 0)
			return error;

		GIT_REFCOUNT_OWN(odb, repo);

		if ((error = git_odb__set_caps(odb, GIT_ODB_CAP_FROM_OWNER)) < 0 ||
			(error = git_odb__add_default_backends(odb, odb_path.ptr, 0, 0)) < 0) {
			git_odb_free(odb);
			return error;
		}

		if (git_atomic_compare_and_swap(&repo->_odb, NULL, odb) != NULL) {
			GIT_REFCOUNT_OWN(odb, NULL);
			git_odb_free(odb);
		}

		git_str_dispose(&odb_path);
		*out = git_atomic_load(repo->_odb);
	}

	return error;
}

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

int git_repository_set_odb(git_repository *repo, git_odb *odb)
{
	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(odb);

	set_odb(repo, odb);
	return 0;
}

int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo)
{
	int error = 0;

	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(repo);

	if (repo->_refdb == NULL) {
		git_refdb *refdb;

		error = git_refdb_open(&refdb, repo);
		if (!error) {
			GIT_REFCOUNT_OWN(refdb, repo);

			if (git_atomic_compare_and_swap(&repo->_refdb, NULL, refdb) != NULL) {
				GIT_REFCOUNT_OWN(refdb, NULL);
				git_refdb_free(refdb);
			}
		}
	}

	*out = repo->_refdb;
	return error;
}

int git_repository_refdb(git_refdb **out, git_repository *repo)
{
	if (git_repository_refdb__weakptr(out, repo) < 0)
		return -1;

	GIT_REFCOUNT_INC(*out);
	return 0;
}

int git_repository_set_refdb(git_repository *repo, git_refdb *refdb)
{
	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(refdb);

	set_refdb(repo, refdb);
	return 0;
}

static int repository_index_path(git_str *out, git_repository *repo)
{
	int error = GIT_ENOTFOUND;

	if (repo->use_env)
		error = git__getenv(out, "GIT_INDEX_FILE");

	if (error == GIT_ENOTFOUND)
		error = git_repository__item_path(out, repo,
			GIT_REPOSITORY_ITEM_INDEX);

	return error;
}

int git_repository_index__weakptr(git_index **out, git_repository *repo)
{
	int error = 0;

	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(repo);

	if (repo->_index == NULL) {
		git_str index_path = GIT_STR_INIT;
		git_index *index;

		if ((error = repository_index_path(&index_path, repo)) < 0)
			return error;

		error = git_index__open(&index, index_path.ptr, repo->oid_type);

		if (!error) {
			GIT_REFCOUNT_OWN(index, repo);

			if (git_atomic_compare_and_swap(&repo->_index, NULL, index) != NULL) {
				GIT_REFCOUNT_OWN(index, NULL);
				git_index_free(index);
			}

			error = git_index_set_caps(repo->_index,
			                           GIT_INDEX_CAPABILITY_FROM_OWNER);
		}

		git_str_dispose(&index_path);
	}

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

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

int git_repository_set_index(git_repository *repo, git_index *index)
{
	GIT_ASSERT_ARG(repo);
	set_index(repo, index);
	return 0;
}

int git_repository_grafts__weakptr(git_grafts **out, git_repository *repo)
{
	GIT_ASSERT_ARG(out && repo);
	GIT_ASSERT(repo->grafts);
	*out = repo->grafts;
	return 0;
}

int git_repository_shallow_grafts__weakptr(git_grafts **out, git_repository *repo)
{
	GIT_ASSERT_ARG(out && repo);
	GIT_ASSERT(repo->shallow_grafts);
	*out = repo->shallow_grafts;
	return 0;
}

int git_repository_set_namespace(git_repository *repo, const char *namespace)
{
	git__free(repo->namespace);

	if (namespace == NULL) {
		repo->namespace = NULL;
		return 0;
	}

	return (repo->namespace = git__strdup(namespace)) ? 0 : -1;
}

const char *git_repository_get_namespace(git_repository *repo)
{
	return repo->namespace;
}

#ifdef GIT_WIN32
static int reserved_names_add8dot3(git_repository *repo, const char *path)
{
	char *name = git_win32_path_8dot3_name(path);
	const char *def = GIT_DIR_SHORTNAME;
	const char *def_dot_git = DOT_GIT;
	size_t name_len, def_len = CONST_STRLEN(GIT_DIR_SHORTNAME);
	size_t def_dot_git_len = CONST_STRLEN(DOT_GIT);
	git_str *buf;

	if (!name)
		return 0;

	name_len = strlen(name);

	if ((name_len == def_len && memcmp(name, def, def_len) == 0) ||
		(name_len == def_dot_git_len && memcmp(name, def_dot_git, def_dot_git_len) == 0)) {
		git__free(name);
		return 0;
	}

	if ((buf = git_array_alloc(repo->reserved_names)) == NULL)
		return -1;

	git_str_attach(buf, name, name_len);
	return true;
}

bool git_repository__reserved_names(
	git_str **out, size_t *outlen, git_repository *repo, bool include_ntfs)
{
	GIT_UNUSED(include_ntfs);

	if (repo->reserved_names.size == 0) {
		git_str *buf;
		size_t i;

		/* Add the static defaults */
		for (i = 0; i < git_repository__reserved_names_win32_len; i++) {
			if ((buf = git_array_alloc(repo->reserved_names)) == NULL)
				goto on_error;

			buf->ptr = git_repository__reserved_names_win32[i].ptr;
			buf->size = git_repository__reserved_names_win32[i].size;
		}

		/* Try to add any repo-specific reserved names - the gitlink file
		 * within a submodule or the repository (if the repository directory
		 * is beneath the workdir).  These are typically `.git`, but should
		 * be protected in case they are not.  Note, repo and workdir paths
		 * are always prettified to end in `/`, so a prefixcmp is safe.
		 */
		if (!repo->is_bare) {
			int (*prefixcmp)(const char *, const char *);
			int error, ignorecase;

			error = git_repository__configmap_lookup(
				&ignorecase, repo, GIT_CONFIGMAP_IGNORECASE);
			prefixcmp = (error || ignorecase) ? git__prefixcmp_icase :
				git__prefixcmp;

			if (repo->gitlink &&
				reserved_names_add8dot3(repo, repo->gitlink) < 0)
				goto on_error;

			if (repo->gitdir &&
				prefixcmp(repo->gitdir, repo->workdir) == 0 &&
				reserved_names_add8dot3(repo, repo->gitdir) < 0)
				goto on_error;
		}
	}

	*out = repo->reserved_names.ptr;
	*outlen = repo->reserved_names.size;

	return true;

	/* Always give good defaults, even on OOM */
on_error:
	*out = git_repository__reserved_names_win32;
	*outlen = git_repository__reserved_names_win32_len;

	return false;
}
#else
bool git_repository__reserved_names(
	git_str **out, size_t *outlen, git_repository *repo, bool include_ntfs)
{
	GIT_UNUSED(repo);

	if (include_ntfs) {
		*out = git_repository__reserved_names_win32;
		*outlen = git_repository__reserved_names_win32_len;
	} else {
		*out = git_repository__reserved_names_posix;
		*outlen = git_repository__reserved_names_posix_len;
	}

	return true;
}
#endif

static int check_repositoryformatversion(int *version, git_config *config)
{
	int error;

	error = git_config_get_int32(version, config, "core.repositoryformatversion");

	/* git ignores this if the config variable isn't there */
	if (error == GIT_ENOTFOUND)
		return 0;

	if (error < 0)
		return -1;

	if (*version < 0) {
		git_error_set(GIT_ERROR_REPOSITORY,
			"invalid repository version %d", *version);
	}

	if (GIT_REPO_VERSION_MAX < *version) {
		git_error_set(GIT_ERROR_REPOSITORY,
			"unsupported repository version %d; only versions up to %d are supported",
			*version, GIT_REPO_VERSION_MAX);
		return -1;
	}

	return 0;
}

static const char *builtin_extensions[] = {
	"noop",
	"objectformat"
};

static git_vector user_extensions = { 0, git__strcmp_cb };

static int check_valid_extension(const git_config_entry *entry, void *payload)
{
	git_str cfg = GIT_STR_INIT;
	bool reject;
	const char *extension;
	size_t i;
	int error = 0;

	GIT_UNUSED(payload);

	git_vector_foreach (&user_extensions, i, extension) {
		git_str_clear(&cfg);

		/*
		 * Users can specify that they don't want to support an
		 * extension with a '!' prefix.
		 */
		if ((reject = (extension[0] == '!')) == true)
			extension = &extension[1];

		if ((error = git_str_printf(&cfg, "extensions.%s", extension)) < 0)
			goto done;

		if (strcmp(entry->name, cfg.ptr) == 0) {
			if (reject)
				goto fail;

			goto done;
		}
	}

	for (i = 0; i < ARRAY_SIZE(builtin_extensions); i++) {
		git_str_clear(&cfg);
		extension = builtin_extensions[i];

		if ((error = git_str_printf(&cfg, "extensions.%s", extension)) < 0)
			goto done;

		if (strcmp(entry->name, cfg.ptr) == 0)
			goto done;
	}

fail:
	git_error_set(GIT_ERROR_REPOSITORY, "unsupported extension name %s", entry->name);
	error = -1;

done:
	git_str_dispose(&cfg);
	return error;
}

static int check_extensions(git_config *config, int version)
{
	if (version < 1)
		return 0;

	return git_config_foreach_match(config, "^extensions\\.", check_valid_extension, NULL);
}

static int load_objectformat(git_repository *repo, git_config *config)
{
	git_config_entry *entry = NULL;
	int error;

	if ((error = git_config_get_entry(&entry, config, "extensions.objectformat")) < 0) {
		if (error == GIT_ENOTFOUND) {
			repo->oid_type = GIT_OID_DEFAULT;
			git_error_clear();
			error = 0;
		}

		goto done;
	}

	if ((repo->oid_type = git_oid_type_fromstr(entry->value)) == 0) {
		git_error_set(GIT_ERROR_REPOSITORY,
			"unknown object format '%s'", entry->value);
		error = GIT_EINVALID;
	}

done:
	git_config_entry_free(entry);
	return error;
}

int git_repository__set_objectformat(
	git_repository *repo,
	git_oid_t oid_type)
{
	git_config *cfg;

	/*
	 * Older clients do not necessarily understand the
	 * `objectformat` extension, even when it's set to an
	 * object format that they understand (SHA1). Do not set
	 * the objectformat extension unless we're not using the
	 * default object format.
	 */
	if (oid_type == GIT_OID_DEFAULT)
		return 0;

	if (!git_repository_is_empty(repo) && repo->oid_type != oid_type) {
		git_error_set(GIT_ERROR_REPOSITORY,
			"cannot change object id type of existing repository");
		return -1;
	}

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

	if (git_config_set_int32(cfg,
			"core.repositoryformatversion", 1) < 0 ||
	    git_config_set_string(cfg, "extensions.objectformat",
			git_oid_type_name(oid_type)) < 0)
		return -1;

	/*
	 * During repo init, we may create some backends with the
	 * default oid type. Clear them so that we create them with
	 * the proper oid type.
	 */
	if (repo->oid_type != oid_type) {
		set_index(repo, NULL);
		set_odb(repo, NULL);
		set_refdb(repo, NULL);

		repo->oid_type = oid_type;
	}

	return 0;
}

int git_repository__extensions(char ***out, size_t *out_len)
{
	git_vector extensions;
	const char *builtin, *user;
	char *extension;
	size_t i, j;

	if (git_vector_init(&extensions, 8, git__strcmp_cb) < 0)
		return -1;

	for (i = 0; i < ARRAY_SIZE(builtin_extensions); i++) {
		bool match = false;

		builtin = builtin_extensions[i];

		git_vector_foreach (&user_extensions, j, user) {
			if (user[0] == '!' && strcmp(builtin, &user[1]) == 0) {
				match = true;
				break;
			}
		}

		if (match)
			continue;

		if ((extension = git__strdup(builtin)) == NULL ||
		    git_vector_insert(&extensions, extension) < 0)
			return -1;
	}

	git_vector_foreach (&user_extensions, i, user) {
		if (user[0] == '!')
			continue;

		if ((extension = git__strdup(user)) == NULL ||
		    git_vector_insert(&extensions, extension) < 0)
			return -1;
	}

	git_vector_sort(&extensions);

	*out = (char **)git_vector_detach(out_len, NULL, &extensions);
	return 0;
}

static int dup_ext_err(void **old, void *extension)
{
	GIT_UNUSED(old);
	GIT_UNUSED(extension);
	return GIT_EEXISTS;
}

int git_repository__set_extensions(const char **extensions, size_t len)
{
	char *extension;
	size_t i, j;
	int error;

	git_repository__free_extensions();

	for (i = 0; i < len; i++) {
		bool is_builtin = false;

		for (j = 0; j < ARRAY_SIZE(builtin_extensions); j++) {
			if (strcmp(builtin_extensions[j], extensions[i]) == 0) {
				is_builtin = true;
				break;
			}
		}

		if (is_builtin)
			continue;

		if ((extension = git__strdup(extensions[i])) == NULL)
			return -1;

		if ((error = git_vector_insert_sorted(&user_extensions, extension, dup_ext_err)) < 0) {
			git__free(extension);

			if (error != GIT_EEXISTS)
				return -1;
		}
	}

	return 0;
}

void git_repository__free_extensions(void)
{
	git_vector_free_deep(&user_extensions);
}

int git_repository_create_head(const char *git_dir, const char *ref_name)
{
	git_str ref_path = GIT_STR_INIT;
	git_filebuf ref = GIT_FILEBUF_INIT;
	const char *fmt;
	int error;

	if ((error = git_str_joinpath(&ref_path, git_dir, GIT_HEAD_FILE)) < 0 ||
	    (error = git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE)) < 0)
		goto out;

	if (git__prefixcmp(ref_name, GIT_REFS_DIR) == 0)
		fmt = "ref: %s\n";
	else
		fmt = "ref: " GIT_REFS_HEADS_DIR "%s\n";

	if ((error = git_filebuf_printf(&ref, fmt, ref_name)) < 0 ||
	    (error = git_filebuf_commit(&ref)) < 0)
		goto out;

out:
	git_str_dispose(&ref_path);
	git_filebuf_cleanup(&ref);
	return error;
}

static bool is_chmod_supported(const char *file_path)
{
	struct stat st1, st2;

	if (p_stat(file_path, &st1) < 0)
		return false;

	if (p_chmod(file_path, st1.st_mode ^ S_IXUSR) < 0)
		return false;

	if (p_stat(file_path, &st2) < 0)
		return false;

	return (st1.st_mode != st2.st_mode);
}

static bool is_filesystem_case_insensitive(const char *gitdir_path)
{
	git_str path = GIT_STR_INIT;
	int is_insensitive = -1;

	if (!git_str_joinpath(&path, gitdir_path, "CoNfIg"))
		is_insensitive = git_fs_path_exists(git_str_cstr(&path));

	git_str_dispose(&path);
	return is_insensitive;
}

/*
 * Return a configuration object with only the global and system
 * configurations; no repository-level configuration.
 */
static int load_global_config(git_config **config, bool use_env)
{
	git_str global_buf = GIT_STR_INIT;
	git_str xdg_buf = GIT_STR_INIT;
	git_str system_buf = GIT_STR_INIT;
	git_str programdata_buf = GIT_STR_INIT;
	int error;

	if (!(error = config_path_system(&system_buf, use_env)) &&
	    !(error = config_path_global(&global_buf, use_env))) {
		git_config__find_xdg(&xdg_buf);
		git_config__find_programdata(&programdata_buf);

		error = load_config(config, NULL,
		                    path_unless_empty(&global_buf),
		                    path_unless_empty(&xdg_buf),
		                    path_unless_empty(&system_buf),
		                    path_unless_empty(&programdata_buf));
	}

	git_str_dispose(&global_buf);
	git_str_dispose(&xdg_buf);
	git_str_dispose(&system_buf);
	git_str_dispose(&programdata_buf);

	return error;
}

static bool are_symlinks_supported(const char *wd_path, bool use_env)
{
	git_config *config = NULL;
	int symlinks = 0;

	/*
	 * To emulate Git for Windows, symlinks on Windows must be explicitly
	 * opted-in.  We examine the system configuration for a core.symlinks
	 * set to true.  If found, we then examine the filesystem to see if
	 * symlinks are _actually_ supported by the current user.  If that is
	 * _not_ set, then we do not test or enable symlink support.
	 */
#ifdef GIT_WIN32
	if (load_global_config(&config, use_env) < 0 ||
	    git_config_get_bool(&symlinks, config, "core.symlinks") < 0 ||
	    !symlinks)
		goto done;
#else
	GIT_UNUSED(use_env);
#endif

	if (!(symlinks = git_fs_path_supports_symlinks(wd_path)))
		goto done;

done:
	git_config_free(config);
	return symlinks != 0;
}

static int create_empty_file(const char *path, mode_t mode)
{
	int fd;

	if ((fd = p_creat(path, mode)) < 0) {
		git_error_set(GIT_ERROR_OS, "error while creating '%s'", path);
		return -1;
	}

	if (p_close(fd) < 0) {
		git_error_set(GIT_ERROR_OS, "error while closing '%s'", path);
		return -1;
	}

	return 0;
}

static int repo_local_config(
	git_config **out,
	git_str *config_dir,
	git_repository *repo,
	const char *repo_dir)
{
	int error = 0;
	git_config *parent;
	const char *cfg_path;

	if (git_str_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
		return -1;
	cfg_path = git_str_cstr(config_dir);

	/* make LOCAL config if missing */
	if (!git_fs_path_isfile(cfg_path) &&
		(error = create_empty_file(cfg_path, GIT_CONFIG_FILE_MODE)) < 0)
		return error;

	/* if no repo, just open that file directly */
	if (!repo)
		return git_config_open_ondisk(out, cfg_path);

	/* otherwise, open parent config and get that level */
	if ((error = git_repository_config__weakptr(&parent, repo)) < 0)
		return error;

	if (git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL) < 0) {
		git_error_clear();

		if (!(error = git_config_add_file_ondisk(
				parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, repo, false)))
			error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
	}

	git_config_free(parent);

	return error;
}

static int repo_init_fs_configs(
	git_config *cfg,
	const char *cfg_path,
	const char *repo_dir,
	const char *work_dir,
	bool update_ignorecase,
	bool use_env)
{
	int error = 0;

	if (!work_dir)
		work_dir = repo_dir;

	if ((error = git_config_set_bool(
			cfg, "core.filemode", is_chmod_supported(cfg_path))) < 0)
		return error;

	if (!are_symlinks_supported(work_dir, use_env)) {
		if ((error = git_config_set_bool(cfg, "core.symlinks", false)) < 0)
			return error;
	} else if (git_config_delete_entry(cfg, "core.symlinks") < 0)
		git_error_clear();

	if (update_ignorecase) {
		if (is_filesystem_case_insensitive(repo_dir)) {
			if ((error = git_config_set_bool(cfg, "core.ignorecase", true)) < 0)
				return error;
		} else if (git_config_delete_entry(cfg, "core.ignorecase") < 0)
			git_error_clear();
	}

#ifdef GIT_USE_ICONV
	if ((error = git_config_set_bool(
			cfg, "core.precomposeunicode",
			git_fs_path_does_decompose_unicode(work_dir))) < 0)
		return error;
	/* on non-iconv platforms, don't even set core.precomposeunicode */
#endif

	return 0;
}

static int repo_init_config(
	const char *repo_dir,
	const char *work_dir,
	uint32_t flags,
	uint32_t mode,
	git_oid_t oid_type)
{
	int error = 0;
	git_str cfg_path = GIT_STR_INIT, worktree_path = GIT_STR_INIT;
	git_config *config = NULL;
	bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0);
	bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0);
	bool use_env = ((flags & GIT_REPOSITORY_OPEN_FROM_ENV) != 0);
	int version = GIT_REPO_VERSION_DEFAULT;

	if ((error = repo_local_config(&config, &cfg_path, NULL, repo_dir)) < 0)
		goto cleanup;

	if (is_reinit &&
	    (error = check_repositoryformatversion(&version, config)) < 0)
		goto cleanup;

	if ((error = check_extensions(config, version)) < 0)
		goto cleanup;

#define SET_REPO_CONFIG(TYPE, NAME, VAL) do { \
	if ((error = git_config_set_##TYPE(config, NAME, VAL)) < 0) \
		goto cleanup; } while (0)

	SET_REPO_CONFIG(bool, "core.bare", is_bare);
	SET_REPO_CONFIG(int32, "core.repositoryformatversion", version);

	if ((error = repo_init_fs_configs(
			config, cfg_path.ptr, repo_dir, work_dir,
			!is_reinit, use_env)) < 0)
		goto cleanup;

	if (!is_bare) {
		SET_REPO_CONFIG(bool, "core.logallrefupdates", true);

		if (!(flags & GIT_REPOSITORY_INIT__NATURAL_WD)) {
			if ((error = git_str_sets(&worktree_path, work_dir)) < 0)
				goto cleanup;

			if ((flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK))
				if ((error = git_fs_path_make_relative(&worktree_path, repo_dir)) < 0)
					goto cleanup;

			SET_REPO_CONFIG(string, "core.worktree", worktree_path.ptr);
		} else if (is_reinit) {
			if (git_config_delete_entry(config, "core.worktree") < 0)
				git_error_clear();
		}
	}

	if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
		SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
	}
	else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
		SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
	}

	if (oid_type != GIT_OID_DEFAULT) {
		SET_REPO_CONFIG(int32, "core.repositoryformatversion", 1);
		SET_REPO_CONFIG(string, "extensions.objectformat", git_oid_type_name(oid_type));
	}

cleanup:
	git_str_dispose(&cfg_path);
	git_str_dispose(&worktree_path);
	git_config_free(config);

	return error;
}

static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
{
	git_repository *smrepo = NULL;
	GIT_UNUSED(n); GIT_UNUSED(p);

	if (git_submodule_open(&smrepo, sm) < 0 ||
		git_repository_reinit_filesystem(smrepo, true) < 0)
		git_error_clear();
	git_repository_free(smrepo);

	return 0;
}

int git_repository_reinit_filesystem(git_repository *repo, int recurse)
{
	int error = 0;
	git_str path = GIT_STR_INIT;
	git_config *config = NULL;
	const char *repo_dir = git_repository_path(repo);

	if (!(error = repo_local_config(&config, &path, repo, repo_dir)))
		error = repo_init_fs_configs(config, path.ptr, repo_dir,
			git_repository_workdir(repo), true, repo->use_env);

	git_config_free(config);
	git_str_dispose(&path);

	git_repository__configmap_lookup_cache_clear(repo);

	if (!repo->is_bare && recurse)
		(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);

	return error;
}

static int repo_write_template(
	const char *git_dir,
	bool allow_overwrite,
	const char *file,
	mode_t mode,
	bool hidden,
	const char *content)
{
	git_str path = GIT_STR_INIT;
	int fd, error = 0, flags;

	if (git_str_joinpath(&path, git_dir, file) < 0)
		return -1;

	if (allow_overwrite)
		flags = O_WRONLY | O_CREAT | O_TRUNC;
	else
		flags = O_WRONLY | O_CREAT | O_EXCL;

	fd = p_open(git_str_cstr(&path), flags, mode);

	if (fd >= 0) {
		error = p_write(fd, content, strlen(content));

		p_close(fd);
	}
	else if (errno != EEXIST)
		error = fd;

#ifdef GIT_WIN32
	if (!error && hidden) {
		if (git_win32__set_hidden(path.ptr, true) < 0)
			error = -1;
	}
#else
	GIT_UNUSED(hidden);
#endif

	git_str_dispose(&path);

	if (error)
		git_error_set(GIT_ERROR_OS,
			"failed to initialize repository with template '%s'", file);

	return error;
}

static int repo_write_gitlink(
	const char *in_dir, const char *to_repo, bool use_relative_path)
{
	int error;
	git_str buf = GIT_STR_INIT;
	git_str path_to_repo = GIT_STR_INIT;
	struct stat st;

	git_fs_path_dirname_r(&buf, to_repo);
	git_fs_path_to_dir(&buf);
	if (git_str_oom(&buf))
		return -1;

	/* don't write gitlink to natural workdir */
	if (git__suffixcmp(to_repo, "/" DOT_GIT "/") == 0 &&
		strcmp(in_dir, buf.ptr) == 0)
	{
		error = GIT_PASSTHROUGH;
		goto cleanup;
	}

	if ((error = git_str_joinpath(&buf, in_dir, DOT_GIT)) < 0)
		goto cleanup;

	if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) {
		git_error_set(GIT_ERROR_REPOSITORY,
			"cannot overwrite gitlink file into path '%s'", in_dir);
		error = GIT_EEXISTS;
		goto cleanup;
	}

	git_str_clear(&buf);

	error = git_str_sets(&path_to_repo, to_repo);

	if (!error && use_relative_path)
		error = git_fs_path_make_relative(&path_to_repo, in_dir);

	if (!error)
		error = git_str_join(&buf, ' ', GIT_FILE_CONTENT_PREFIX, path_to_repo.ptr);

	if (!error)
		error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);

cleanup:
	git_str_dispose(&buf);
	git_str_dispose(&path_to_repo);
	return error;
}

static mode_t pick_dir_mode(git_repository_init_options *opts)
{
	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_UMASK)
		return 0777;
	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_GROUP)
		return (0775 | S_ISGID);
	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_ALL)
		return (0777 | S_ISGID);
	return opts->mode;
}

#include "repo_template.h"

static int repo_init_structure(
	const char *repo_dir,
	const char *work_dir,
	git_repository_init_options *opts)
{
	int error = 0;
	repo_template_item *tpl;
	bool external_tpl =
		((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
	mode_t dmode = pick_dir_mode(opts);
	bool chmod = opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK;

	/* Hide the ".git" directory */
#ifdef GIT_WIN32
	if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
		if (git_win32__set_hidden(repo_dir, true) < 0) {
			git_error_set(GIT_ERROR_OS,
				"failed to mark Git repository folder as hidden");
			return -1;
		}
	}
#endif

	/* Create the .git gitlink if appropriate */
	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
		(opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0)
	{
		if (repo_write_gitlink(work_dir, repo_dir, opts->flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK) < 0)
			return -1;
	}

	/* Copy external template if requested */
	if (external_tpl) {
		git_config *cfg = NULL;
		const char *tdir = NULL;
		bool default_template = false;
		git_str template_buf = GIT_STR_INIT;

		if (opts->template_path)
			tdir = opts->template_path;
		else if ((error = git_config_open_default(&cfg)) >= 0) {
			if (!git_config__get_path(&template_buf, cfg, "init.templatedir"))
				tdir = template_buf.ptr;
			git_error_clear();
		}

		if (!tdir) {
			if (!(error = git_sysdir_find_template_dir(&template_buf)))
				tdir = template_buf.ptr;
			default_template = true;
		}

		/*
		 * If tdir was the empty string, treat it like tdir was a path to an
		 * empty directory (so, don't do any copying). This is the behavior
		 * that git(1) exhibits, although it doesn't seem to be officially
		 * documented.
		 */
		if (tdir && git__strcmp(tdir, "") != 0) {
			uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS |
				GIT_CPDIR_SIMPLE_TO_MODE |
				GIT_CPDIR_COPY_DOTFILES;
			if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
					cpflags |= GIT_CPDIR_CHMOD_DIRS;
			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
		}

		git_str_dispose(&template_buf);
		git_config_free(cfg);

		/* If tdir does not exist, then do not error out. This matches the
		 * behaviour of git(1), which just prints a warning and continues.
		 * TODO: issue warning when warning API is available.
		 * `git` prints to stderr: 'warning: templates not found in /path/to/tdir'
		 */
		if (error < 0) {
			if (!default_template && error != GIT_ENOTFOUND)
				return error;

			/* if template was default, ignore error and use internal */
			git_error_clear();
			external_tpl = false;
			error = 0;
		}
	}

	/* Copy internal template
	 * - always ensure existence of dirs
	 * - only create files if no external template was specified
	 */
	for (tpl = repo_template; !error && tpl->path; ++tpl) {
		if (!tpl->content) {
			uint32_t mkdir_flags = GIT_MKDIR_PATH;
			if (chmod)
				mkdir_flags |= GIT_MKDIR_CHMOD;

			error = git_futils_mkdir_relative(
				tpl->path, repo_dir, dmode, mkdir_flags, NULL);
		}
		else if (!external_tpl) {
			const char *content = tpl->content;

			if (opts->description && strcmp(tpl->path, GIT_DESC_FILE) == 0)
				content = opts->description;

			error = repo_write_template(
				repo_dir, false, tpl->path, tpl->mode, false, content);
		}
	}

	return error;
}

static int mkdir_parent(git_str *buf, uint32_t mode, bool skip2)
{
	/* When making parent directories during repository initialization
	 * don't try to set gid or grant world write access
	 */
	return git_futils_mkdir(
		buf->ptr, mode & ~(S_ISGID | 0002),
		GIT_MKDIR_PATH | GIT_MKDIR_VERIFY_DIR |
		(skip2 ? GIT_MKDIR_SKIP_LAST2 : GIT_MKDIR_SKIP_LAST));
}

static int repo_init_directories(
	git_str *repo_path,
	git_str *wd_path,
	const char *given_repo,
	git_repository_init_options *opts)
{
	int error = 0;
	bool is_bare, add_dotgit, has_dotgit, natural_wd;
	mode_t dirmode;

	/* There are three possible rules for what we are allowed to create:
	 * - MKPATH means anything we need
	 * - MKDIR means just the .git directory and its parent and the workdir
	 * - Neither means only the .git directory can be created
	 *
	 * There are 5 "segments" of path that we might need to deal with:
	 * 1. The .git directory
	 * 2. The parent of the .git directory
	 * 3. Everything above the parent of the .git directory
	 * 4. The working directory (often the same as #2)
	 * 5. Everything above the working directory (often the same as #3)
	 *
	 * For all directories created, we start with the init_mode value for
	 * permissions and then strip off bits in some cases:
	 *
	 * For MKPATH, we create #3 (and #5) paths without S_ISGID or S_IWOTH
	 * For MKPATH and MKDIR, we create #2 (and #4) without S_ISGID
	 * For all rules, we create #1 using the untouched init_mode
	 */

	/* set up repo path */

	is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);

	add_dotgit =
		(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
		!is_bare &&
		git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
		git__suffixcmp(given_repo, "/" GIT_DIR) != 0;

	if (git_str_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
		return -1;

	has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
	if (has_dotgit)
		opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;

	/* set up workdir path */

	if (!is_bare) {
		if (opts->workdir_path) {
			if (git_fs_path_join_unrooted(
					wd_path, opts->workdir_path, repo_path->ptr, NULL) < 0)
				return -1;
		} else if (has_dotgit) {
			if (git_fs_path_dirname_r(wd_path, repo_path->ptr) < 0)
				return -1;
		} else {
			git_error_set(GIT_ERROR_REPOSITORY, "cannot pick working directory"
				" for non-bare repository that isn't a '.git' directory");
			return -1;
		}

		if (git_fs_path_to_dir(wd_path) < 0)
			return -1;
	} else {
		git_str_clear(wd_path);
	}

	natural_wd =
		has_dotgit &&
		wd_path->size > 0 &&
		wd_path->size + strlen(GIT_DIR) == repo_path->size &&
		memcmp(repo_path->ptr, wd_path->ptr, wd_path->size) == 0;
	if (natural_wd)
		opts->flags |= GIT_REPOSITORY_INIT__NATURAL_WD;

	/* create directories as needed / requested */

	dirmode = pick_dir_mode(opts);

	if ((opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0) {
		/* create path #5 */
		if (wd_path->size > 0 &&
			(error = mkdir_parent(wd_path, dirmode, false)) < 0)
			return error;

		/* create path #3 (if not the same as #5) */
		if (!natural_wd &&
			(error = mkdir_parent(repo_path, dirmode, has_dotgit)) < 0)
			return error;
	}

	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0)
	{
		/* create path #4 */
		if (wd_path->size > 0 &&
			(error = git_futils_mkdir(
				wd_path->ptr, dirmode & ~S_ISGID,
				GIT_MKDIR_VERIFY_DIR)) < 0)
			return error;

		/* create path #2 (if not the same as #4) */
		if (!natural_wd &&
			(error = git_futils_mkdir(
				repo_path->ptr, dirmode & ~S_ISGID,
				GIT_MKDIR_VERIFY_DIR | GIT_MKDIR_SKIP_LAST)) < 0)
			return error;
	}

	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0 ||
		has_dotgit)
	{
		/* create path #1 */
		error = git_futils_mkdir(repo_path->ptr, dirmode,
			GIT_MKDIR_VERIFY_DIR | ((dirmode & S_ISGID) ? GIT_MKDIR_CHMOD : 0));
	}

	/* prettify both directories now that they are created */

	if (!error) {
		error = git_fs_path_prettify_dir(repo_path, repo_path->ptr, NULL);

		if (!error && wd_path->size > 0)
			error = git_fs_path_prettify_dir(wd_path, wd_path->ptr, NULL);
	}

	return error;
}

static int repo_init_head(const char *repo_dir, const char *given)
{
	git_config *cfg = NULL;
	git_str head_path = GIT_STR_INIT, cfg_branch = GIT_STR_INIT;
	const char *initial_head = NULL;
	int error;

	if ((error = git_str_joinpath(&head_path, repo_dir, GIT_HEAD_FILE)) < 0)
		goto out;

	/*
	 * A template may have set a HEAD; use that unless it's been
	 * overridden by the caller's given initial head setting.
	 */
	if (git_fs_path_exists(head_path.ptr) && !given)
		goto out;

	if (given) {
		initial_head = given;
	} else if ((error = git_config_open_default(&cfg)) >= 0 &&
	           (error = git_config__get_string_buf(&cfg_branch, cfg, "init.defaultbranch")) >= 0 &&
	           *cfg_branch.ptr) {
		initial_head = cfg_branch.ptr;
	}

	if (!initial_head)
		initial_head = GIT_BRANCH_DEFAULT;

	error = git_repository_create_head(repo_dir, initial_head);

out:
	git_config_free(cfg);
	git_str_dispose(&head_path);
	git_str_dispose(&cfg_branch);

	return error;
}

static int repo_init_create_origin(git_repository *repo, const char *url)
{
	int error;
	git_remote *remote;

	if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
		git_remote_free(remote);
	}

	return error;
}

int git_repository_init(
	git_repository **repo_out, const char *path, unsigned is_bare)
{
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;

	opts.flags = GIT_REPOSITORY_INIT_MKPATH; /* don't love this default */
	if (is_bare)
		opts.flags |= GIT_REPOSITORY_INIT_BARE;

	return git_repository_init_ext(repo_out, path, &opts);
}

int git_repository_init_ext(
	git_repository **out,
	const char *given_repo,
	git_repository_init_options *opts)
{
	git_str repo_path = GIT_STR_INIT, wd_path = GIT_STR_INIT,
		common_path = GIT_STR_INIT;
	const char *wd;
	bool is_valid;
	git_oid_t oid_type = GIT_OID_DEFAULT;
	int error;

	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(given_repo);
	GIT_ASSERT_ARG(opts);

	GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");

#ifdef GIT_EXPERIMENTAL_SHA256
	if (opts->oid_type)
		oid_type = opts->oid_type;
#endif

	if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0)
		goto out;

	wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_str_cstr(&wd_path);

	if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path, opts->flags)) < 0)
		goto out;

	if (is_valid) {
		if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
			git_error_set(GIT_ERROR_REPOSITORY,
				"attempt to reinitialize '%s'", given_repo);
			error = GIT_EEXISTS;
			goto out;
		}

		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;

		if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode, oid_type)) < 0)
			goto out;

		/* TODO: reinitialize the templates */
	} else {
		if ((error = repo_init_structure(repo_path.ptr, wd, opts)) < 0 ||
		    (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode, oid_type)) < 0 ||
		    (error = repo_init_head(repo_path.ptr, opts->initial_head)) < 0)
			goto out;
	}

	if ((error = git_repository_open(out, repo_path.ptr)) < 0)
		goto out;

	if (opts->origin_url &&
	    (error = repo_init_create_origin(*out, opts->origin_url)) < 0)
		goto out;

out:
	git_str_dispose(&common_path);
	git_str_dispose(&repo_path);
	git_str_dispose(&wd_path);

	return error;
}

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_REFERENCE_SYMBOLIC) {
		git_reference_free(ref);
		return 0;
	}

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

	git_reference_free(ref);
	return exists;
}

int git_repository_head_detached_for_worktree(git_repository *repo, const char *name)
{
	git_reference *ref = NULL;
	int error;

	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(name);

	if ((error = git_repository_head_for_worktree(&ref, repo, name)) < 0)
		goto out;

	error = (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC);
out:
	git_reference_free(ref);

	return error;
}

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

	GIT_ASSERT_ARG(head_out);

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

	if (git_reference_type(head) == GIT_REFERENCE_DIRECT) {
		*head_out = head;
		return 0;
	}

	error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
	git_reference_free(head);

	return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
}

int git_repository_head_for_worktree(git_reference **out, git_repository *repo, const char *name)
{
	git_repository *worktree_repo = NULL;
	git_worktree *worktree = NULL;
	git_reference *head = NULL;
	int error;

	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(name);

	*out = NULL;

	if ((error = git_worktree_lookup(&worktree, repo, name)) < 0 ||
	    (error = git_repository_open_from_worktree(&worktree_repo, worktree)) < 0 ||
	    (error = git_reference_lookup(&head, worktree_repo, GIT_HEAD_FILE)) < 0)
		goto out;

	if (git_reference_type(head) != GIT_REFERENCE_DIRECT) {
		if ((error = git_reference_lookup_resolved(out, worktree_repo, git_reference_symbolic_target(head), -1)) < 0)
			goto out;
	} else {
		*out = head;
		head = NULL;
	}

out:
	git_reference_free(head);
	git_worktree_free(worktree);
	git_repository_free(worktree_repo);
	return error;
}

int git_repository_foreach_worktree(git_repository *repo,
				    git_repository_foreach_worktree_cb cb,
				    void *payload)
{
	git_strarray worktrees = {0};
	git_repository *worktree_repo = NULL;
	git_worktree *worktree = NULL;
	int error;
	size_t i;

	/* apply operation to repository supplied when commondir is empty, implying there's
	 * no linked worktrees to iterate, which can occur when using custom odb/refdb
	 */
	if (!repo->commondir)
		return cb(repo, payload);

	if ((error = git_repository_open(&worktree_repo, repo->commondir)) < 0 ||
	    (error = cb(worktree_repo, payload) != 0))
		goto out;

	git_repository_free(worktree_repo);
	worktree_repo = NULL;

	if ((error = git_worktree_list(&worktrees, repo)) < 0)
		goto out;

	for (i = 0; i < worktrees.count; i++) {
		git_repository_free(worktree_repo);
		worktree_repo = NULL;
		git_worktree_free(worktree);
		worktree = NULL;

		if ((error = git_worktree_lookup(&worktree, repo, worktrees.strings[i]) < 0) ||
		    (error = git_repository_open_from_worktree(&worktree_repo, worktree)) < 0) {
			if (error != GIT_ENOTFOUND)
				goto out;
			error = 0;
			continue;
		}

		if ((error = cb(worktree_repo, payload)) != 0)
			goto out;
	}

out:
	git_strarray_dispose(&worktrees);
	git_repository_free(worktree_repo);
	git_worktree_free(worktree);
	return error;
}

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

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

	if (error == GIT_EUNBORNBRANCH) {
		git_error_clear();
		return 1;
	}

	if (error < 0)
		return -1;

	return 0;
}

static int repo_contains_no_reference(git_repository *repo)
{
	git_reference_iterator *iter;
	const char *refname;
	int error;

	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
		return error;

	error = git_reference_next_name(&refname, iter);
	git_reference_iterator_free(iter);

	if (error == GIT_ITEROVER)
		return 1;

	return error;
}

int git_repository_initialbranch(git_str *out, git_repository *repo)
{
	git_config *config;
	git_config_entry *entry = NULL;
	const char *branch;
	int valid, error;

	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
		return error;

	if ((error = git_config_get_entry(&entry, config, "init.defaultbranch")) == 0 &&
		*entry->value) {
		branch = entry->value;
	}
	else if (!error || error == GIT_ENOTFOUND) {
		branch = GIT_BRANCH_DEFAULT;
	}
	else {
		goto done;
	}

	if ((error = git_str_puts(out, GIT_REFS_HEADS_DIR)) < 0 ||
	    (error = git_str_puts(out, branch)) < 0 ||
	    (error = git_reference_name_is_valid(&valid, out->ptr)) < 0)
	    goto done;

	if (!valid) {
		git_error_set(GIT_ERROR_INVALID, "the value of init.defaultBranch is not a valid branch name");
		error = -1;
	}

done:
	git_config_entry_free(entry);
	return error;
}

int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL;
	git_str initialbranch = GIT_STR_INIT;
	int result = 0;

	if ((result = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0 ||
	    (result = git_repository_initialbranch(&initialbranch, repo)) < 0)
		goto done;

	result = (git_reference_type(head) == GIT_REFERENCE_SYMBOLIC &&
	          strcmp(git_reference_symbolic_target(head), initialbranch.ptr) == 0 &&
	          repo_contains_no_reference(repo));

done:
	git_reference_free(head);
	git_str_dispose(&initialbranch);

	return result;
}

static const char *resolved_parent_path(const git_repository *repo, git_repository_item_t item, git_repository_item_t fallback)
{
	const char *parent;

	switch (item) {
		case GIT_REPOSITORY_ITEM_GITDIR:
			parent = git_repository_path(repo);
			break;
		case GIT_REPOSITORY_ITEM_WORKDIR:
			parent = git_repository_workdir(repo);
			break;
		case GIT_REPOSITORY_ITEM_COMMONDIR:
			parent = git_repository_commondir(repo);
			break;
		default:
			git_error_set(GIT_ERROR_INVALID, "invalid item directory");
			return NULL;
	}
	if (!parent && fallback != GIT_REPOSITORY_ITEM__LAST)
		return resolved_parent_path(repo, fallback, GIT_REPOSITORY_ITEM__LAST);

	return parent;
}

int git_repository_item_path(
	git_buf *out,
	const git_repository *repo,
	git_repository_item_t item)
{
	GIT_BUF_WRAP_PRIVATE(out, git_repository__item_path, repo, item);
}

int git_repository__item_path(
	git_str *out,
	const git_repository *repo,
	git_repository_item_t item)
{
	const char *parent = resolved_parent_path(repo, items[item].parent, items[item].fallback);
	if (parent == NULL) {
		git_error_set(GIT_ERROR_INVALID, "path cannot exist in repository");
		return GIT_ENOTFOUND;
	}

	if (git_str_sets(out, parent) < 0)
		return -1;

	if (items[item].name) {
		if (git_str_joinpath(out, parent, items[item].name) < 0)
			return -1;
	}

	if (items[item].directory) {
		if (git_fs_path_to_dir(out) < 0)
			return -1;
	}

	return 0;
}

const char *git_repository_path(const git_repository *repo)
{
	GIT_ASSERT_ARG_WITH_RETVAL(repo, NULL);
	return repo->gitdir;
}

const char *git_repository_workdir(const git_repository *repo)
{
	GIT_ASSERT_ARG_WITH_RETVAL(repo, NULL);

	if (repo->is_bare)
		return NULL;

	return repo->workdir;
}

int git_repository_workdir_path(
	git_str *out, git_repository *repo, const char *path)
{
	int error;

	if (!repo->workdir) {
		git_error_set(GIT_ERROR_REPOSITORY, "repository has no working directory");
		return GIT_EBAREREPO;
	}

	if (!(error = git_str_joinpath(out, repo->workdir, path)))
		error = git_path_validate_str_length(repo, out);

	return error;
}

const char *git_repository_commondir(const git_repository *repo)
{
	GIT_ASSERT_ARG_WITH_RETVAL(repo, NULL);
	return repo->commondir;
}

int git_repository_set_workdir(
	git_repository *repo, const char *workdir, int update_gitlink)
{
	int error = 0;
	git_str path = GIT_STR_INIT;

	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(workdir);

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

	if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
		return 0;

	if (update_gitlink) {
		git_config *config;

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

		error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);

		/* passthrough error means gitlink is unnecessary */
		if (error == GIT_PASSTHROUGH)
			error = git_config_delete_entry(config, "core.worktree");
		else if (!error)
			error = git_config_set_string(config, "core.worktree", path.ptr);

		if (!error)
			error = git_config_set_bool(config, "core.bare", false);
	}

	if (!error) {
		char *old_workdir = repo->workdir;

		repo->workdir = git_str_detach(&path);
		repo->is_bare = 0;

		git__free(old_workdir);
	}

	return error;
}

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

int git_repository_is_worktree(const git_repository *repo)
{
	GIT_ASSERT_ARG(repo);
	return repo->is_worktree;
}

int git_repository_set_bare(git_repository *repo)
{
	int error;
	git_config *config;

	GIT_ASSERT_ARG(repo);

	if (repo->is_bare)
		return 0;

	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
		return error;

	if ((error = git_config_set_bool(config, "core.bare", true)) < 0)
		return error;

	if ((error = git_config__update_entry(config, "core.worktree", NULL, true, true)) < 0)
		return error;

	git__free(repo->workdir);
	repo->workdir = NULL;
	repo->is_bare = 1;

	return 0;
}

int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
	git_reference *head;
	git_object *obj;
	int error;

	if ((error = git_repository_head(&head, repo)) < 0)
		return error;

	if ((error = git_reference_peel(&obj, head, GIT_OBJECT_TREE)) < 0)
		goto cleanup;

	*tree = (git_tree *)obj;

cleanup:
	git_reference_free(head);
	return error;
}

int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head)
{
	git_filebuf file = GIT_FILEBUF_INIT;
	git_str file_path = GIT_STR_INIT;
	char orig_head_str[GIT_OID_MAX_HEXSIZE];
	int error = 0;

	git_oid_fmt(orig_head_str, orig_head);

	if ((error = git_str_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 &&
		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) == 0 &&
		(error = git_filebuf_printf(&file, "%.*s\n", (int)git_oid_hexsize(repo->oid_type), orig_head_str)) == 0)
		error = git_filebuf_commit(&file);

	if (error < 0)
		git_filebuf_cleanup(&file);

	git_str_dispose(&file_path);

	return error;
}

static int git_repository__message(git_str *out, git_repository *repo)
{
	git_str path = GIT_STR_INIT;
	struct stat st;
	int error;

	if (git_str_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
		return -1;

	if ((error = p_stat(git_str_cstr(&path), &st)) < 0) {
		if (errno == ENOENT)
			error = GIT_ENOTFOUND;
		git_error_set(GIT_ERROR_OS, "could not access message file");
	} else {
		error = git_futils_readbuffer(out, git_str_cstr(&path));
	}

	git_str_dispose(&path);

	return error;
}

int git_repository_message(git_buf *out, git_repository *repo)
{
	GIT_BUF_WRAP_PRIVATE(out, git_repository__message, repo);
}

int git_repository_message_remove(git_repository *repo)
{
	git_str path = GIT_STR_INIT;
	int error;

	if (git_str_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
		return -1;

	error = p_unlink(git_str_cstr(&path));
	git_str_dispose(&path);

	return error;
}

int git_repository_hashfile(
	git_oid *out,
	git_repository *repo,
	const char *path,
	git_object_t type,
	const char *as_path)
{
	int error;
	git_filter_list *fl = NULL;
	git_file fd = -1;
	uint64_t len;
	git_str full_path = GIT_STR_INIT;
	const char *workdir = git_repository_workdir(repo);

	 /* as_path can be NULL */
	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(path);
	GIT_ASSERT_ARG(repo);

	if ((error = git_fs_path_join_unrooted(&full_path, path, workdir, NULL)) < 0 ||
	    (error = git_path_validate_str_length(repo, &full_path)) < 0)
		return error;

	/*
	 * NULL as_path means that we should derive it from the
	 * given path.
	 */
	if (!as_path) {
		if (workdir && !git__prefixcmp(full_path.ptr, workdir))
			as_path = full_path.ptr + strlen(workdir);
		else
			as_path = "";
	}

	/* passing empty string for "as_path" indicated --no-filters */
	if (strlen(as_path) > 0) {
		error = git_filter_list_load(
			&fl, repo, NULL, as_path,
			GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);

		if (error < 0)
			return error;
	}

	/* at this point, error is a count of the number of loaded filters */

	fd = git_futils_open_ro(full_path.ptr);
	if (fd < 0) {
		error = fd;
		goto cleanup;
	}

	if ((error = git_futils_filesize(&len, fd)) < 0)
		goto cleanup;

	if (!git__is_sizet(len)) {
		git_error_set(GIT_ERROR_OS, "file size overflow for 32-bit systems");
		error = -1;
		goto cleanup;
	}

	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, repo->oid_type, fl);

cleanup:
	if (fd >= 0)
		p_close(fd);
	git_filter_list_free(fl);
	git_str_dispose(&full_path);

	return error;
}

static int checkout_message(git_str *out, git_reference *old, const char *new)
{
	const char *idstr;

	git_str_puts(out, "checkout: moving from ");

	if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC) {
		git_str_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
	} else {
		if ((idstr = git_oid_tostr_s(git_reference_target(old))) == NULL)
			return -1;

		git_str_puts(out, idstr);
	}

	git_str_puts(out, " to ");

	if (git_reference__is_branch(new) ||
		git_reference__is_tag(new) ||
		git_reference__is_remote(new))
		git_str_puts(out, git_reference__shorthand(new));
	else
		git_str_puts(out, new);

	if (git_str_oom(out))
		return -1;

	return 0;
}

static int detach(git_repository *repo, const git_oid *id, const char *new)
{
	int error;
	git_str log_message = GIT_STR_INIT;
	git_object *object = NULL, *peeled = NULL;
	git_reference *new_head = NULL, *current = NULL;

	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(id);

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

	if ((error = git_object_lookup(&object, repo, id, GIT_OBJECT_ANY)) < 0)
		goto cleanup;

	if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0)
		goto cleanup;

	if (new == NULL &&
	    (new = git_oid_tostr_s(git_object_id(peeled))) == NULL) {
		error = -1;
		goto cleanup;
	}

	if ((error = checkout_message(&log_message, current, new)) < 0)
		goto cleanup;

	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, git_str_cstr(&log_message));

cleanup:
	git_str_dispose(&log_message);
	git_object_free(object);
	git_object_free(peeled);
	git_reference_free(current);
	git_reference_free(new_head);
	return error;
}

int git_repository_set_head(
	git_repository *repo,
	const char *refname)
{
	git_reference *ref = NULL, *current = NULL, *new_head = NULL;
	git_str log_message = GIT_STR_INIT;
	int error;

	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(refname);

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

	if ((error = checkout_message(&log_message, current, refname)) < 0)
		goto cleanup;

	error = git_reference_lookup(&ref, repo, refname);
	if (error < 0 && error != GIT_ENOTFOUND)
		goto cleanup;

	if (ref && current->type == GIT_REFERENCE_SYMBOLIC && git__strcmp(current->target.symbolic, ref->name) &&
	    git_reference_is_branch(ref) && git_branch_is_checked_out(ref)) {
		git_error_set(GIT_ERROR_REPOSITORY, "cannot set HEAD to reference '%s' as it is the current HEAD "
			"of a linked repository.", git_reference_name(ref));
		error = -1;
		goto cleanup;
	}

	if (!error) {
		if (git_reference_is_branch(ref)) {
			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
					git_reference_name(ref), true, git_str_cstr(&log_message));
		} else {
			error = detach(repo, git_reference_target(ref),
				git_reference_is_tag(ref) || git_reference_is_remote(ref) ? refname : NULL);
		}
	} else if (git_reference__is_branch(refname)) {
		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
				true, git_str_cstr(&log_message));
	}

cleanup:
	git_str_dispose(&log_message);
	git_reference_free(current);
	git_reference_free(ref);
	git_reference_free(new_head);
	return error;
}

int git_repository_set_head_detached(
	git_repository *repo,
	const git_oid *committish)
{
	return detach(repo, committish, NULL);
}

int git_repository_set_head_detached_from_annotated(
	git_repository *repo,
	const git_annotated_commit *committish)
{
	GIT_ASSERT_ARG(repo);
	GIT_ASSERT_ARG(committish);

	return detach(repo, git_annotated_commit_id(committish), committish->description);
}

int git_repository_detach_head(git_repository *repo)
{
	git_reference *old_head = NULL,	*new_head = NULL, *current = NULL;
	git_object *object = NULL;
	git_str log_message = GIT_STR_INIT;
	const char *idstr;
	int error;

	GIT_ASSERT_ARG(repo);

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

	if ((error = git_repository_head(&old_head, repo)) < 0)
		goto cleanup;

	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0)
		goto cleanup;

	if ((idstr = git_oid_tostr_s(git_object_id(object))) == NULL) {
		error = -1;
		goto cleanup;
	}

	if ((error = checkout_message(&log_message, current, idstr)) < 0)
		goto cleanup;

	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
			1, git_str_cstr(&log_message));

cleanup:
	git_str_dispose(&log_message);
	git_object_free(object);
	git_reference_free(old_head);
	git_reference_free(new_head);
	git_reference_free(current);
	return error;
}

/**
 * Loosely ported from git.git
 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
 */
int git_repository_state(git_repository *repo)
{
	git_str repo_path = GIT_STR_INIT;
	int state = GIT_REPOSITORY_STATE_NONE;

	GIT_ASSERT_ARG(repo);

	if (git_str_puts(&repo_path, repo->gitdir) < 0)
		return -1;

	if (git_fs_path_contains_file(&repo_path, GIT_REBASE_MERGE_INTERACTIVE_FILE))
		state = GIT_REPOSITORY_STATE_REBASE_INTERACTIVE;
	else if (git_fs_path_contains_dir(&repo_path, GIT_REBASE_MERGE_DIR))
		state = GIT_REPOSITORY_STATE_REBASE_MERGE;
	else if (git_fs_path_contains_file(&repo_path, GIT_REBASE_APPLY_REBASING_FILE))
		state = GIT_REPOSITORY_STATE_REBASE;
	else if (git_fs_path_contains_file(&repo_path, GIT_REBASE_APPLY_APPLYING_FILE))
		state = GIT_REPOSITORY_STATE_APPLY_MAILBOX;
	else if (git_fs_path_contains_dir(&repo_path, GIT_REBASE_APPLY_DIR))
		state = GIT_REPOSITORY_STATE_APPLY_MAILBOX_OR_REBASE;
	else if (git_fs_path_contains_file(&repo_path, GIT_MERGE_HEAD_FILE))
		state = GIT_REPOSITORY_STATE_MERGE;
	else if (git_fs_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE)) {
		state = GIT_REPOSITORY_STATE_REVERT;
		if (git_fs_path_contains_file(&repo_path, GIT_SEQUENCER_TODO_FILE)) {
			state = GIT_REPOSITORY_STATE_REVERT_SEQUENCE;
		}
	} else if (git_fs_path_contains_file(&repo_path, GIT_CHERRYPICK_HEAD_FILE)) {
		state = GIT_REPOSITORY_STATE_CHERRYPICK;
		if (git_fs_path_contains_file(&repo_path, GIT_SEQUENCER_TODO_FILE)) {
			state = GIT_REPOSITORY_STATE_CHERRYPICK_SEQUENCE;
		}
	} else if (git_fs_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
		state = GIT_REPOSITORY_STATE_BISECT;

	git_str_dispose(&repo_path);
	return state;
}

int git_repository__cleanup_files(
	git_repository *repo, const char *files[], size_t files_len)
{
	git_str buf = GIT_STR_INIT;
	size_t i;
	int error;

	for (error = 0, i = 0; !error && i < files_len; ++i) {
		const char *path;

		if (git_str_joinpath(&buf, repo->gitdir, files[i]) < 0)
			return -1;

		path = git_str_cstr(&buf);

		if (git_fs_path_isfile(path)) {
			error = p_unlink(path);
		} else if (git_fs_path_isdir(path)) {
			error = git_futils_rmdir_r(path, NULL,
				GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS);
		}

		git_str_clear(&buf);
	}

	git_str_dispose(&buf);
	return error;
}

static const char *state_files[] = {
	GIT_MERGE_HEAD_FILE,
	GIT_MERGE_MODE_FILE,
	GIT_MERGE_MSG_FILE,
	GIT_REVERT_HEAD_FILE,
	GIT_CHERRYPICK_HEAD_FILE,
	GIT_BISECT_LOG_FILE,
	GIT_REBASE_MERGE_DIR,
	GIT_REBASE_APPLY_DIR,
	GIT_SEQUENCER_DIR,
};

int git_repository_state_cleanup(git_repository *repo)
{
	GIT_ASSERT_ARG(repo);

	return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
}

int git_repository__shallow_roots(
	git_oid **out,
	size_t *out_len,
	git_repository *repo)
{
	int error = 0;

	if (!repo->shallow_grafts && (error = load_grafts(repo)) < 0)
		return error;

	if ((error = git_grafts_refresh(repo->shallow_grafts)) < 0)
		return error;

	if ((error = git_grafts_oids(out, out_len, repo->shallow_grafts)) < 0)
		return error;

	return 0;
}

int git_repository__shallow_roots_write(git_repository *repo, git_oidarray *roots)
{
	git_filebuf file = GIT_FILEBUF_INIT;
	git_str path = GIT_STR_INIT;
	char oid_str[GIT_OID_MAX_HEXSIZE + 1];
	size_t i;
	int filebuf_hash, error = 0;

	GIT_ASSERT_ARG(repo);

	filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(repo->oid_type));
	GIT_ASSERT(filebuf_hash);

	if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0)
		goto on_error;

	if ((error = git_filebuf_open(&file, git_str_cstr(&path), filebuf_hash, 0666)) < 0)
		goto on_error;

	for (i = 0; i < roots->count; i++) {
		git_oid_tostr(oid_str, sizeof(oid_str), &roots->ids[i]);
		git_filebuf_write(&file, oid_str, git_oid_hexsize(repo->oid_type));
		git_filebuf_write(&file, "\n", 1);
	}

	git_filebuf_commit(&file);

	if ((error = load_grafts(repo)) < 0) {
		error = -1;
		goto on_error;
	}

	if (!roots->count)
		remove(path.ptr);

on_error:
	git_str_dispose(&path);

	return error;
}

int git_repository_is_shallow(git_repository *repo)
{
	git_str path = GIT_STR_INIT;
	struct stat st;
	int error;

	if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0)
		return error;

	error = git_fs_path_lstat(path.ptr, &st);
	git_str_dispose(&path);

	if (error == GIT_ENOTFOUND) {
		git_error_clear();
		return 0;
	}

	if (error < 0)
		return error;

	return st.st_size == 0 ? 0 : 1;
}

int git_repository_init_options_init(
	git_repository_init_options *opts, unsigned int version)
{
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_repository_init_options,
		GIT_REPOSITORY_INIT_OPTIONS_INIT);
	return 0;
}

#ifndef GIT_DEPRECATE_HARD
int git_repository_init_init_options(
	git_repository_init_options *opts, unsigned int version)
{
	return git_repository_init_options_init(opts, version);
}
#endif

int git_repository_ident(const char **name, const char **email, const git_repository *repo)
{
	*name = repo->ident_name;
	*email = repo->ident_email;

	return 0;
}

int git_repository_set_ident(git_repository *repo, const char *name, const char *email)
{
	char *tmp_name = NULL, *tmp_email = NULL;

	if (name) {
		tmp_name = git__strdup(name);
		GIT_ERROR_CHECK_ALLOC(tmp_name);
	}

	if (email) {
		tmp_email = git__strdup(email);
		GIT_ERROR_CHECK_ALLOC(tmp_email);
	}

	tmp_name = git_atomic_swap(repo->ident_name, tmp_name);
	tmp_email = git_atomic_swap(repo->ident_email, tmp_email);

	git__free(tmp_name);
	git__free(tmp_email);

	return 0;
}

int git_repository_submodule_cache_all(git_repository *repo)
{
	GIT_ASSERT_ARG(repo);
	return git_submodule_cache_init(&repo->submodule_cache, repo);
}

int git_repository_submodule_cache_clear(git_repository *repo)
{
	int error = 0;
	GIT_ASSERT_ARG(repo);

	error = git_submodule_cache_free(repo->submodule_cache);
	repo->submodule_cache = NULL;
	return error;
}

git_oid_t git_repository_oid_type(git_repository *repo)
{
	return repo ? repo->oid_type : 0;
}
