proxmox-mirrors/libgit2
1
0
Fork 0
mirror of https://git.proxmox.com/git/libgit2 synced 2025-08-06 06:30:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add git_repository_init_ext for power initters

Browse Source 
The extended version of repository init adds support for many
of the things that you can do with `git init` and sets up
structures that will make it easier to extend further in the
future.
This commit is contained in:
Russell Belfer 2012-07-26 16:07:01 -07:00
parent 5fdc41e765
commit 662880ca60
6 changed files with 529 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
include/git2/repository.h
View File

@ -83,6 +83,15 @@ GIT_EXTERN(int) git_repository_discover(
int across_fs,
const char *ceiling_dirs);
/**
* Option flags for `git_repository_open_ext`.
*
* * GIT_REPOSITORY_OPEN_NO_SEARCH - Only open the repository if it can be
* immediately found in the start_path. Do not walk up from the
* start_path looking at parent directories.
* * GIT_REPOSITORY_OPEN_CROSS_FS - Do not continue search across
* filesystem boundaries (as reported by the `stat` system call).
*/
enum {
GIT_REPOSITORY_OPEN_NO_SEARCH = (1 << 0),
GIT_REPOSITORY_OPEN_CROSS_FS = (1 << 1),
@ -90,6 +99,20 @@ enum {
/**
* Find and open a repository with extended controls.
*
* @param repo_out Pointer to the repo which will be opened. This can
* actually be NULL if you only want to use the error code to
* see if a repo at this path could be opened.
* @param start_path Path to open as git repository. If the flags
* permit "searching", then this can be a path to a subdirectory
* inside the working directory of the repository.
* @param flags A combination of the GIT_REPOSITORY_OPEN flags above.
* @param ceiling_dirs A GIT_PATH_LIST_SEPARATOR delimited list of path
* prefixes at which the search for a containing repository should
* terminate.
* @return 0 on success, GIT_ENOTFOUND if no repository could be found,
* or -1 if there was a repository but open failed for some reason
* (such as repo corruption or system errors).
*/
GIT_EXTERN(int) git_repository_open_ext(
git_repository **repo,
@ -118,13 +141,117 @@ GIT_EXTERN(void) git_repository_free(git_repository *repo);
*
* @param repo_out pointer to the repo which will be created or reinitialized
* @param path the path to the repository
* @param is_bare if true, a Git repository without a working directory is created
* at the pointed path. If false, provided path will be considered as the working
* directory into which the .git directory will be created.
* @param is_bare if true, a Git repository without a working directory is
* created at the pointed path. If false, provided path will be
* considered as the working directory into which the .git directory
* will be created.
*
* @return 0 or an error code
*/
GIT_EXTERN(int) git_repository_init(git_repository **repo_out, const char *path, unsigned is_bare);
GIT_EXTERN(int) git_repository_init(
git_repository **repo_out,
const char *path,
unsigned is_bare);
/**
* Option flags for `git_repository_init_ext`.
*
* These flags configure extra behaviors to `git_repository_init_ext`.
* In every case, the default behavior is the zero value (i.e. flag is
* not set). Just OR the flag values together for the `flags` parameter
* when initializing a new repo. Details of individual values are:
*
* * BARE - Create a bare repository with no working directory.
* * NO_REINIT - Return an EEXISTS error if the repo_path appears to
* already be an git repository.
* * NO_DOTGIT_DIR - Normally a "/.git/" will be appended to the repo
* path for non-bare repos (if it is not already there), but
* passing this flag prevents that behavior.
* * MKDIR - Make the repo_path (and workdir_path) as needed. Init is
* always willing to create the ".git" directory even without this
* flag. This flag tells init to create the trailing component of
* the repo and workdir paths as needed.
* * MKPATH - Recursively make all components of the repo and workdir
* paths as necessary.
* * EXTERNAL_TEMPLATE - libgit2 normally uses internal templates to
* initialize a new repo. This flags enables external templates,
* looking the "template_path" from the options if set, or the
* `init.templatedir` global config if not, or falling back on
* "/usr/share/git-core/templates" if it exists.
* * SHARED_UMASK - Use permissions reported by umask - this is default
* * SHARED_GROUP - Use "--shared=group" behavior, chmod'ing the new repo
* to be group writable and "g+sx" for sticky group assignment.
* * SHARED_ALL - Use "--shared=all" behavior, adding world readability.
* * SHARED_CUSTOM - Use the `mode` value from the init options struct.
*/
enum {
GIT_REPOSITORY_INIT_BARE = (1u << 0),
GIT_REPOSITORY_INIT_NO_REINIT = (1u << 1),
GIT_REPOSITORY_INIT_NO_DOTGIT_DIR = (1u << 2),
GIT_REPOSITORY_INIT_MKDIR = (1u << 3),
GIT_REPOSITORY_INIT_MKPATH = (1u << 4),
GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE = (1u << 5),
GIT_REPOSITORY_INIT_SHARED_UMASK = (0u << 6),
GIT_REPOSITORY_INIT_SHARED_GROUP = (1u << 6),
GIT_REPOSITORY_INIT_SHARED_ALL = (2u << 6),
GIT_REPOSITORY_INIT_SHARED_CUSTOM = (3u << 6),
};
/**
* Extended options structure for `git_repository_init_ext`.
*
* This contains extra options for `git_repository_init_ext` that enable
* additional initialization features. The fields are:
*
* * flags - Combination of GIT_REPOSITORY_INIT flags above.
* * mode - When GIT_REPOSITORY_INIT_SHARED_CUSTOM is set, this contains
* the mode bits that should be used for directories in the repo.
* * workdir_path - The path to the working dir or NULL for default (i.e.
* repo_path parent on non-bare repos). If a relative path, this
* will be evaluated relative to the repo_path. If this is not the
* "natural" working directory, a .git gitlink file will be created
* here linking to the repo_path.
* * description - If set, this will be used to initialize the "description"
* file in the repository, instead of using the template content.
* * template_path - When GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE is set,
* this contains the path to use for the template directory. If
* this is NULL, the config or default directory options will be
* used instead.
* * initial_head - The name of the head to point HEAD at. If NULL, then
* this will be treated as "master" and the HEAD ref will be set
* to "refs/heads/master". If this begins with "refs/" it will be
* used verbatim; otherwise "refs/heads/" will be prefixed.
* * origin_url - If this is non-NULL, then after the rest of the
* repository initialization is completed, an "origin" remote
* will be added pointing to this URL.
*/
typedef struct {
uint32_t flags;
uint32_t mode;
const char *workdir_path;
const char *description;
const char *template_path;
const char *initial_head;
const char *origin_url;
} git_repository_init_options;
/**
* Create a new Git repository in the given folder with extended controls.
*
* This will initialize a new git repository (creating the repo_path
* if requested by flags) and working directory as needed. It will
* auto-detect the case sensitivity of the file system and if the
* file system supports file mode bits correctly.
*
* @param repo_out Pointer to the repo which will be created or reinitialized.
* @param repo_path The path to the repository.
* @param opts Pointer to git_repository_init_options struct.
* @return 0 or an error code on failure.
*/
GIT_EXTERN(int) git_repository_init_ext(
git_repository **repo_out,
const char *repo_path,
git_repository_init_options *opts);
/**
* Retrieve and resolve the reference pointed at by HEAD.

10
src/fileops.c
View File

@ -239,6 +239,16 @@ void git_futils_mmap_free(git_map *out)
p_munmap(out);
}
int git_futils_mkdir_q(const char *path, const mode_t mode)
{
if (p_mkdir(path, mode) < 0 && errno != EEXIST) {
giterr_set(GITERR_OS, "Failed to create directory at '%s'", path);
return -1;
}
return 0;
}
int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode)
{
git_buf make_path = GIT_BUF_INIT;

5
src/fileops.h
View File

@ -47,6 +47,11 @@ extern int git_futils_creat_locked(const char *path, const mode_t mode);
*/
extern int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode);
/**
* Create a directory if it does not exist
*/
extern int git_futils_mkdir_q(const char *path, const mode_t mode);
/**
* Create a path recursively
*

58
src/repo_template.h Normal file
View File

@ -0,0 +1,58 @@
/*
* Copyright (C) 2012 the libgit2 contributors
*
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
#ifndef INCLUDE_repo_template_h__
#define INCLUDE_repo_template_h__
#define GIT_OBJECTS_INFO_DIR GIT_OBJECTS_DIR "info/"
#define GIT_OBJECTS_PACK_DIR GIT_OBJECTS_DIR "pack/"
#define GIT_HOOKS_DIR "hooks/"
#define GIT_HOOKS_DIR_MODE 0755
#define GIT_HOOKS_README_FILE GIT_HOOKS_DIR "README.sample"
#define GIT_HOOKS_README_MODE 0755
#define GIT_HOOKS_README_CONTENT \
"#!/bin/sh\n"\
"#\n"\
"# Place appropriately named executable hook scripts into this directory\n"\
"# to intercept various actions that git takes. See `git help hooks` for\n"\
"# more information.\n"
#define GIT_INFO_DIR "info/"
#define GIT_INFO_DIR_MODE 0755
#define GIT_INFO_EXCLUDE_FILE GIT_INFO_DIR "exclude"
#define GIT_INFO_EXCLUDE_MODE 0644
#define GIT_INFO_EXCLUDE_CONTENT \
"# File patterns to ignore; see `git help ignore` for more information.\n"\
"# Lines that start with '#' are comments.\n"
#define GIT_DESC_FILE "description"
#define GIT_DESC_MODE 0644
#define GIT_DESC_CONTENT \
"Unnamed repository; edit this file 'description' to name the repository.\n"
typedef struct {
const char *path;
mode_t mode;
const char *content;
} repo_template_item;
static repo_template_item repo_template[] = {
{ GIT_OBJECTS_INFO_DIR, GIT_OBJECT_DIR_MODE, NULL }, /* '/objects/info/' */
{ GIT_OBJECTS_PACK_DIR, GIT_OBJECT_DIR_MODE, NULL }, /* '/objects/pack/' */
{ GIT_REFS_HEADS_DIR, GIT_REFS_DIR_MODE, NULL }, /* '/refs/heads/' */
{ GIT_REFS_TAGS_DIR, GIT_REFS_DIR_MODE, NULL }, /* '/refs/tags/' */
{ GIT_HOOKS_DIR, GIT_HOOKS_DIR_MODE, NULL }, /* '/hooks/' */
{ GIT_INFO_DIR, GIT_INFO_DIR_MODE, NULL }, /* '/info/' */
{ GIT_DESC_FILE, GIT_DESC_MODE, GIT_DESC_CONTENT },
{ GIT_HOOKS_README_FILE, GIT_HOOKS_README_MODE, GIT_HOOKS_README_CONTENT },
{ GIT_INFO_EXCLUDE_FILE, GIT_INFO_EXCLUDE_MODE, GIT_INFO_EXCLUDE_CONTENT },
{ NULL, 0, NULL }
};
#endif

450
src/repository.c
View File

@ -18,9 +18,6 @@
#include "config.h"
#include "refs.h"
#define GIT_OBJECTS_INFO_DIR GIT_OBJECTS_DIR "info/"
#define GIT_OBJECTS_PACK_DIR GIT_OBJECTS_DIR "pack/"
#define GIT_FILE_CONTENT_PREFIX "gitdir:"
#define GIT_BRANCH_MASTER "master"
@ -238,16 +235,17 @@ static int read_gitfile(git_buf *path_out, const char *file_path)
git_buf_rtrim(&file);
if (file.size <= prefix_len ||
memcmp(file.ptr, GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
if (git_buf_len(&file) <= prefix_len ||
memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
{
giterr_set(GITERR_REPOSITORY, "The `.git` file at '%s' is malformed", file_path);
error = -1;
}
else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
const char *gitlink = ((const char *)file.ptr) + prefix_len;
const char *gitlink = git_buf_cstr(&file) + prefix_len;
while (*gitlink && git__isspace(*gitlink)) gitlink++;
error = git_path_prettify_dir(path_out, gitlink, path_out->ptr);
error = git_path_prettify_dir(
path_out, gitlink, git_buf_cstr(path_out));
}
git_buf_free(&file);
@ -359,9 +357,11 @@ int git_repository_open_ext(
git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT;
git_repository *repo;
*repo_ptr = NULL;
if (repo_ptr)
*repo_ptr = NULL;
if ((error = find_repo(&path, &parent, start_path, flags, ceiling_dirs)) < 0)
error = find_repo(&path, &parent, start_path, flags, ceiling_dirs);
if (error < 0 || !repo_ptr)
return error;
repo = repository_alloc();
@ -632,19 +632,35 @@ static int check_repositoryformatversion(git_config *config)
return 0;
}
static int repo_init_createhead(const char *git_dir)
static int repo_init_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;
if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 ||
git_filebuf_open(&ref, ref_path.ptr, 0) < 0 ||
git_filebuf_printf(&ref, "ref: refs/heads/master\n") < 0 ||
git_filebuf_open(&ref, ref_path.ptr, 0) < 0)
goto fail;
if (!ref_name)
ref_name = GIT_BRANCH_MASTER;
if (git__prefixcmp(ref_name, "refs/") == 0)
fmt = "ref: %s\n";
else
fmt = "ref: refs/heads/%s\n";
if (git_filebuf_printf(&ref, fmt, ref_name) < 0 ||
git_filebuf_commit(&ref, GIT_REFS_FILE_MODE) < 0)
return -1;
goto fail;
git_buf_free(&ref_path);
return 0;
fail:
git_buf_free(&ref_path);
git_filebuf_cleanup(&ref);
return -1;
}
static bool is_chmod_supported(const char *file_path)
@ -686,7 +702,8 @@ cleanup:
return _is_insensitive;
}
static int repo_init_config(const char *git_dir, bool is_bare, bool is_reinit)
static int repo_init_config(
const char *git_dir, git_repository_init_options *opts)
{
git_buf cfg_path = GIT_BUF_INIT;
git_config *config = NULL;
@ -706,58 +723,48 @@ static int repo_init_config(const char *git_dir, bool is_bare, bool is_reinit)
return -1;
}
if (is_reinit && check_repositoryformatversion(config) < 0) {
if ((opts->flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0 &&
check_repositoryformatversion(config) < 0)
{
git_buf_free(&cfg_path);
git_config_free(config);
return -1;
}
SET_REPO_CONFIG(bool, "core.bare", is_bare);
SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION);
SET_REPO_CONFIG(bool, "core.filemode", is_chmod_supported(git_buf_cstr(&cfg_path)));
if (!is_bare)
SET_REPO_CONFIG(
bool, "core.bare", (opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);
SET_REPO_CONFIG(
int32, "core.repositoryformatversion", GIT_REPO_VERSION);
SET_REPO_CONFIG(
bool, "core.filemode", is_chmod_supported(git_buf_cstr(&cfg_path)));
if (!(opts->flags & GIT_REPOSITORY_INIT_BARE))
SET_REPO_CONFIG(bool, "core.logallrefupdates", true);
if (!is_reinit && is_filesystem_case_insensitive(git_dir))
if (!(opts->flags & GIT_REPOSITORY_INIT__IS_REINIT) &&
is_filesystem_case_insensitive(git_dir))
SET_REPO_CONFIG(bool, "core.ignorecase", true);
/* TODO: what other defaults? */
if (opts->flags & GIT_REPOSITORY_INIT_SHARED_GROUP) {
SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
} else if (opts->flags & GIT_REPOSITORY_INIT_SHARED_ALL) {
SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
}
git_buf_free(&cfg_path);
git_config_free(config);
return 0;
}
#define GIT_HOOKS_DIR "hooks/"
#define GIT_HOOKS_DIR_MODE 0755
#define GIT_HOOKS_README_FILE GIT_HOOKS_DIR "README.sample"
#define GIT_HOOKS_README_MODE 0755
#define GIT_HOOKS_README_CONTENT \
"#!/bin/sh\n"\
"#\n"\
"# Place appropriately named executable hook scripts into this directory\n"\
"# to intercept various actions that git takes. See `git help hooks` for\n"\
"# more information.\n"
#define GIT_INFO_DIR "info/"
#define GIT_INFO_DIR_MODE 0755
#define GIT_INFO_EXCLUDE_FILE GIT_INFO_DIR "exclude"
#define GIT_INFO_EXCLUDE_MODE 0644
#define GIT_INFO_EXCLUDE_CONTENT \
"# File patterns to ignore; see `git help ignore` for more information.\n"\
"# Lines that start with '#' are comments.\n"
#define GIT_DESC_FILE "description"
#define GIT_DESC_MODE 0644
#define GIT_DESC_CONTENT "Unnamed repository; edit this file 'description' to name the repository.\n"
static int repo_write_template(
const char *git_dir,
bool allow_overwrite,
const char *file,
mode_t mode,
bool hidden,
const char *content)
{
git_buf path = GIT_BUF_INIT;
@ -781,6 +788,15 @@ static int repo_write_template(
else if (errno != EEXIST)
error = fd;
#ifdef GIT_WIN32
if (!error && hidden) {
if (p_hide_directory__w32(path.ptr) < 0)
error = -1;
}
#else
GIT_UNUSED(hidden);
#endif
git_buf_free(&path);
if (error)
@ -790,86 +806,287 @@ static int repo_write_template(
return error;
}
static int repo_init_structure(const char *git_dir, int is_bare)
static int repo_write_gitlink(
const char *in_dir, const char *to_repo)
{
int i;
struct { const char *dir; mode_t mode; } dirs[] = {
{ GIT_OBJECTS_INFO_DIR, GIT_OBJECT_DIR_MODE }, /* '/objects/info/' */
{ GIT_OBJECTS_PACK_DIR, GIT_OBJECT_DIR_MODE }, /* '/objects/pack/' */
{ GIT_REFS_HEADS_DIR, GIT_REFS_DIR_MODE }, /* '/refs/heads/' */
{ GIT_REFS_TAGS_DIR, GIT_REFS_DIR_MODE }, /* '/refs/tags/' */
{ GIT_HOOKS_DIR, GIT_HOOKS_DIR_MODE }, /* '/hooks/' */
{ GIT_INFO_DIR, GIT_INFO_DIR_MODE }, /* '/info/' */
{ NULL, 0 }
};
struct { const char *file; mode_t mode; const char *content; } tmpl[] = {
{ GIT_DESC_FILE, GIT_DESC_MODE, GIT_DESC_CONTENT },
{ GIT_HOOKS_README_FILE, GIT_HOOKS_README_MODE, GIT_HOOKS_README_CONTENT },
{ GIT_INFO_EXCLUDE_FILE, GIT_INFO_EXCLUDE_MODE, GIT_INFO_EXCLUDE_CONTENT },
{ NULL, 0, NULL }
};
int error;
git_buf buf = GIT_BUF_INIT;
struct stat st;
/* Make the base directory */
if (git_futils_mkdir_r(git_dir, NULL, is_bare ? GIT_BARE_DIR_MODE : GIT_DIR_MODE) < 0)
git_path_dirname_r(&buf, to_repo);
git_path_to_dir(&buf);
if (git_buf_oom(&buf))
return -1;
/* Hides the ".git" directory */
if (!is_bare) {
/* 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_buf_joinpath(&buf, in_dir, DOT_GIT)) < 0)
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);
error = GIT_EEXISTS;
goto cleanup;
}
git_buf_clear(&buf);
error = git_buf_printf(&buf, "%s %s", GIT_FILE_CONTENT_PREFIX, to_repo);
if (!error)
error = repo_write_template(in_dir, true, DOT_GIT, 0644, true, buf.ptr);
cleanup:
git_buf_free(&buf);
return error;
}
#include "repo_template.h"
static int repo_init_structure(
const char *repo_dir,
const char *work_dir,
git_repository_init_options *opts)
{
repo_template_item *tpl;
mode_t gid = 0;
/* Hide the ".git" directory */
if ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0) {
#ifdef GIT_WIN32
if (p_hide_directory__w32(git_dir) < 0) {
if (p_hide_directory__w32(repo_dir) < 0) {
giterr_set(GITERR_REPOSITORY,
"Failed to mark Git repository folder as hidden");
return -1;
}
#endif
}
/* Make subdirectories as needed */
for (i = 0; dirs[i].dir != NULL; ++i) {
if (git_futils_mkdir_r(dirs[i].dir, git_dir, dirs[i].mode) < 0)
/* Create .git gitlink if appropriate */
else if ((opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0) {
if (repo_write_gitlink(work_dir, repo_dir) < 0)
return -1;
}
/* Make template files as needed */
for (i = 0; tmpl[i].file != NULL; ++i) {
if (repo_write_template(
git_dir, false, tmpl[i].file, tmpl[i].mode, tmpl[i].content) < 0)
return -1;
if ((opts->flags & GIT_REPOSITORY_INIT_SHARED_GROUP) != 0 ||
(opts->flags & GIT_REPOSITORY_INIT_SHARED_ALL) != 0)
gid = S_ISGID;
/* TODO: honor GIT_REPOSITORY_INIT_USE_EXTERNAL_TEMPLATE if set */
/* Copy internal template as needed */
for (tpl = repo_template; tpl->path; ++tpl) {
if (!tpl->content) {
if (git_futils_mkdir_r(tpl->path, repo_dir, tpl->mode | gid) < 0)
return -1;
}
else {
const char *content = tpl->content;
if (opts->description && strcmp(tpl->path, GIT_DESC_FILE) == 0)
content = opts->description;
if (repo_write_template(
repo_dir, false, tpl->path, tpl->mode, false, content) < 0)
return -1;
}
}
return 0;
}
int git_repository_init(git_repository **repo_out, const char *path, unsigned is_bare)
static int repo_init_directories(
git_buf *repo_path,
git_buf *wd_path,
const char *given_repo,
git_repository_init_options *opts)
{
git_buf repository_path = GIT_BUF_INIT;
bool is_reinit;
int result = -1;
int error = 0;
bool add_dotgit, has_dotgit, natural_wd;
assert(repo_out && path);
/* set up repo path */
if (git_buf_joinpath(&repository_path, path, is_bare ? "" : GIT_DIR) < 0)
goto cleanup;
add_dotgit =
(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
(opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
is_reinit = git_path_isdir(repository_path.ptr) && valid_repository_path(&repository_path);
if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
return -1;
if (is_reinit) {
/* TODO: reinitialize the templates */
has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
if (has_dotgit)
opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;
if (repo_init_config(repository_path.ptr, is_bare, is_reinit) < 0)
goto cleanup;
/* set up workdir path */
} else if (repo_init_structure(repository_path.ptr, is_bare) < 0 ||
repo_init_config(repository_path.ptr, is_bare, is_reinit) < 0 ||
repo_init_createhead(repository_path.ptr) < 0) {
goto cleanup;
if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0) {
if (opts->workdir_path) {
if (git_path_root(opts->workdir_path) < 0) {
if (git_path_dirname_r(wd_path, repo_path->ptr) < 0 ||
git_buf_putc(wd_path, '/') < 0 ||
git_buf_puts(wd_path, opts->workdir_path) < 0)
return -1;
} else {
if (git_buf_sets(wd_path, opts->workdir_path) < 0)
return -1;
}
} else if (has_dotgit) {
if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
return -1;
} else {
giterr_set(GITERR_REPOSITORY, "Cannot pick working directory"
" for non-bare repository that isn't a '.git' directory");
return -1;
}
if (git_path_to_dir(wd_path) < 0)
return -1;
} else {
git_buf_clear(wd_path);
}
result = git_repository_open(repo_out, repository_path.ptr);
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;
/* pick mode */
if ((opts->flags & GIT_REPOSITORY_INIT_SHARED_CUSTOM) != 0)
/* leave mode as is */;
else if ((opts->flags & GIT_REPOSITORY_INIT_SHARED_GROUP) != 0)
opts->mode = 0775 | S_ISGID;
else if ((opts->flags & GIT_REPOSITORY_INIT_SHARED_ALL) != 0)
opts->mode = 0777 | S_ISGID;
else if ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0)
opts->mode = 0755;
else
opts->mode = 0755;
/* create directories as needed / requested */
if ((opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0) {
error = git_futils_mkdir_r(repo_path->ptr, NULL, opts->mode);
if (!error && !natural_wd && wd_path->size > 0)
error = git_futils_mkdir_r(wd_path->ptr, NULL, opts->mode);
}
else if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0) {
if (has_dotgit) {
git_buf p = GIT_BUF_INIT;
if ((error = git_path_dirname_r(&p, repo_path->ptr)) >= 0)
error = git_futils_mkdir_q(p.ptr, opts->mode);
git_buf_free(&p);
}
if (!error)
error = git_futils_mkdir_q(repo_path->ptr, opts->mode);
if (!error && !natural_wd && wd_path->size > 0)
error = git_futils_mkdir_q(wd_path->ptr, opts->mode);
}
else if (has_dotgit)
error = git_futils_mkdir_q(repo_path->ptr, opts->mode);
/* prettify both directories now that they are created */
if (!error) {
error = git_path_prettify_dir(repo_path, repo_path->ptr, NULL);
if (!error && wd_path->size > 0)
error = git_path_prettify_dir(wd_path, wd_path->ptr, NULL);
}
return error;
}
static int repo_init_create_origin(git_repository *repo, const char *url)
{
int error;
git_remote *remote;
if (!(error = git_remote_add(&remote, repo, "origin", url))) {
error = git_remote_save(remote);
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;
memset(&opts, 0, sizeof(opts));
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 **repo_out,
const char *given_repo,
git_repository_init_options *opts)
{
int error;
git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT;
assert(repo_out && given_repo && opts);
error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
if (error < 0)
goto cleanup;
if (valid_repository_path(&repo_path)) {
if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
giterr_set(GITERR_REPOSITORY,
"Attempt to reinitialize '%s'", given_repo);
error = GIT_EEXISTS;
goto cleanup;
}
opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;
error = repo_init_config(git_buf_cstr(&repo_path), opts);
/* TODO: reinitialize the templates */
}
else {
if (!(error = repo_init_structure(
git_buf_cstr(&repo_path), git_buf_cstr(&wd_path), opts)) &&
!(error = repo_init_config(git_buf_cstr(&repo_path), opts)))
error = repo_init_create_head(
git_buf_cstr(&repo_path), opts->initial_head);
}
if (error < 0)
goto cleanup;
error = git_repository_open(repo_out, git_buf_cstr(&repo_path));
if (!error && opts->origin_url)
error = repo_init_create_origin(*repo_out, opts->origin_url);
cleanup:
git_buf_free(&repository_path);
return result;
git_buf_free(&repo_path);
git_buf_free(&wd_path);
return error;
}
int git_repository_head_detached(git_repository *repo)
@ -965,43 +1182,6 @@ const char *git_repository_workdir(git_repository *repo)
return repo->workdir;
}
static int write_gitlink(
const char *in_dir, const char *to_repo)
{
int error;
git_buf buf = GIT_BUF_INIT;
struct stat st;
if (git_path_dirname_r(&buf, to_repo) < 0 ||
git_path_to_dir(&buf) < 0)
return -1;
/* don't write gitlink to natural workdir */
if (git__suffixcmp(to_repo, "/" DOT_GIT "/") == 0 &&
strcmp(in_dir, buf.ptr) == 0)
return GIT_PASSTHROUGH;
if (git_buf_joinpath(&buf, in_dir, DOT_GIT) < 0)
return -1;
if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) {
giterr_set(GITERR_REPOSITORY,
"Cannot overwrite gitlink file into path '%s'", in_dir);
return GIT_EEXISTS;
}
git_buf_clear(&buf);
if (git_buf_printf(&buf, "%s %s", GIT_FILE_CONTENT_PREFIX, to_repo) < 0)
return -1;
error = repo_write_template(in_dir, true, DOT_GIT, 0644, buf.ptr);
git_buf_free(&buf);
return error;
}
int git_repository_set_workdir(
git_repository *repo, const char *workdir, int update_gitlink)
{
@ -1022,7 +1202,7 @@ int git_repository_set_workdir(
if (git_repository_config__weakptr(&config, repo) < 0)
return -1;
error = write_gitlink(path.ptr, git_repository_path(repo));
error = repo_write_gitlink(path.ptr, git_repository_path(repo));
/* passthrough error means gitlink is unnecessary */
if (error == GIT_PASSTHROUGH)

12
src/repository.h
View File

@ -68,6 +68,14 @@ typedef enum {
GIT_EOL_DEFAULT = GIT_EOL_NATIVE
} git_cvar_value;
/* internal repository init flags */
enum {
GIT_REPOSITORY_INIT__HAS_DOTGIT = (1u << 16),
GIT_REPOSITORY_INIT__NATURAL_WD = (1u << 17),
GIT_REPOSITORY_INIT__IS_REINIT = (1u << 18),
};
/** Base git object for inheritance */
struct git_object {
git_cached_obj cached;
@ -75,6 +83,7 @@ struct git_object {
git_otype type;
};
/** Internal structure for repository object */
struct git_repository {
git_odb *_odb;
git_config *_config;
@ -94,8 +103,7 @@ struct git_repository {
git_cvar_value cvar_cache[GIT_CVAR_CACHE_MAX];
};
/* fully free the object; internal method, do not
* export */
/* fully free the object; internal method, DO NOT EXPORT */
void git_object__free(void *object);
GIT_INLINE(int) git_object__dup(git_object **dest, git_object *source)