diff options
| -rw-r--r-- | include/git2/repository.h | 135 | ||||
| -rw-r--r-- | src/fileops.c | 10 | ||||
| -rw-r--r-- | src/fileops.h | 5 | ||||
| -rw-r--r-- | src/repo_template.h | 58 | ||||
| -rw-r--r-- | src/repository.c | 450 | ||||
| -rw-r--r-- | src/repository.h | 12 |
6 files changed, 529 insertions, 141 deletions
diff --git a/include/git2/repository.h b/include/git2/repository.h index e727ff317..afef612c8 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -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. diff --git a/src/fileops.c b/src/fileops.c index 4de58b0cc..70c5c387c 100644 --- a/src/fileops.c +++ b/src/fileops.c @@ -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; diff --git a/src/fileops.h b/src/fileops.h index 594eacbd0..edfcb7dd0 100644 --- a/src/fileops.h +++ b/src/fileops.h @@ -48,6 +48,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 * * If a base parameter is being passed, it's expected to be valued with a path pointing to an already diff --git a/src/repo_template.h b/src/repo_template.h new file mode 100644 index 000000000..ae5a9690c --- /dev/null +++ b/src/repo_template.h @@ -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 diff --git a/src/repository.c b/src/repository.c index 6f1f4349b..994b13bd5 100644 --- a/src/repository.c +++ b/src/repository.c @@ -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 } - }; - - /* Make the base directory */ - if (git_futils_mkdir_r(git_dir, NULL, is_bare ? GIT_BARE_DIR_MODE : GIT_DIR_MODE) < 0) + int error; + git_buf buf = GIT_BUF_INIT; + struct stat st; + + 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; + + if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0) + return -1; - is_reinit = git_path_isdir(repository_path.ptr) && valid_repository_path(&repository_path); + 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 ((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 (is_reinit) { - /* TODO: reinitialize the templates */ + if (git_path_to_dir(wd_path) < 0) + return -1; + } else { + git_buf_clear(wd_path); + } - if (repo_init_config(repository_path.ptr, is_bare, is_reinit) < 0) - goto cleanup; + 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 */ - } 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) { + 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)); - result = git_repository_open(repo_out, repository_path.ptr); + 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) diff --git a/src/repository.h b/src/repository.h index 4e03e632b..dd42c63e1 100644 --- a/src/repository.h +++ b/src/repository.h @@ -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) |