* 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/refdb.h"
#include "git2/sys/repository.h"
#include "common.h"
-#include "repository.h"
#include "commit.h"
#include "tag.h"
#include "blob.h"
-#include "fileops.h"
+#include "futils.h"
#include "sysdir.h"
#include "filebuf.h"
#include "index.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 "strmap.h"
#ifdef GIT_WIN32
# include "win32/w32_util.h"
#endif
+bool git_repository__fsync_gitdir = false;
+
+static const struct {
+ git_repository_item_t parent;
+ 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(git_config *config);
+#define GIT_COMMONDIR_FILE "commondir"
+#define GIT_GITDIR_FILE "gitdir"
+
#define GIT_FILE_CONTENT_PREFIX "gitdir:"
#define GIT_BRANCH_MASTER "master"
git_config_free(config);
}
- git_repository__cvar_cache_clear(repo);
+ git_repository__configmap_lookup_cache_clear(repo);
}
static void set_index(git_repository *repo, git_index *index)
}
}
-void git_repository__cleanup(git_repository *repo)
+int git_repository__cleanup(git_repository *repo)
{
assert(repo);
+ git_repository_submodule_cache_clear(repo);
git_cache_clear(&repo->objects);
git_attr_cache_flush(repo);
set_index(repo, NULL);
set_odb(repo, NULL);
set_refdb(repo, NULL);
+
+ return 0;
}
void git_repository_free(git_repository *repo)
git_repository__cleanup(repo);
- git_cache_free(&repo->objects);
+ 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_buf_free(git_array_get(repo->reserved_names, i));
+ git_buf_dispose(git_array_get(repo->reserved_names, i));
git_array_clear(repo->reserved_names);
- git__free(repo->path_gitlink);
- git__free(repo->path_repository);
+ 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);
*
* Open a repository object from its path
*/
-static bool valid_repository_path(git_buf *repository_path)
+static int is_valid_repository_path(bool *out, git_buf *repository_path, git_buf *common_path)
{
- /* Check OBJECTS_DIR first, since it will generate the longest path name */
- if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR) == false)
- return false;
+ int error;
+
+ *out = false;
+
+ /* Check if we have a separate commondir (e.g. we have a
+ * worktree) */
+ if (git_path_contains_file(repository_path, GIT_COMMONDIR_FILE)) {
+ git_buf common_link = GIT_BUF_INIT;
+
+ if ((error = git_buf_joinpath(&common_link, repository_path->ptr, GIT_COMMONDIR_FILE)) < 0 ||
+ (error = git_futils_readbuffer(&common_link, common_link.ptr)) < 0)
+ return error;
+
+ git_buf_rtrim(&common_link);
+ if (git_path_is_relative(common_link.ptr)) {
+ if ((error = git_buf_joinpath(common_path, repository_path->ptr, common_link.ptr)) < 0)
+ return error;
+ } else {
+ git_buf_swap(common_path, &common_link);
+ }
+
+ git_buf_dispose(&common_link);
+ }
+ else {
+ if ((error = git_buf_set(common_path, repository_path->ptr, repository_path->size)) < 0)
+ return error;
+ }
+
+ /* Make sure the commondir path always has a trailing * slash */
+ if (git_buf_rfind(common_path, '/') != (ssize_t)common_path->size - 1)
+ if ((error = git_buf_putc(common_path, '/')) < 0)
+ return error;
/* Ensure HEAD file exists */
if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)
- return false;
-
- if (git_path_contains_dir(repository_path, GIT_REFS_DIR) == false)
- return false;
+ return 0;
+ /* Check files in common dir */
+ if (git_path_contains_dir(common_path, GIT_OBJECTS_DIR) == false)
+ return 0;
+ if (git_path_contains_dir(common_path, GIT_REFS_DIR) == false)
+ return 0;
- return true;
+ *out = true;
+ return 0;
}
static git_repository *repository_alloc(void)
if (!repo->reserved_names.ptr)
goto on_error;
- /* set all the entries in the cvar cache to `unset` */
- git_repository__cvar_cache_clear(repo);
+ /* 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_free(&repo->objects);
+ git_cache_dispose(&repo->objects);
git__free(repo);
return NULL;
git_repository *repo;
*out = repo = repository_alloc();
- GITERR_CHECK_ALLOC(repo);
+ GIT_ERROR_CHECK_ALLOC(repo);
repo->is_bare = 1;
+ repo->is_worktree = 0;
return 0;
}
{
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 (git_config_get_bool(&is_bare, config, "core.bare") < 0)
- repo->is_bare = 0;
+ if (err != GIT_ENOTFOUND)
+ repo->is_bare = is_bare && !repo->is_worktree;
else
- repo->is_bare = is_bare;
+ repo->is_bare = 0;
return 0;
}
static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)
{
- int error;
+ int error;
git_config_entry *ce;
- git_buf worktree = GIT_BUF_INIT;
+ git_buf worktree = GIT_BUF_INIT;
+ git_buf path = GIT_BUF_INIT;
if (repo->is_bare)
return 0;
&ce, config, "core.worktree", false)) < 0)
return error;
- if (ce && ce->value) {
+ if (repo->is_worktree) {
+ char *gitlink = git_worktree__read_link(repo->gitdir, GIT_GITDIR_FILE);
+ if (!gitlink) {
+ error = -1;
+ goto cleanup;
+ }
+
+ git_buf_attach(&worktree, gitlink, 0);
+
+ if ((git_path_dirname_r(&worktree, worktree.ptr)) < 0 ||
+ git_path_to_dir(&worktree) < 0) {
+ error = -1;
+ goto cleanup;
+ }
+
+ repo->workdir = git_buf_detach(&worktree);
+ }
+ else if (ce && ce->value) {
if ((error = git_path_prettify_dir(
- &worktree, ce->value, repo->path_repository)) < 0)
+ &worktree, ce->value, repo->gitdir)) < 0)
goto cleanup;
repo->workdir = git_buf_detach(&worktree);
else if (parent_path && git_path_isdir(parent_path->ptr))
repo->workdir = git_buf_detach(parent_path);
else {
- if (git_path_dirname_r(&worktree, repo->path_repository) < 0 ||
+ if (git_path_dirname_r(&worktree, repo->gitdir) < 0 ||
git_path_to_dir(&worktree) < 0) {
error = -1;
goto cleanup;
repo->workdir = git_buf_detach(&worktree);
}
- GITERR_CHECK_ALLOC(repo->workdir);
+ GIT_ERROR_CHECK_ALLOC(repo->workdir);
cleanup:
+ git_buf_dispose(&path);
git_config_entry_free(ce);
return error;
}
if (git_buf_len(&file) <= prefix_len ||
memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
{
- giterr_set(GITERR_REPOSITORY,
- "The `.git` file at '%s' is malformed", file_path);
+ git_error_set(GIT_ERROR_REPOSITORY,
+ "the `.git` file at '%s' is malformed", file_path);
error = -1;
}
else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
path_out, gitlink, git_buf_cstr(path_out));
}
- git_buf_free(&file);
+ git_buf_dispose(&file);
return error;
}
static int find_repo(
- git_buf *repo_path,
- git_buf *parent_path,
- git_buf *link_path,
+ git_buf *gitdir_path,
+ git_buf *workdir_path,
+ git_buf *gitlink_path,
+ git_buf *commondir_path,
const char *start_path,
uint32_t flags,
const char *ceiling_dirs)
{
- int error;
git_buf path = GIT_BUF_INIT;
git_buf repo_link = GIT_BUF_INIT;
+ git_buf common_link = GIT_BUF_INIT;
struct stat st;
dev_t initial_device = 0;
int min_iterations;
- bool in_dot_git;
+ bool in_dot_git, is_valid;
size_t ceiling_offset = 0;
+ int error;
- git_buf_free(repo_path);
+ git_buf_clear(gitdir_path);
error = git_path_prettify(&path, start_path, NULL);
if (error < 0)
for (;;) {
if (!(flags & GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
if (!in_dot_git) {
- error = git_buf_joinpath(&path, path.ptr, DOT_GIT);
- if (error < 0)
- break;
+ if ((error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0)
+ goto out;
}
in_dot_git = !in_dot_git;
}
break;
if (S_ISDIR(st.st_mode)) {
- if (valid_repository_path(&path)) {
- git_path_to_dir(&path);
- git_buf_set(repo_path, path.ptr, path.size);
+ if ((error = is_valid_repository_path(&is_valid, &path, &common_link)) < 0)
+ goto out;
+
+ if (is_valid) {
+ if ((error = git_path_to_dir(&path)) < 0 ||
+ (error = git_buf_set(gitdir_path, path.ptr, path.size)) < 0)
+ goto out;
+
+ if (gitlink_path)
+ if ((error = git_buf_attach(gitlink_path, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0)
+ goto out;
+ if (commondir_path)
+ git_buf_swap(&common_link, commondir_path);
+
break;
}
- }
- else if (S_ISREG(st.st_mode)) {
- error = read_gitfile(&repo_link, path.ptr);
- if (error < 0)
- break;
- if (valid_repository_path(&repo_link)) {
- git_buf_swap(repo_path, &repo_link);
-
- if (link_path)
- error = git_buf_put(link_path, path.ptr, path.size);
+ } 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)) < 0)
+ goto out;
+
+ if (is_valid) {
+ git_buf_swap(gitdir_path, &repo_link);
+
+ if (gitlink_path)
+ if ((error = git_buf_put(gitlink_path, path.ptr, path.size)) < 0)
+ goto out;
+ if (commondir_path)
+ git_buf_swap(&common_link, commondir_path);
}
break;
}
/* Move up one directory. If we're in_dot_git, we'll search the
* parent itself next. If we're !in_dot_git, we'll search .git
* in the parent directory next (added at the top of the loop). */
- if (git_path_dirname_r(&path, path.ptr) < 0) {
- error = -1;
- break;
- }
+ if ((error = git_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. */
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)))
+ if (min_iterations == 0 &&
+ (path.ptr[ceiling_offset] == 0 || (flags & GIT_REPOSITORY_OPEN_NO_SEARCH)))
break;
}
- if (!error && parent_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
- if (!git_buf_len(repo_path))
- git_buf_clear(parent_path);
- else {
- git_path_dirname_r(parent_path, path.ptr);
- git_path_to_dir(parent_path);
- }
- if (git_buf_oom(parent_path))
- return -1;
+ if (workdir_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
+ if (!git_buf_len(gitdir_path))
+ git_buf_clear(workdir_path);
+ else if ((error = git_path_dirname_r(workdir_path, path.ptr)) < 0 ||
+ (error = git_path_to_dir(workdir_path)) < 0)
+ goto out;
}
/* If we didn't find the repository, and we don't have any other error
* to report, report that. */
- if (!git_buf_len(repo_path) && !error) {
- giterr_set(GITERR_REPOSITORY,
- "Could not find repository from '%s'", start_path);
+ if (!git_buf_len(gitdir_path)) {
+ git_error_set(GIT_ERROR_REPOSITORY, "could not find repository from '%s'", start_path);
error = GIT_ENOTFOUND;
+ goto out;
}
- git_buf_free(&path);
- git_buf_free(&repo_link);
+out:
+ git_buf_dispose(&path);
+ git_buf_dispose(&repo_link);
+ git_buf_dispose(&common_link);
return error;
}
git_repository **repo_ptr,
const char *bare_path)
{
- int error;
- git_buf path = GIT_BUF_INIT;
+ git_buf path = GIT_BUF_INIT, common_path = GIT_BUF_INIT;
git_repository *repo = NULL;
+ bool is_valid;
+ int error;
- if ((error = git_path_prettify_dir(&path, bare_path, NULL)) < 0)
+ if ((error = git_path_prettify_dir(&path, bare_path, NULL)) < 0 ||
+ (error = is_valid_repository_path(&is_valid, &path, &common_path)) < 0)
return error;
- if (!valid_repository_path(&path)) {
- git_buf_free(&path);
- giterr_set(GITERR_REPOSITORY, "Path is not a repository: %s", bare_path);
+ if (!is_valid) {
+ git_buf_dispose(&path);
+ git_buf_dispose(&common_path);
+ git_error_set(GIT_ERROR_REPOSITORY, "path is not a repository: %s", bare_path);
return GIT_ENOTFOUND;
}
repo = repository_alloc();
- GITERR_CHECK_ALLOC(repo);
+ GIT_ERROR_CHECK_ALLOC(repo);
- repo->path_repository = git_buf_detach(&path);
- GITERR_CHECK_ALLOC(repo->path_repository);
+ repo->gitdir = git_buf_detach(&path);
+ GIT_ERROR_CHECK_ALLOC(repo->gitdir);
+ repo->commondir = git_buf_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;
*repo_ptr = repo;
if (!start_path) {
error = git__getenv(&dir_buf, "GIT_DIR");
if (error == GIT_ENOTFOUND) {
- giterr_clear();
+ git_error_clear();
start_path = ".";
} else if (error < 0)
goto error;
error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES");
if (error == GIT_ENOTFOUND)
- giterr_clear();
+ git_error_clear();
else if (error < 0)
goto error;
else
error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM");
if (error == GIT_ENOTFOUND)
- giterr_clear();
+ git_error_clear();
else if (error < 0)
goto error;
else {
error = git__getenv(&index_file_buf, "GIT_INDEX_FILE");
if (error == GIT_ENOTFOUND)
- giterr_clear();
+ git_error_clear();
else if (error < 0)
goto error;
else {
error = git__getenv(&namespace_buf, "GIT_NAMESPACE");
if (error == GIT_ENOTFOUND)
- giterr_clear();
+ git_error_clear();
else if (error < 0)
goto error;
error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");
if (error == GIT_ENOTFOUND)
- giterr_clear();
+ git_error_clear();
else if (error < 0)
goto error;
else {
error = git__getenv(&work_tree_buf, "GIT_WORK_TREE");
if (error == GIT_ENOTFOUND)
- giterr_clear();
+ git_error_clear();
else if (error < 0)
goto error;
else {
- giterr_set(GITERR_INVALID, "GIT_WORK_TREE unimplemented");
+ git_error_set(GIT_ERROR_INVALID, "GIT_WORK_TREE unimplemented");
error = GIT_ERROR;
goto error;
}
error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");
if (error == GIT_ENOTFOUND)
- giterr_clear();
+ git_error_clear();
else if (error < 0)
goto error;
else {
- giterr_set(GITERR_INVALID, "GIT_COMMON_DIR unimplemented");
+ git_error_set(GIT_ERROR_INVALID, "GIT_COMMON_DIR unimplemented");
error = GIT_ERROR;
goto error;
}
error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES");
if (error == GIT_ENOTFOUND) {
- giterr_clear();
+ git_error_clear();
error = 0;
} else if (error < 0)
goto error;
success:
git_odb_free(odb);
git_index_free(index);
- git_buf_free(&common_dir_buf);
- git_buf_free(&work_tree_buf);
- git_buf_free(&alts_buf);
- git_buf_free(&object_dir_buf);
- git_buf_free(&namespace_buf);
- git_buf_free(&index_file_buf);
- git_buf_free(&across_fs_buf);
- git_buf_free(&ceiling_dirs_buf);
- git_buf_free(&dir_buf);
+ git_buf_dispose(&common_dir_buf);
+ git_buf_dispose(&work_tree_buf);
+ git_buf_dispose(&alts_buf);
+ git_buf_dispose(&object_dir_buf);
+ git_buf_dispose(&namespace_buf);
+ git_buf_dispose(&index_file_buf);
+ git_buf_dispose(&across_fs_buf);
+ git_buf_dispose(&ceiling_dirs_buf);
+ git_buf_dispose(&dir_buf);
+ return error;
+}
+
+static int repo_is_worktree(unsigned *out, const git_repository *repo)
+{
+ git_buf gitdir_link = GIT_BUF_INIT;
+ int error;
+
+ /* Worktrees cannot have the same commondir and gitdir */
+ if (repo->commondir && repo->gitdir
+ && !strcmp(repo->commondir, repo->gitdir)) {
+ *out = 0;
+ return 0;
+ }
+
+ if ((error = git_buf_joinpath(&gitdir_link, repo->gitdir, "gitdir")) < 0)
+ return -1;
+
+ /* A 'gitdir' file inside a git directory is currently
+ * only used when the repository is a working tree. */
+ *out = !!git_path_exists(gitdir_link.ptr);
+
+ git_buf_dispose(&gitdir_link);
return error;
}
const char *ceiling_dirs)
{
int error;
- git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT,
- link_path = GIT_BUF_INIT;
- git_repository *repo;
+ unsigned is_worktree;
+ git_buf gitdir = GIT_BUF_INIT, workdir = GIT_BUF_INIT,
+ gitlink = GIT_BUF_INIT, commondir = GIT_BUF_INIT;
+ git_repository *repo = NULL;
git_config *config = NULL;
if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)
*repo_ptr = NULL;
error = find_repo(
- &path, &parent, &link_path, start_path, flags, ceiling_dirs);
+ &gitdir, &workdir, &gitlink, &commondir, start_path, flags, ceiling_dirs);
if (error < 0 || !repo_ptr)
- return error;
+ goto cleanup;
repo = repository_alloc();
- GITERR_CHECK_ALLOC(repo);
+ GIT_ERROR_CHECK_ALLOC(repo);
- repo->path_repository = git_buf_detach(&path);
- GITERR_CHECK_ALLOC(repo->path_repository);
+ repo->gitdir = git_buf_detach(&gitdir);
+ GIT_ERROR_CHECK_ALLOC(repo->gitdir);
- if (link_path.size) {
- repo->path_gitlink = git_buf_detach(&link_path);
- GITERR_CHECK_ALLOC(repo->path_gitlink);
+ if (gitlink.size) {
+ repo->gitlink = git_buf_detach(&gitlink);
+ GIT_ERROR_CHECK_ALLOC(repo->gitlink);
+ }
+ if (commondir.size) {
+ repo->commondir = git_buf_detach(&commondir);
+ GIT_ERROR_CHECK_ALLOC(repo->commondir);
}
+ if ((error = repo_is_worktree(&is_worktree, repo)) < 0)
+ goto cleanup;
+ repo->is_worktree = is_worktree;
+
/*
* We'd like to have the config, but git doesn't particularly
* care if it's not there, so we need to deal with that.
if (config &&
((error = load_config_data(repo, config)) < 0 ||
- (error = load_workdir(repo, config, &parent)) < 0))
+ (error = load_workdir(repo, config, &workdir)) < 0))
goto cleanup;
}
cleanup:
- git_buf_free(&parent);
+ git_buf_dispose(&gitdir);
+ git_buf_dispose(&workdir);
+ git_buf_dispose(&gitlink);
+ git_buf_dispose(&commondir);
git_config_free(config);
if (error < 0)
git_repository_free(repo);
- else
+ else if (repo_ptr)
*repo_ptr = repo;
return error;
repo_out, path, GIT_REPOSITORY_OPEN_NO_SEARCH, NULL);
}
+int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *wt)
+{
+ git_buf path = GIT_BUF_INIT;
+ git_repository *repo = NULL;
+ size_t len;
+ int err;
+
+ assert(repo_out && 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_buf_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_buf_dispose(&path);
+
+ return err;
+}
+
int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
{
git_repository *repo;
repo = repository_alloc();
- GITERR_CHECK_ALLOC(repo);
+ GIT_ERROR_CHECK_ALLOC(repo);
git_repository_set_odb(repo, odb);
*repo_out = repo;
git_buf_sanitize(out);
- return find_repo(out, NULL, NULL, start_path, flags, ceiling_dirs);
+ return find_repo(out, NULL, NULL, NULL, start_path, flags, ceiling_dirs);
}
static int load_config(
git_buf config_path = GIT_BUF_INIT;
git_config *cfg = NULL;
- assert(repo && out);
+ assert(out);
if ((error = git_config_new(&cfg)) < 0)
return error;
- error = git_buf_joinpath(
- &config_path, repo->path_repository, GIT_CONFIG_FILENAME_INREPO);
- if (error < 0)
- goto on_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 = git_config_add_file_ondisk(
- cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, 0)) < 0 &&
- error != GIT_ENOTFOUND)
- goto on_error;
+ if (error && error != GIT_ENOTFOUND)
+ goto on_error;
- git_buf_free(&config_path);
+ git_buf_dispose(&config_path);
+ }
if (global_config_path != NULL &&
(error = git_config_add_file_ondisk(
- cfg, global_config_path, GIT_CONFIG_LEVEL_GLOBAL, 0)) < 0 &&
+ 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, 0)) < 0 &&
+ 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, 0)) < 0 &&
+ 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, 0)) < 0 &&
+ cfg, programdata_path, GIT_CONFIG_LEVEL_PROGRAMDATA, repo, 0)) < 0 &&
error != GIT_ENOTFOUND)
goto on_error;
- giterr_clear(); /* clear any lingering ENOTFOUND errors */
+ git_error_clear(); /* clear any lingering ENOTFOUND errors */
*out = cfg;
return 0;
on_error:
- git_buf_free(&config_path);
+ git_buf_dispose(&config_path);
git_config_free(cfg);
*out = NULL;
return error;
}
}
- git_buf_free(&global_buf);
- git_buf_free(&xdg_buf);
- git_buf_free(&system_buf);
- git_buf_free(&programdata_buf);
+ git_buf_dispose(&global_buf);
+ git_buf_dispose(&xdg_buf);
+ git_buf_dispose(&system_buf);
+ git_buf_dispose(&programdata_buf);
}
*out = repo->_config;
return git_config_snapshot(out, weak);
}
-void git_repository_set_config(git_repository *repo, git_config *config)
+int git_repository_set_config(git_repository *repo, git_config *config)
{
assert(repo && config);
set_config(repo, config);
+ return 0;
}
int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
git_buf odb_path = GIT_BUF_INIT;
git_odb *odb;
- if ((error = git_buf_joinpath(&odb_path, repo->path_repository, GIT_OBJECTS_DIR)) < 0)
+ if ((error = git_repository_item_path(&odb_path, repo,
+ GIT_REPOSITORY_ITEM_OBJECTS)) < 0 ||
+ (error = git_odb_new(&odb)) < 0)
return error;
- error = git_odb_open(&odb, odb_path.ptr);
- if (!error) {
- GIT_REFCOUNT_OWN(odb, repo);
+ GIT_REFCOUNT_OWN(odb, repo);
- odb = git__compare_and_swap(&repo->_odb, NULL, odb);
- if (odb != NULL) {
- GIT_REFCOUNT_OWN(odb, NULL);
- git_odb_free(odb);
- }
+ 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;
}
- git_buf_free(&odb_path);
+ odb = git__compare_and_swap(&repo->_odb, NULL, odb);
+ if (odb != NULL) {
+ GIT_REFCOUNT_OWN(odb, NULL);
+ git_odb_free(odb);
+ }
+
+ git_buf_dispose(&odb_path);
}
*out = repo->_odb;
return 0;
}
-void git_repository_set_odb(git_repository *repo, git_odb *odb)
+int git_repository_set_odb(git_repository *repo, git_odb *odb)
{
assert(repo && odb);
set_odb(repo, odb);
+ return 0;
}
int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo)
return 0;
}
-void git_repository_set_refdb(git_repository *repo, git_refdb *refdb)
+int git_repository_set_refdb(git_repository *repo, git_refdb *refdb)
{
assert(repo && refdb);
set_refdb(repo, refdb);
+ return 0;
}
int git_repository_index__weakptr(git_index **out, git_repository *repo)
git_buf index_path = GIT_BUF_INIT;
git_index *index;
- if ((error = git_buf_joinpath(&index_path, repo->path_repository, GIT_INDEX_FILE)) < 0)
+ if ((error = git_buf_joinpath(&index_path, repo->gitdir, GIT_INDEX_FILE)) < 0)
return error;
error = git_index_open(&index, index_path.ptr);
git_index_free(index);
}
- error = git_index_set_caps(repo->_index, GIT_INDEXCAP_FROM_OWNER);
+ error = git_index_set_caps(repo->_index,
+ GIT_INDEX_CAPABILITY_FROM_OWNER);
}
- git_buf_free(&index_path);
+ git_buf_dispose(&index_path);
}
*out = repo->_index;
return 0;
}
-void git_repository_set_index(git_repository *repo, git_index *index)
+int git_repository_set_index(git_repository *repo, git_index *index)
{
assert(repo);
set_index(repo, index);
+ return 0;
}
int git_repository_set_namespace(git_repository *repo, const char *namespace)
name_len = strlen(name);
- if ((name_len == def_len && memcmp(name, def, def_len) == 0) ||
+ 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;
int (*prefixcmp)(const char *, const char *);
int error, ignorecase;
- error = git_repository__cvar(
- &ignorecase, repo, GIT_CVAR_IGNORECASE);
+ error = git_repository__configmap_lookup(
+ &ignorecase, repo, GIT_CONFIGMAP_IGNORECASE);
prefixcmp = (error || ignorecase) ? git__prefixcmp_icase :
git__prefixcmp;
- if (repo->path_gitlink &&
- reserved_names_add8dot3(repo, repo->path_gitlink) < 0)
+ if (repo->gitlink &&
+ reserved_names_add8dot3(repo, repo->gitlink) < 0)
goto on_error;
- if (repo->path_repository &&
- prefixcmp(repo->path_repository, repo->workdir) == 0 &&
- reserved_names_add8dot3(repo, repo->path_repository) < 0)
+ if (repo->gitdir &&
+ prefixcmp(repo->gitdir, repo->workdir) == 0 &&
+ reserved_names_add8dot3(repo, repo->gitdir) < 0)
goto on_error;
}
}
return -1;
if (GIT_REPO_VERSION < version) {
- giterr_set(GITERR_REPOSITORY,
- "Unsupported repository version %d. Only versions up to %d are supported.",
+ git_error_set(GIT_ERROR_REPOSITORY,
+ "unsupported repository version %d. Only versions up to %d are supported.",
version, GIT_REPO_VERSION);
return -1;
}
return 0;
}
-static int repo_init_create_head(const char *git_dir, const char *ref_name)
+int git_repository_create_head(const char *git_dir, const char *ref_name)
{
git_buf ref_path = GIT_BUF_INIT;
git_filebuf ref = GIT_FILEBUF_INIT;
const char *fmt;
+ int error;
- if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 ||
- git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE) < 0)
- goto fail;
+ if ((error = git_buf_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 (!ref_name)
ref_name = GIT_BRANCH_MASTER;
else
fmt = "ref: " GIT_REFS_HEADS_DIR "%s\n";
- if (git_filebuf_printf(&ref, fmt, ref_name) < 0 ||
- git_filebuf_commit(&ref) < 0)
- goto fail;
-
- git_buf_free(&ref_path);
- return 0;
+ if ((error = git_filebuf_printf(&ref, fmt, ref_name)) < 0 ||
+ (error = git_filebuf_commit(&ref)) < 0)
+ goto out;
-fail:
- git_buf_free(&ref_path);
+out:
+ git_buf_dispose(&ref_path);
git_filebuf_cleanup(&ref);
- return -1;
+ return error;
}
static bool is_chmod_supported(const char *file_path)
if (!git_buf_joinpath(&path, gitdir_path, "CoNfIg"))
is_insensitive = git_path_exists(git_buf_cstr(&path));
- git_buf_free(&path);
+ git_buf_dispose(&path);
return is_insensitive;
}
static bool are_symlinks_supported(const char *wd_path)
{
- git_buf path = GIT_BUF_INIT;
- int fd;
- struct stat st;
- int symlinks_supported = -1;
-
- if ((fd = git_futils_mktmp(&path, wd_path, 0666)) < 0 ||
- p_close(fd) < 0 ||
- p_unlink(path.ptr) < 0 ||
- p_symlink("testing", path.ptr) < 0 ||
- p_lstat(path.ptr, &st) < 0)
- symlinks_supported = false;
- else
- symlinks_supported = (S_ISLNK(st.st_mode) != 0);
+ git_config *config = NULL;
+ git_buf global_buf = GIT_BUF_INIT;
+ git_buf xdg_buf = GIT_BUF_INIT;
+ git_buf system_buf = GIT_BUF_INIT;
+ git_buf programdata_buf = GIT_BUF_INIT;
+ 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
+ git_config_find_global(&global_buf);
+ git_config_find_xdg(&xdg_buf);
+ git_config_find_system(&system_buf);
+ git_config_find_programdata(&programdata_buf);
+
+ if (load_config(&config, NULL,
+ path_unless_empty(&global_buf),
+ path_unless_empty(&xdg_buf),
+ path_unless_empty(&system_buf),
+ path_unless_empty(&programdata_buf)) < 0)
+ goto done;
+
+ if (git_config_get_bool(&symlinks, config, "core.symlinks") < 0 || !symlinks)
+ goto done;
+#endif
- (void)p_unlink(path.ptr);
- git_buf_free(&path);
+ if (!(symlinks = git_path_supports_symlinks(wd_path)))
+ goto done;
- return symlinks_supported;
+done:
+ git_buf_dispose(&global_buf);
+ git_buf_dispose(&xdg_buf);
+ git_buf_dispose(&system_buf);
+ git_buf_dispose(&programdata_buf);
+ 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) {
- giterr_set(GITERR_OS, "Error while creating '%s'", path);
+ git_error_set(GIT_ERROR_OS, "error while creating '%s'", path);
return -1;
}
if (p_close(fd) < 0) {
- giterr_set(GITERR_OS, "Error while closing '%s'", path);
+ git_error_set(GIT_ERROR_OS, "error while closing '%s'", path);
return -1;
}
return error;
if (git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL) < 0) {
- giterr_clear();
+ git_error_clear();
if (!(error = git_config_add_file_ondisk(
- parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, false)))
+ parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, repo, false)))
error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
}
if ((error = git_config_set_bool(cfg, "core.symlinks", false)) < 0)
return error;
} else if (git_config_delete_entry(cfg, "core.symlinks") < 0)
- giterr_clear();
+ 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)
- giterr_clear();
+ git_error_clear();
}
#ifdef GIT_USE_ICONV
SET_REPO_CONFIG(string, "core.worktree", worktree_path.ptr);
} else if (is_reinit) {
if (git_config_delete_entry(config, "core.worktree") < 0)
- giterr_clear();
+ git_error_clear();
}
}
}
cleanup:
- git_buf_free(&cfg_path);
- git_buf_free(&worktree_path);
+ git_buf_dispose(&cfg_path);
+ git_buf_dispose(&worktree_path);
git_config_free(config);
return error;
if (git_submodule_open(&smrepo, sm) < 0 ||
git_repository_reinit_filesystem(smrepo, true) < 0)
- giterr_clear();
+ git_error_clear();
git_repository_free(smrepo);
return 0;
config, path.ptr, repo_dir, git_repository_workdir(repo), true);
git_config_free(config);
- git_buf_free(&path);
+ git_buf_dispose(&path);
- git_repository__cvar_cache_clear(repo);
+ git_repository__configmap_lookup_cache_clear(repo);
if (!repo->is_bare && recurse)
(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
GIT_UNUSED(hidden);
#endif
- git_buf_free(&path);
+ git_buf_dispose(&path);
if (error)
- giterr_set(GITERR_OS,
- "Failed to initialize repository with template '%s'", file);
+ git_error_set(GIT_ERROR_OS,
+ "failed to initialize repository with template '%s'", file);
return error;
}
goto cleanup;
if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) {
- giterr_set(GITERR_REPOSITORY,
- "Cannot overwrite gitlink file into path '%s'", in_dir);
+ git_error_set(GIT_ERROR_REPOSITORY,
+ "cannot overwrite gitlink file into path '%s'", in_dir);
error = GIT_EEXISTS;
goto cleanup;
}
error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
cleanup:
- git_buf_free(&buf);
- git_buf_free(&path_to_repo);
+ git_buf_dispose(&buf);
+ git_buf_dispose(&path_to_repo);
return error;
}
#ifdef GIT_WIN32
if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
if (git_win32__set_hidden(repo_dir, true) < 0) {
- giterr_set(GITERR_OS,
- "Failed to mark Git repository folder as hidden");
+ git_error_set(GIT_ERROR_OS,
+ "failed to mark Git repository folder as hidden");
return -1;
}
}
else if ((error = git_config_open_default(&cfg)) >= 0) {
if (!git_config_get_path(&template_buf, cfg, "init.templatedir"))
tdir = template_buf.ptr;
- giterr_clear();
+ git_error_clear();
}
if (!tdir) {
default_template = true;
}
- if (tdir) {
+ /*
+ * 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;
error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
}
- git_buf_free(&template_buf);
+ git_buf_dispose(&template_buf);
git_config_free(cfg);
if (error < 0) {
return error;
/* if template was default, ignore error and use internal */
- giterr_clear();
+ git_error_clear();
external_tpl = false;
error = 0;
}
if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
return -1;
} else {
- giterr_set(GITERR_REPOSITORY, "Cannot pick working directory"
+ git_error_set(GIT_ERROR_REPOSITORY, "cannot pick working directory"
" for non-bare repository that isn't a '.git' directory");
return -1;
}
const char *given_repo,
git_repository_init_options *opts)
{
- int error;
- git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT;
+ git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT,
+ common_path = GIT_BUF_INIT, head_path = GIT_BUF_INIT;
const char *wd;
+ bool is_valid;
+ int error;
assert(out && given_repo && opts);
- GITERR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
+ GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
- error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
- if (error < 0)
- goto cleanup;
+ if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0)
+ goto out;
wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_buf_cstr(&wd_path);
- if (valid_repository_path(&repo_path)) {
+ if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path)) < 0)
+ goto out;
+
+ if (is_valid) {
if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
- giterr_set(GITERR_REPOSITORY,
- "Attempt to reinitialize '%s'", given_repo);
+ git_error_set(GIT_ERROR_REPOSITORY,
+ "attempt to reinitialize '%s'", given_repo);
error = GIT_EEXISTS;
- goto cleanup;
+ goto out;
}
opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;
- error = repo_init_config(
- repo_path.ptr, wd, opts->flags, opts->mode);
+ if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 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)) < 0 ||
+ (error = git_buf_joinpath(&head_path, repo_path.ptr, GIT_HEAD_FILE)) < 0)
+ goto out;
+
+ /*
+ * Only set the new HEAD if the file does not exist already via
+ * a template or if the caller has explicitly supplied an
+ * initial HEAD value.
+ */
+ if ((!git_path_exists(head_path.ptr) || opts->initial_head) &&
+ (error = git_repository_create_head(repo_path.ptr, opts->initial_head)) < 0)
+ goto out;
}
- else {
- if (!(error = repo_init_structure(
- repo_path.ptr, wd, opts)) &&
- !(error = repo_init_config(
- repo_path.ptr, wd, opts->flags, opts->mode)))
- error = repo_init_create_head(
- repo_path.ptr, opts->initial_head);
- }
- if (error < 0)
- goto cleanup;
- error = git_repository_open(out, repo_path.ptr);
+ if ((error = git_repository_open(out, repo_path.ptr)) < 0)
+ goto out;
- if (!error && opts->origin_url)
- error = repo_init_create_origin(*out, opts->origin_url);
+ if (opts->origin_url &&
+ (error = repo_init_create_origin(*out, opts->origin_url)) < 0)
+ goto out;
-cleanup:
- git_buf_free(&repo_path);
- git_buf_free(&wd_path);
+out:
+ git_buf_dispose(&head_path);
+ git_buf_dispose(&common_path);
+ git_buf_dispose(&repo_path);
+ git_buf_dispose(&wd_path);
return error;
}
if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
return -1;
- if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
+ if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
git_reference_free(ref);
return 0;
}
return exists;
}
+static int get_worktree_file_path(git_buf *out, git_repository *repo, const char *worktree, const char *file)
+{
+ git_buf_clear(out);
+ return git_buf_printf(out, "%s/worktrees/%s/%s", repo->commondir, worktree, file);
+}
+
+int git_repository_head_detached_for_worktree(git_repository *repo, const char *name)
+{
+ git_reference *ref = NULL;
+ int error;
+
+ assert(repo && 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;
+ assert(head_out);
+
if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
return error;
- if (git_reference_type(head) == GIT_REF_OID) {
+ if (git_reference_type(head) == GIT_REFERENCE_DIRECT) {
*head_out = head;
return 0;
}
return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
}
+int git_repository_head_for_worktree(git_reference **out, git_repository *repo, const char *name)
+{
+ git_buf path = GIT_BUF_INIT;
+ git_reference *head = NULL;
+ int error;
+
+ assert(out && repo && name);
+
+ *out = NULL;
+
+ if ((error = get_worktree_file_path(&path, repo, name, GIT_HEAD_FILE)) < 0 ||
+ (error = git_reference__read_head(&head, repo, path.ptr)) < 0)
+ goto out;
+
+ if (git_reference_type(head) != GIT_REFERENCE_DIRECT) {
+ git_reference *resolved;
+
+ error = git_reference_lookup_resolved(&resolved, repo, git_reference_symbolic_target(head), -1);
+ git_reference_free(head);
+ head = resolved;
+ }
+
+ *out = head;
+
+out:
+ if (error)
+ git_reference_free(head);
+
+ git_buf_dispose(&path);
+
+ return error;
+}
+
+int git_repository_foreach_head(git_repository *repo,
+ git_repository_foreach_head_cb cb,
+ int flags, void *payload)
+{
+ git_strarray worktrees = GIT_VECTOR_INIT;
+ git_buf path = GIT_BUF_INIT;
+ int error = 0;
+ size_t i;
+
+
+ if (!(flags & GIT_REPOSITORY_FOREACH_HEAD_SKIP_REPO)) {
+ /* Gather HEAD of main repository */
+ if ((error = git_buf_joinpath(&path, repo->commondir, GIT_HEAD_FILE)) < 0 ||
+ (error = cb(repo, path.ptr, payload) != 0))
+ goto out;
+ }
+
+ if (!(flags & GIT_REPOSITORY_FOREACH_HEAD_SKIP_WORKTREES)) {
+ if ((error = git_worktree_list(&worktrees, repo)) < 0) {
+ error = 0;
+ goto out;
+ }
+
+ /* Gather HEADs of all worktrees */
+ for (i = 0; i < worktrees.count; i++) {
+ if (get_worktree_file_path(&path, repo, worktrees.strings[i], GIT_HEAD_FILE) < 0)
+ continue;
+
+ if ((error = cb(repo, path.ptr, payload)) != 0)
+ goto out;
+ }
+ }
+
+out:
+ git_buf_dispose(&path);
+ git_strarray_free(&worktrees);
+ return error;
+}
+
int git_repository_head_unborn(git_repository *repo)
{
git_reference *ref = NULL;
git_reference_free(ref);
if (error == GIT_EUNBORNBRANCH) {
- giterr_clear();
+ git_error_clear();
return 1;
}
if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0)
return -1;
- if (git_reference_type(head) == GIT_REF_SYMBOLIC)
+ if (git_reference_type(head) == GIT_REFERENCE_SYMBOLIC)
is_empty =
(strcmp(git_reference_symbolic_target(head),
GIT_REFS_HEADS_DIR "master") == 0) &&
return is_empty;
}
-const char *git_repository_path(git_repository *repo)
+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)
+{
+ 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_buf_sets(out, parent) < 0)
+ return -1;
+
+ if (items[item].name) {
+ if (git_buf_joinpath(out, parent, items[item].name) < 0)
+ return -1;
+ }
+
+ if (items[item].directory) {
+ if (git_path_to_dir(out) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+const char *git_repository_path(const git_repository *repo)
{
assert(repo);
- return repo->path_repository;
+ return repo->gitdir;
}
-const char *git_repository_workdir(git_repository *repo)
+const char *git_repository_workdir(const git_repository *repo)
{
assert(repo);
return repo->workdir;
}
+const char *git_repository_commondir(const git_repository *repo)
+{
+ assert(repo);
+ return repo->commondir;
+}
+
int git_repository_set_workdir(
git_repository *repo, const char *workdir, int update_gitlink)
{
return error;
}
-int git_repository_is_bare(git_repository *repo)
+int git_repository_is_bare(const git_repository *repo)
{
assert(repo);
return repo->is_bare;
}
+int git_repository_is_worktree(const git_repository *repo)
+{
+ assert(repo);
+ return repo->is_worktree;
+}
+
int git_repository_set_bare(git_repository *repo)
{
int error;
if ((error = git_repository_head(&head, repo)) < 0)
return error;
- if ((error = git_reference_peel(&obj, head, GIT_OBJ_TREE)) < 0)
+ if ((error = git_reference_peel(&obj, head, GIT_OBJECT_TREE)) < 0)
goto cleanup;
*tree = (git_tree *)obj;
git_oid_fmt(orig_head_str, orig_head);
- if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_ORIG_HEAD_FILE)) == 0 &&
- (error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_MERGE_FILE_MODE)) == 0 &&
+ if ((error = git_buf_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", GIT_OID_HEXSZ, orig_head_str)) == 0)
error = git_filebuf_commit(&file);
if (error < 0)
git_filebuf_cleanup(&file);
- git_buf_free(&file_path);
+ git_buf_dispose(&file_path);
return error;
}
git_buf_sanitize(out);
- if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
+ if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
return -1;
if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
if (errno == ENOENT)
error = GIT_ENOTFOUND;
- giterr_set(GITERR_OS, "Could not access message file");
+ git_error_set(GIT_ERROR_OS, "could not access message file");
} else {
error = git_futils_readbuffer(out, git_buf_cstr(&path));
}
- git_buf_free(&path);
+ git_buf_dispose(&path);
return error;
}
git_buf path = GIT_BUF_INIT;
int error;
- if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
+ if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
return -1;
error = p_unlink(git_buf_cstr(&path));
- git_buf_free(&path);
+ git_buf_dispose(&path);
return error;
}
git_oid *out,
git_repository *repo,
const char *path,
- git_otype type,
+ git_object_t type,
const char *as_path)
{
int error;
git_filter_list *fl = NULL;
git_file fd = -1;
- git_off_t len;
+ uint64_t len;
git_buf full_path = GIT_BUF_INIT;
assert(out && path && repo); /* as_path can be NULL */
goto cleanup;
}
- len = git_futils_filesize(fd);
- if (len < 0) {
- error = (int)len;
+ if ((error = git_futils_filesize(&len, fd)) < 0)
goto cleanup;
- }
if (!git__is_sizet(len)) {
- giterr_set(GITERR_OS, "File size overflow for 32-bit systems");
+ git_error_set(GIT_ERROR_OS, "file size overflow for 32-bit systems");
error = -1;
goto cleanup;
}
if (fd >= 0)
p_close(fd);
git_filter_list_free(fl);
- git_buf_free(&full_path);
+ git_buf_dispose(&full_path);
return error;
}
{
git_buf_puts(out, "checkout: moving from ");
- if (git_reference_type(old) == GIT_REF_SYMBOLIC)
+ if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC)
git_buf_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
else
git_buf_puts(out, git_oid_tostr_s(git_reference_target(old)));
git_buf_puts(out, " to ");
- if (git_reference__is_branch(new))
+ if (git_reference__is_branch(new) ||
+ git_reference__is_tag(new) ||
+ git_reference__is_remote(new))
git_buf_puts(out, git_reference__shorthand(new));
else
git_buf_puts(out, new);
return 0;
}
-int git_repository_set_head(
- git_repository* repo,
- const char* refname)
+static int detach(git_repository *repo, const git_oid *id, const char *new)
{
- git_reference *ref = NULL, *current = NULL, *new_head = NULL;
- git_buf log_message = GIT_BUF_INIT;
int error;
+ git_buf log_message = GIT_BUF_INIT;
+ git_object *object = NULL, *peeled = NULL;
+ git_reference *new_head = NULL, *current = NULL;
- assert(repo && refname);
+ assert(repo && id);
if ((error = git_reference_lookup(¤t, repo, GIT_HEAD_FILE)) < 0)
return error;
- if ((error = checkout_message(&log_message, current, refname)) < 0)
+ if ((error = git_object_lookup(&object, repo, id, GIT_OBJECT_ANY)) < 0)
goto cleanup;
- error = git_reference_lookup(&ref, repo, refname);
- if (error < 0 && error != GIT_ENOTFOUND)
+ if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0)
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_buf_cstr(&log_message));
- } else {
- error = git_repository_set_head_detached(repo, git_reference_target(ref));
- }
- } else if (git_reference__is_branch(refname)) {
- error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
- true, git_buf_cstr(&log_message));
- }
+ if (new == NULL)
+ new = git_oid_tostr_s(git_object_id(peeled));
+
+ 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_buf_cstr(&log_message));
cleanup:
- git_buf_free(&log_message);
+ git_buf_dispose(&log_message);
+ git_object_free(object);
+ git_object_free(peeled);
git_reference_free(current);
- git_reference_free(ref);
git_reference_free(new_head);
return error;
}
-static int detach(git_repository *repo, const git_oid *id, const char *from)
+int git_repository_set_head(
+ git_repository* repo,
+ const char* refname)
{
- int error;
+ git_reference *ref = NULL, *current = NULL, *new_head = NULL;
git_buf log_message = GIT_BUF_INIT;
- git_object *object = NULL, *peeled = NULL;
- git_reference *new_head = NULL, *current = NULL;
+ int error;
- assert(repo && id);
+ assert(repo && refname);
if ((error = git_reference_lookup(¤t, repo, GIT_HEAD_FILE)) < 0)
return error;
- if ((error = git_object_lookup(&object, repo, id, GIT_OBJ_ANY)) < 0)
+ if ((error = checkout_message(&log_message, current, refname)) < 0)
goto cleanup;
- if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
+ error = git_reference_lookup(&ref, repo, refname);
+ if (error < 0 && error != GIT_ENOTFOUND)
goto cleanup;
- if (from == NULL)
- from = git_oid_tostr_s(git_object_id(peeled));
-
- if ((error = checkout_message(&log_message, current, from)) < 0)
+ 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;
+ }
- error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, git_buf_cstr(&log_message));
+ 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_buf_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_buf_cstr(&log_message));
+ }
cleanup:
- git_buf_free(&log_message);
- git_object_free(object);
- git_object_free(peeled);
+ git_buf_dispose(&log_message);
git_reference_free(current);
+ git_reference_free(ref);
git_reference_free(new_head);
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_OBJ_COMMIT)) < 0)
+ if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0)
goto cleanup;
if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
1, git_buf_cstr(&log_message));
cleanup:
- git_buf_free(&log_message);
+ git_buf_dispose(&log_message);
git_object_free(object);
git_reference_free(old_head);
git_reference_free(new_head);
assert(repo);
- if (git_buf_puts(&repo_path, repo->path_repository) < 0)
+ if (git_buf_puts(&repo_path, repo->gitdir) < 0)
return -1;
if (git_path_contains_file(&repo_path, GIT_REBASE_MERGE_INTERACTIVE_FILE))
} else if (git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
state = GIT_REPOSITORY_STATE_BISECT;
- git_buf_free(&repo_path);
+ git_buf_dispose(&repo_path);
return state;
}
for (error = 0, i = 0; !error && i < files_len; ++i) {
const char *path;
- if (git_buf_joinpath(&buf, repo->path_repository, files[i]) < 0)
+ if (git_buf_joinpath(&buf, repo->gitdir, files[i]) < 0)
return -1;
path = git_buf_cstr(&buf);
error = git_futils_rmdir_r(path, NULL,
GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS);
}
-
+
git_buf_clear(&buf);
}
- git_buf_free(&buf);
+ git_buf_dispose(&buf);
return error;
}
struct stat st;
int error;
- if ((error = git_buf_joinpath(&path, repo->path_repository, "shallow")) < 0)
+ if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0)
return error;
error = git_path_lstat(path.ptr, &st);
- git_buf_free(&path);
+ git_buf_dispose(&path);
if (error == GIT_ENOTFOUND) {
- giterr_clear();
+ git_error_clear();
return 0;
}
return st.st_size == 0 ? 0 : 1;
}
-int git_repository_init_init_options(
+int git_repository_init_options_init(
git_repository_init_options *opts, unsigned int version)
{
GIT_INIT_STRUCTURE_FROM_TEMPLATE(
return 0;
}
+int git_repository_init_init_options(
+ git_repository_init_options *opts, unsigned int version)
+{
+ return git_repository_init_options_init(opts, version);
+}
+
int git_repository_ident(const char **name, const char **email, const git_repository *repo)
{
*name = repo->ident_name;
if (name) {
tmp_name = git__strdup(name);
- GITERR_CHECK_ALLOC(tmp_name);
+ GIT_ERROR_CHECK_ALLOC(tmp_name);
}
if (email) {
tmp_email = git__strdup(email);
- GITERR_CHECK_ALLOC(tmp_email);
+ GIT_ERROR_CHECK_ALLOC(tmp_email);
}
tmp_name = git__swap(repo->ident_name, tmp_name);
return 0;
}
+
+int git_repository_submodule_cache_all(git_repository *repo)
+{
+ int error;
+
+ assert(repo);
+
+ if ((error = git_strmap_new(&repo->submodule_cache)))
+ return error;
+
+ error = git_submodule__map(repo, repo->submodule_cache);
+ return error;
+}
+
+int git_repository_submodule_cache_clear(git_repository *repo)
+{
+ git_submodule *sm;
+ assert(repo);
+ if (repo->submodule_cache == NULL) {
+ return 0;
+ }
+ git_strmap_foreach_value(repo->submodule_cache, sm, {
+ git_submodule_free(sm);
+ });
+ git_strmap_free(repo->submodule_cache);
+ repo->submodule_cache = 0;
+ return 0;
+}
projects / libgit2.git / blobdiff