diff --git a/include/git2/repository.h b/include/git2/repository.h index 34dd90444..d760c23b7 100644 --- a/include/git2/repository.h +++ b/include/git2/repository.h @@ -70,6 +70,20 @@ GIT_EXTERN(int) git_repository_discover( int across_fs, const char *ceiling_dirs); +enum { + GIT_REPOSITORY_OPEN_NO_SEARCH = (1 << 0), + GIT_REPOSITORY_OPEN_CROSS_FS = (1 << 1), +}; + +/** + * Find and open a repository with extended controls. + */ +GIT_EXTERN(int) git_repository_open_ext( + git_repository **repo, + const char *start_path, + uint32_t flags, + const char *ceiling_dirs); + /** * Free a previously allocated repository * diff --git a/src/attr.c b/src/attr.c index 5cf96acf7..c02289363 100644 --- a/src/attr.c +++ b/src/attr.c @@ -347,6 +347,7 @@ static int collect_attr_files( int git_attr_cache__init(git_repository *repo) { + int ret; git_attr_cache *cache = git_repository_attr_cache(repo); git_config *cfg; @@ -354,17 +355,18 @@ int git_attr_cache__init(git_repository *repo) return 0; /* cache config settings for attributes and ignores */ - if (git_repository_config(&cfg, repo) < 0) + if (git_repository_config__weakptr(&cfg, repo) < 0) return -1; - if (git_config_get_string(cfg, GIT_ATTR_CONFIG, &cache->cfg_attr_file)) { - giterr_clear(); - cache->cfg_attr_file = NULL; - } - if (git_config_get_string(cfg, GIT_IGNORE_CONFIG, &cache->cfg_excl_file)) { - giterr_clear(); - cache->cfg_excl_file = NULL; - } - git_config_free(cfg); + + ret = git_config_get_string(cfg, GIT_ATTR_CONFIG, &cache->cfg_attr_file); + if (ret < 0 && ret != GIT_ENOTFOUND) + return ret; + + ret = git_config_get_string(cfg, GIT_IGNORE_CONFIG, &cache->cfg_excl_file); + if (ret < 0 && ret != GIT_ENOTFOUND) + return ret; + + giterr_clear(); /* allocate hashtable for attribute and ignore file contents */ if (cache->files == NULL) { diff --git a/src/config.c b/src/config.c index 250bfa652..f5cfa9ec0 100644 --- a/src/config.c +++ b/src/config.c @@ -327,11 +327,11 @@ int git_config_lookup_map_value( int git_config_get_mapped(git_config *cfg, const char *name, git_cvar_map *maps, size_t map_n, int *out) { const char *value; - int error; + int ret; - error = git_config_get_string(cfg, name, &value); - if (error < 0) - return error; + ret = git_config_get_string(cfg, name, &value); + if (ret < 0) + return ret; if (!git_config_lookup_map_value(maps, map_n, value, out)) return 0; @@ -371,7 +371,7 @@ int git_config_get_int32(git_config *cfg, const char *name, int32_t *out) giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a 32-bit integer", value); return -1; } - + return 0; } @@ -399,26 +399,17 @@ int git_config_get_bool(git_config *cfg, const char *name, int *out) int git_config_get_string(git_config *cfg, const char *name, const char **out) { file_internal *internal; - git_config_file *file; - int ret = GIT_ENOTFOUND; unsigned int i; assert(cfg->files.length); - for (i = 0; i < cfg->files.length; ++i) { - internal = git_vector_get(&cfg->files, i); - file = internal->file; + *out = NULL; - ret = file->get(file, name, out); - if (ret == 0) - return 0; - - /* File backend doesn't set error message on variable - * not found */ - if (ret == GIT_ENOTFOUND) - continue; - - return ret; + git_vector_foreach(&cfg->files, i, internal) { + git_config_file *file = internal->file; + int ret = file->get(file, name, out); + if (ret != GIT_ENOTFOUND) + return ret; } giterr_set(GITERR_CONFIG, "Config variable '%s' not found", name); diff --git a/src/diff.c b/src/diff.c index 54e8dd166..fa841f717 100644 --- a/src/diff.c +++ b/src/diff.c @@ -253,7 +253,7 @@ static git_diff_list *git_diff_list_alloc( diff->repo = repo; /* load config values that affect diff behavior */ - if (git_repository_config(&cfg, repo) < 0) + if (git_repository_config__weakptr(&cfg, repo) < 0) goto fail; if (config_bool(cfg, "core.symlinks", 1)) diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_HAS_SYMLINKS; @@ -264,7 +264,6 @@ static git_diff_list *git_diff_list_alloc( if (config_bool(cfg, "core.trustctime", 1)) diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_CTIME; /* Don't set GIT_DIFFCAPS_USE_DEV - compile time option in core git */ - git_config_free(cfg); if (opts == NULL) return diff; diff --git a/src/errors.c b/src/errors.c index 70aa641c4..aad6c4482 100644 --- a/src/errors.c +++ b/src/errors.c @@ -92,8 +92,12 @@ const char *git_lasterror(void) { char *last_error = GIT_GLOBAL->error.last; - if (!last_error[0]) + if (!last_error[0]) { + const git_error *err = git_error_last(); + if (err != NULL) + return err->message; return NULL; + } return last_error; } diff --git a/src/path.c b/src/path.c index 31d2e72f9..3c1a723ea 100644 --- a/src/path.c +++ b/src/path.c @@ -172,20 +172,22 @@ int git_path_root(const char *path) if (isalpha(path[0]) && (path[1] == ':')) offset += 2; - /* Are we dealing with a network path? */ - else if (path[0] == '/' && path[1] == '/') { + /* Are we dealing with a windows network path? */ + else if ((path[0] == '/' && path[1] == '/') || + (path[0] == '\\' && path[1] == '\\')) + { offset += 2; - + /* Skip the computer name segment */ - while (*(path + offset) && *(path + offset) != '/') + while (path[offset] && path[offset] != '/' && path[offset] != '\\') offset++; } #endif - if (*(path + offset) == '/') + if (path[offset] == '/' || path[offset] == '\\') return offset; - return -1; /* Not a real error. Rather a signal than the path is not rooted */ + return -1; /* Not a real error - signals that path is not rooted */ } int git_path_prettify(git_buf *path_out, const char *path, const char *base) @@ -193,26 +195,21 @@ int git_path_prettify(git_buf *path_out, const char *path, const char *base) char buf[GIT_PATH_MAX]; assert(path && path_out); - git_buf_clear(path_out); /* construct path if needed */ if (base != NULL && git_path_root(path) < 0) { if (git_buf_joinpath(path_out, base, path) < 0) return -1; - path = path_out->ptr; } if (p_realpath(path, buf) == NULL) { - giterr_set(GITERR_OS, "Failed to resolve path '%s': %s", - path, strerror(errno)); + giterr_set(GITERR_OS, "Failed to resolve path '%s'", path); + git_buf_clear(path_out); return (errno == ENOENT) ? GIT_ENOTFOUND : -1; } - if (git_buf_sets(path_out, buf) < 0) - return -1; - - return 0; + return git_buf_sets(path_out, buf); } int git_path_prettify_dir(git_buf *path_out, const char *path, const char *base) diff --git a/src/repository.c b/src/repository.c index ce313280e..413bb17ae 100644 --- a/src/repository.c +++ b/src/repository.c @@ -5,6 +5,7 @@ * a Linking Exception. For full terms see the included COPYING file. */ #include +#include #include "git2/object.h" @@ -20,7 +21,7 @@ #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_FILE_CONTENT_PREFIX "gitdir:" #define GIT_BRANCH_MASTER "master" @@ -132,76 +133,294 @@ static int load_config_data(git_repository *repo) return 0; } -static int load_workdir(git_repository *repo) +static int load_workdir(git_repository *repo, git_buf *parent_path) { - git_buf workdir_buf = GIT_BUF_INIT; + int error; + git_config *config; + const char *worktree; + git_buf worktree_buf = GIT_BUF_INIT; if (repo->is_bare) return 0; - git_path_dirname_r(&workdir_buf, repo->path_repository); - git_path_to_dir(&workdir_buf); - - if (git_buf_oom(&workdir_buf)) + if (git_repository_config__weakptr(&config, repo) < 0) return -1; - repo->workdir = git_buf_detach(&workdir_buf); - git_buf_free(&workdir_buf); + error = git_config_get_string(config, "core.worktree", &worktree); + if (!error && worktree != NULL) + repo->workdir = git__strdup(worktree); + else if (error != GIT_ENOTFOUND) + return error; + else { + giterr_clear(); + if (parent_path && git_path_isdir(parent_path->ptr)) + repo->workdir = git_buf_detach(parent_path); + else { + git_path_dirname_r(&worktree_buf, repo->path_repository); + git_path_to_dir(&worktree_buf); + repo->workdir = git_buf_detach(&worktree_buf); + } + } + + GITERR_CHECK_ALLOC(repo->workdir); + + return 0; +} + +/* + * This function returns furthest offset into path where a ceiling dir + * is found, so we can stop processing the path at that point. + * + * Note: converting this to use git_bufs instead of GIT_PATH_MAX buffers on + * the stack could remove directories name limits, but at the cost of doing + * repeated malloc/frees inside the loop below, so let's not do it now. + */ +static int find_ceiling_dir_offset( + const char *path, + const char *ceiling_directories) +{ + char buf[GIT_PATH_MAX + 1]; + char buf2[GIT_PATH_MAX + 1]; + const char *ceil, *sep; + int len, max_len = -1; + int min_len; + + assert(path); + + min_len = git_path_root(path) + 1; + + if (ceiling_directories == NULL || min_len == 0) + return min_len; + + for (sep = ceil = ceiling_directories; *sep; ceil = sep + 1) { + for (sep = ceil; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++); + len = sep - ceil; + + if (len == 0 || len >= (int)sizeof(buf) || git_path_root(ceil) == -1) + continue; + + strncpy(buf, ceil, len); + buf[len] = '\0'; + + if (p_realpath(buf, buf2) == NULL) + continue; + + len = strlen(buf2); + if (len > 0 && buf2[len-1] == '/') + buf[--len] = '\0'; + + if (!strncmp(path, buf2, len) && + path[len] == '/' && + len > max_len) + { + max_len = len; + } + } + + return max_len <= min_len ? min_len : max_len; +} + +/* + * Read the contents of `file_path` and set `path_out` to the repo dir that + * it points to. Before calling, set `path_out` to the base directory that + * should be used if the contents of `file_path` are a relative path. + */ +static int read_gitfile(git_buf *path_out, const char *file_path) +{ + int error = 0; + git_buf file = GIT_BUF_INIT; + size_t prefix_len = strlen(GIT_FILE_CONTENT_PREFIX); + + assert(path_out && file_path); + + if (git_futils_readbuffer(&file, file_path) < 0) + return -1; + + git_buf_rtrim(&file); + + if (file.size <= prefix_len || + memcmp(file.ptr, 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; + while (*gitlink && isspace(*gitlink)) gitlink++; + error = git_path_prettify_dir(path_out, gitlink, path_out->ptr); + } + + git_buf_free(&file); + return error; +} + +static int find_repo( + git_buf *repo_path, + git_buf *parent_path, + const char *start_path, + uint32_t flags, + const char *ceiling_dirs) +{ + int error; + git_buf path = GIT_BUF_INIT; + struct stat st; + dev_t initial_device = 0; + bool try_with_dot_git = false; + int ceiling_offset; + + git_buf_free(repo_path); + + if ((error = git_path_prettify_dir(&path, start_path, NULL)) < 0) + return error; + + ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs); + + if ((error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0) + return error; + + while (!error && !repo_path->size) { + if (p_stat(path.ptr, &st) == 0) { + /* check that we have not crossed device boundaries */ + if (initial_device == 0) + initial_device = st.st_dev; + else if (st.st_dev != initial_device && + (flags & GIT_REPOSITORY_OPEN_CROSS_FS) == 0) + 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); + break; + } + } + else if (S_ISREG(st.st_mode)) { + git_buf repo_link = GIT_BUF_INIT; + + if (!(error = read_gitfile(&repo_link, path.ptr))) { + if (valid_repository_path(&repo_link)) + git_buf_swap(repo_path, &repo_link); + break; + } + git_buf_free(&repo_link); + } + } + + /* move up one directory level */ + if (git_path_dirname_r(&path, path.ptr) < 0) { + error = -1; + break; + } + + if (try_with_dot_git) { + /* if we tried original dir with and without .git AND either hit + * directory ceiling or NO_SEARCH was requested, then be done. + */ + if (path.ptr[ceiling_offset] == '\0' || + (flags & GIT_REPOSITORY_OPEN_NO_SEARCH) != 0) + break; + /* otherwise look first for .git item */ + error = git_buf_joinpath(&path, path.ptr, DOT_GIT); + } + try_with_dot_git = !try_with_dot_git; + } + + if (!error && parent_path != NULL) { + if (!repo_path->size) + 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; + } + + git_buf_free(&path); + + if (!repo_path->size && !error) { + giterr_set(GITERR_REPOSITORY, + "Could not find repository from '%s'", start_path); + error = GIT_ENOTFOUND; + } + + return error; +} + +int git_repository_open_ext( + git_repository **repo_ptr, + const char *start_path, + uint32_t flags, + const char *ceiling_dirs) +{ + int error; + git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT; + git_repository *repo; + + *repo_ptr = NULL; + + if ((error = find_repo(&path, &parent, start_path, flags, ceiling_dirs)) < 0) + return error; + + repo = repository_alloc(); + GITERR_CHECK_ALLOC(repo); + + repo->path_repository = git_buf_detach(&path); + GITERR_CHECK_ALLOC(repo->path_repository); + + if ((error = load_config_data(repo)) < 0 || + (error = load_workdir(repo, &parent)) < 0) + { + git_repository_free(repo); + return error; + } + + *repo_ptr = repo; return 0; } int git_repository_open(git_repository **repo_out, const char *path) { - git_buf path_buf = GIT_BUF_INIT; - git_repository *repo = NULL; - int res; + return git_repository_open_ext( + repo_out, path, GIT_REPOSITORY_OPEN_NO_SEARCH, NULL); +} - res = git_path_prettify_dir(&path_buf, path, NULL); - if (res < 0) - return res; +int git_repository_discover( + char *repository_path, + size_t size, + const char *start_path, + int across_fs, + const char *ceiling_dirs) +{ + git_buf path = GIT_BUF_INIT; + uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0; - /** - * Check if the path we've been given is actually the path - * of the working dir, by testing if it contains a `.git` - * folder inside of it. - */ - if (git_path_contains_dir(&path_buf, GIT_DIR) == true) - git_buf_joinpath(&path_buf, path_buf.ptr, GIT_DIR); + assert(start_path && repository_path && size > 0); - if (valid_repository_path(&path_buf) == false) { + *repository_path = '\0'; + + if (find_repo(&path, NULL, start_path, flags, ceiling_dirs) < 0) + return -1; + + if (size < (size_t)(path.size + 1)) { giterr_set(GITERR_REPOSITORY, - "The given path (%s) is not a valid Git repository", git_buf_cstr(&path_buf)); - git_buf_free(&path_buf); - return GIT_ENOTFOUND; + "The given buffer is too long to store the discovered path"); + git_buf_free(&path); + return -1; } - repo = repository_alloc(); - GITERR_CHECK_ALLOC(repo); - - repo->path_repository = git_buf_detach(&path_buf); - GITERR_CHECK_ALLOC(repo->path_repository); - - if (load_config_data(repo) < 0) - goto cleanup; - - if (load_workdir(repo) < 0) - goto cleanup; - - *repo_out = repo; + /* success: we discovered a repository */ + git_buf_copy_cstr(repository_path, size, &path); + git_buf_free(&path); return 0; - - cleanup: - git_repository_free(repo); - git_buf_free(&path_buf); - return -1; } static int load_config( - git_config **out, - git_repository *repo, - const char *global_config_path, - const char *system_config_path) + git_config **out, + git_repository *repo, + const char *global_config_path, + const char *system_config_path) { git_buf config_path = GIT_BUF_INIT; git_config *cfg = NULL; @@ -375,240 +594,6 @@ void git_repository_set_index(git_repository *repo, git_index *index) GIT_REFCOUNT_OWN(repo->_index, repo); } - -static int retrieve_device(dev_t *device_out, const char *path) -{ - int error; - struct stat path_info; - - assert(device_out); - - if ((error = git_path_lstat(path, &path_info)) == 0) - *device_out = path_info.st_dev; - - return error; -} - -/* - * This function returns furthest offset into path where a ceiling dir - * is found, so we can stop processing the path at that point. - * - * Note: converting this to use git_bufs instead of GIT_PATH_MAX buffers on - * the stack could remove directories name limits, but at the cost of doing - * repeated malloc/frees inside the loop below, so let's not do it now. - */ -static int retrieve_ceiling_directories_offset( - const char *path, - const char *ceiling_directories) -{ - char buf[GIT_PATH_MAX + 1]; - char buf2[GIT_PATH_MAX + 1]; - const char *ceil, *sep; - int len, max_len = -1; - int min_len; - - assert(path); - - min_len = git_path_root(path) + 1; - - if (ceiling_directories == NULL || min_len == 0) - return min_len; - - for (sep = ceil = ceiling_directories; *sep; ceil = sep + 1) { - for (sep = ceil; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++); - len = sep - ceil; - - if (len == 0 || len >= (int)sizeof(buf) || git_path_root(ceil) == -1) - continue; - - strncpy(buf, ceil, len); - buf[len] = '\0'; - - if (p_realpath(buf, buf2) == NULL) - continue; - - len = strlen(buf2); - if (len > 0 && buf2[len-1] == '/') - buf[--len] = '\0'; - - if (!strncmp(path, buf2, len) && - path[len] == '/' && - len > max_len) - { - max_len = len; - } - } - - return max_len <= min_len ? min_len : max_len; -} - -/* - * Read the contents of `file_path` and set `path_out` to the repo dir that - * it points to. Before calling, set `path_out` to the base directory that - * should be used if the contents of `file_path` are a relative path. - */ -static int read_gitfile(git_buf *path_out, const char *file_path, const char *base_path) -{ - git_buf file = GIT_BUF_INIT; - - assert(path_out && file_path); - - if (git_futils_readbuffer(&file, file_path) < 0) - return -1; - - git_buf_rtrim(&file); - - if (git__prefixcmp((char *)file.ptr, GIT_FILE_CONTENT_PREFIX) != 0 || - strlen(GIT_FILE_CONTENT_PREFIX) == file.size) { - git_buf_free(&file); - giterr_set(GITERR_REPOSITORY, "The `.git` file at '%s' is corrupted", file_path); - return -1; - } - - if (git_path_prettify_dir(path_out, - ((char *)file.ptr) + strlen(GIT_FILE_CONTENT_PREFIX), base_path) < 0) { - git_buf_free(&file); - giterr_set(GITERR_REPOSITORY, - "The `.git` file at '%s' points to an invalid path.", file_path); - return -1; - } - - git_buf_free(&file); - return 0; -} - -int git_repository_discover( - char *repository_path, - size_t size, - const char *start_path, - int across_fs, - const char *ceiling_dirs) -{ - int res, ceiling_offset; - git_buf bare_path = GIT_BUF_INIT; - git_buf normal_path = GIT_BUF_INIT; - git_buf *found_path = NULL; - dev_t current_device = 0; - - assert(start_path && repository_path); - - *repository_path = '\0'; - - res = git_path_prettify_dir(&bare_path, start_path, NULL); - if (res < 0) - return res; - - if (!across_fs) { - if (retrieve_device(¤t_device, bare_path.ptr) < 0) - goto on_error; - } - - ceiling_offset = retrieve_ceiling_directories_offset(bare_path.ptr, ceiling_dirs); - - while(1) { - if (git_buf_joinpath(&normal_path, bare_path.ptr, DOT_GIT) < 0) - goto on_error; - - /** - * If the `.git` file is regular instead of - * a directory, it should contain the path of the actual git repository - */ - if (git_path_isfile(normal_path.ptr) == true) { - git_buf gitfile_path = GIT_BUF_INIT; - - if (read_gitfile(&gitfile_path, normal_path.ptr, bare_path.ptr) < 0) { - git_buf_free(&gitfile_path); - goto on_error; - } - - if (valid_repository_path(&gitfile_path) == false) { - git_buf_free(&gitfile_path); - giterr_set(GITERR_REPOSITORY, - "The `.git` file found at '%s' points to an invalid git folder", normal_path.ptr); - goto on_error; - } - - git_buf_swap(&normal_path, &gitfile_path); - found_path = &normal_path; - - git_buf_free(&gitfile_path); - break; - } - - /** - * If the `.git` file is a folder, we check inside of it - */ - if (git_path_isdir(normal_path.ptr) == true) { - if (valid_repository_path(&normal_path) == true) { - found_path = &normal_path; - break; - } - } - - /** - * Otherwise, the repository may be bare, let's check - * the root anyway - */ - if (valid_repository_path(&bare_path) == true) { - found_path = &bare_path; - break; - } - - /** - * If we didn't find it, walk up the tree - */ - if (git_path_dirname_r(&normal_path, bare_path.ptr) < 0) - goto on_error; - - git_buf_swap(&bare_path, &normal_path); - - if (!across_fs) { - dev_t new_device; - if (retrieve_device(&new_device, bare_path.ptr) < 0) - goto on_error; - - if (current_device != new_device) - goto on_not_found; - - current_device = new_device; - } - - /* nothing has been found, lets try the parent directory - * but stop if we hit one of the ceiling directories - */ - if (bare_path.ptr[ceiling_offset] == '\0') - goto on_not_found; - } - - assert(found_path); - - if (git_path_to_dir(found_path) < 0) - goto on_error; - - if (size < (size_t)(found_path->size + 1)) { - giterr_set(GITERR_REPOSITORY, - "The given buffer is too long to store the discovered path"); - goto on_error; - } - - /* success: we discovered a repository */ - git_buf_copy_cstr(repository_path, size, found_path); - - git_buf_free(&bare_path); - git_buf_free(&normal_path); - return 0; - -on_error: /* unrecoverable error */ - git_buf_free(&bare_path); - git_buf_free(&normal_path); - return -1; - -on_not_found: /* failed to discover the repository */ - git_buf_free(&bare_path); - git_buf_free(&normal_path); - return GIT_ENOTFOUND; -} - static int check_repositoryformatversion(git_repository *repo) { git_config *config; diff --git a/tests-clar/clar_helpers.c b/tests-clar/clar_helpers.c index 22db56f0c..001045360 100644 --- a/tests-clar/clar_helpers.c +++ b/tests-clar/clar_helpers.c @@ -28,9 +28,9 @@ void cl_git_mkfile(const char *filename, const char *content) cl_must_pass(p_close(fd)); } -void cl_git_append2file(const char *filename, const char *new_content) +void cl_git_write2file(const char *filename, const char *new_content, int flags) { - int fd = p_open(filename, O_WRONLY | O_APPEND | O_CREAT); + int fd = p_open(filename, flags); cl_assert(fd != 0); if (!new_content) new_content = "\n"; @@ -39,6 +39,16 @@ void cl_git_append2file(const char *filename, const char *new_content) cl_must_pass(p_chmod(filename, 0644)); } +void cl_git_append2file(const char *filename, const char *new_content) +{ + cl_git_write2file(filename, new_content, O_WRONLY | O_APPEND | O_CREAT); +} + +void cl_git_rewritefile(const char *filename, const char *new_content) +{ + cl_git_write2file(filename, new_content, O_WRONLY | O_CREAT | O_TRUNC); +} + static const char *_cl_sandbox = NULL; static git_repository *_cl_repo = NULL; @@ -52,11 +62,12 @@ git_repository *cl_git_sandbox_init(const char *sandbox) p_chdir(sandbox); - /* Rename `sandbox/.gitted` to `sandbox/.git` which must be done since - * we cannot store a folder named `.git` inside the fixtures folder of - * our libgit2 repo. + /* If this is not a bare repo, then rename `sandbox/.gitted` to + * `sandbox/.git` which must be done since we cannot store a folder + * named `.git` inside the fixtures folder of our libgit2 repo. */ - cl_git_pass(p_rename(".gitted", ".git")); + if (p_access(".gitted", F_OK) == 0) + cl_git_pass(p_rename(".gitted", ".git")); /* If we have `gitattributes`, rename to `.gitattributes`. This may * be necessary if we don't want the attributes to be applied in the diff --git a/tests-clar/clar_libgit2.h b/tests-clar/clar_libgit2.h index 5c034a385..bb2feee6a 100644 --- a/tests-clar/clar_libgit2.h +++ b/tests-clar/clar_libgit2.h @@ -57,6 +57,8 @@ GIT_INLINE(void) cl_assert_strequal_internal( /* Write the contents of a buffer to disk */ void cl_git_mkfile(const char *filename, const char *content); void cl_git_append2file(const char *filename, const char *new_content); +void cl_git_rewritefile(const char *filename, const char *new_content); +void cl_git_write2file(const char *filename, const char *new_content, int mode); /* Git sandbox setup helpers */ diff --git a/tests-clar/repo/open.c b/tests-clar/repo/open.c index c3a7dadbd..28bae40fa 100644 --- a/tests-clar/repo/open.c +++ b/tests-clar/repo/open.c @@ -1,25 +1,27 @@ #include "clar_libgit2.h" -#include "posix.h" - -static git_repository *repo; +#include "fileops.h" void test_repo_open__cleanup(void) { - git_repository_free(repo); + cl_git_sandbox_cleanup(); + + if (git_path_isdir("alternate")) + git_futils_rmdir_r("alternate", 1); } void test_repo_open__bare_empty_repo(void) { - cl_git_pass(git_repository_open(&repo, cl_fixture("empty_bare.git"))); + git_repository *repo = cl_git_sandbox_init("empty_bare.git"); cl_assert(git_repository_path(repo) != NULL); cl_assert(git__suffixcmp(git_repository_path(repo), "/") == 0); - cl_assert(git_repository_workdir(repo) == NULL); } void test_repo_open__standard_empty_repo_through_gitdir(void) { + git_repository *repo; + cl_git_pass(git_repository_open(&repo, cl_fixture("empty_standard_repo/.gitted"))); cl_assert(git_repository_path(repo) != NULL); @@ -27,20 +29,246 @@ void test_repo_open__standard_empty_repo_through_gitdir(void) cl_assert(git_repository_workdir(repo) != NULL); cl_assert(git__suffixcmp(git_repository_workdir(repo), "/") == 0); + + git_repository_free(repo); } void test_repo_open__standard_empty_repo_through_workdir(void) { - cl_fixture_sandbox("empty_standard_repo"); - cl_git_pass(p_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git")); - - cl_git_pass(git_repository_open(&repo, "empty_standard_repo")); + git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); cl_assert(git_repository_path(repo) != NULL); cl_assert(git__suffixcmp(git_repository_path(repo), "/") == 0); cl_assert(git_repository_workdir(repo) != NULL); cl_assert(git__suffixcmp(git_repository_workdir(repo), "/") == 0); - - cl_fixture_cleanup("empty_standard_repo"); +} + + +void test_repo_open__open_with_discover(void) +{ + static const char *variants[] = { + "attr", "attr/", "attr/.git", "attr/.git/", + "attr/sub", "attr/sub/", "attr/sub/sub", "attr/sub/sub/", + NULL + }; + git_repository *repo; + const char **scan; + + cl_fixture_sandbox("attr"); + cl_git_pass(p_rename("attr/.gitted", "attr/.git")); + + for (scan = variants; *scan != NULL; scan++) { + cl_git_pass(git_repository_open_ext(&repo, *scan, 0, NULL)); + cl_assert(git__suffixcmp(git_repository_path(repo), "attr/.git/") == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo), "attr/") == 0); + git_repository_free(repo); + } + + cl_fixture_cleanup("attr"); +} + +void test_repo_open__gitlinked(void) +{ + /* need to have both repo dir and workdir set up correctly */ + git_repository *repo = cl_git_sandbox_init("empty_standard_repo"); + git_repository *repo2; + + cl_must_pass(p_mkdir("alternate", 0777)); + cl_git_mkfile("alternate/.git", "gitdir: ../empty_standard_repo/.git"); + + cl_git_pass(git_repository_open(&repo2, "alternate")); + + cl_assert(git_repository_path(repo2) != NULL); + cl_assert_(git__suffixcmp(git_repository_path(repo2), "empty_standard_repo/.git/") == 0, git_repository_path(repo2)); + cl_assert_equal_s(git_repository_path(repo), git_repository_path(repo2)); + + cl_assert(git_repository_workdir(repo2) != NULL); + cl_assert_(git__suffixcmp(git_repository_workdir(repo2), "alternate/") == 0, git_repository_workdir(repo2)); + + git_repository_free(repo2); +} + +void test_repo_open__from_git_new_workdir(void) +{ + /* The git-new-workdir script that ships with git sets up a bunch of + * symlinks to create a second workdir that shares the object db with + * another checkout. Libgit2 can open a repo that has been configured + * this way. + */ + cl_git_sandbox_init("empty_standard_repo"); + +#ifndef GIT_WIN32 + git_repository *repo2; + git_buf link_tgt = GIT_BUF_INIT, link = GIT_BUF_INIT, body = GIT_BUF_INIT; + const char **scan; + int link_fd; + static const char *links[] = { + "config", "refs", "logs/refs", "objects", "info", "hooks", + "packed-refs", "remotes", "rr-cache", "svn", NULL + }; + static const char *copies[] = { + "HEAD", NULL + }; + + cl_git_pass(p_mkdir("alternate", 0777)); + cl_git_pass(p_mkdir("alternate/.git", 0777)); + + for (scan = links; *scan != NULL; scan++) { + git_buf_joinpath(&link_tgt, "empty_standard_repo/.git", *scan); + if (git_path_exists(link_tgt.ptr)) { + git_buf_joinpath(&link_tgt, "../../empty_standard_repo/.git", *scan); + git_buf_joinpath(&link, "alternate/.git", *scan); + if (strchr(*scan, '/')) + git_futils_mkpath2file(link.ptr, 0777); + cl_assert_(symlink(link_tgt.ptr, link.ptr) == 0, strerror(errno)); + } + } + for (scan = copies; *scan != NULL; scan++) { + git_buf_joinpath(&link_tgt, "empty_standard_repo/.git", *scan); + if (git_path_exists(link_tgt.ptr)) { + git_buf_joinpath(&link, "alternate/.git", *scan); + cl_git_pass(git_futils_readbuffer(&body, link_tgt.ptr)); + + cl_assert((link_fd = git_futils_creat_withpath(link.ptr, 0777, 0666)) >= 0); + cl_must_pass(p_write(link_fd, body.ptr, body.size)); + p_close(link_fd); + } + } + + git_buf_free(&link_tgt); + git_buf_free(&link); + git_buf_free(&body); + + + cl_git_pass(git_repository_open(&repo2, "alternate")); + + cl_assert(git_repository_path(repo2) != NULL); + cl_assert_(git__suffixcmp(git_repository_path(repo2), "alternate/.git/") == 0, git_repository_path(repo2)); + + cl_assert(git_repository_workdir(repo2) != NULL); + cl_assert_(git__suffixcmp(git_repository_workdir(repo2), "alternate/") == 0, git_repository_workdir(repo2)); + + git_repository_free(repo2); +#endif +} + +void test_repo_open__failures(void) +{ + git_repository *base, *repo; + git_buf ceiling = GIT_BUF_INIT; + + base = cl_git_sandbox_init("attr"); + cl_git_pass(git_buf_sets(&ceiling, git_repository_workdir(base))); + + /* fail with no searching */ + cl_git_fail(git_repository_open(&repo, "attr/sub")); + cl_git_fail(git_repository_open_ext( + &repo, "attr/sub", GIT_REPOSITORY_OPEN_NO_SEARCH, NULL)); + + /* fail with ceiling too low */ + cl_git_pass(git_buf_joinpath(&ceiling, ceiling.ptr, "sub")); + cl_git_fail(git_repository_open_ext(&repo, "attr/sub", 0, ceiling.ptr)); + + /* fail with no repo */ + cl_git_pass(p_mkdir("alternate", 0777)); + cl_git_pass(p_mkdir("alternate/.git", 0777)); + cl_git_fail(git_repository_open_ext(&repo, "alternate", 0, NULL)); + cl_git_fail(git_repository_open_ext(&repo, "alternate/.git", 0, NULL)); + + git_buf_free(&ceiling); +} + +void test_repo_open__bad_gitlinks(void) +{ + git_repository *repo; + static const char *bad_links[] = { + "garbage\n", "gitdir", "gitdir:\n", "gitdir: foobar", + "gitdir: ../invalid", "gitdir: ../invalid2", + "gitdir: ../attr/.git with extra stuff", + NULL + }; + const char **scan; + + cl_git_sandbox_init("attr"); + + cl_git_pass(p_mkdir("alternate", 0777)); + cl_git_pass(p_mkdir("invalid", 0777)); + cl_git_pass(git_futils_mkdir_r("invalid2/.git", NULL, 0777)); + + for (scan = bad_links; *scan != NULL; scan++) { + cl_git_rewritefile("alternate/.git", *scan); + cl_git_fail(git_repository_open_ext(&repo, "alternate", 0, NULL)); + } + + git_futils_rmdir_r("invalid", 1); + git_futils_rmdir_r("invalid2", 1); +} + +static void unposix_path(git_buf *path) +{ + char *src, *tgt; + + src = tgt = path->ptr; + + /* convert "/d/..." to "d:\..." */ + if (src[0] == '/' && isalpha(src[1]) && src[2] == '/') { + *tgt++ = src[1]; + *tgt++ = ':'; + *tgt++ = '\\'; + src += 3; + } + + while (*src) { + *tgt++ = (*src == '/') ? '\\' : *src; + src++; + } + + *tgt = '\0'; +} + +void test_repo_open__win32_path(void) +{ +#ifdef GIT_WIN32 + git_repository *repo = cl_git_sandbox_init("empty_standard_repo"), *repo2; + git_buf winpath = GIT_BUF_INIT; + char *src, *tgt; + static const char *repo_path = "empty_standard_repo/.git/"; + static const char *repo_wd = "empty_standard_repo/"; + + cl_assert(git__suffixcmp(git_repository_path(repo), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo), repo_wd) == 0); + + cl_git_pass(git_buf_sets(&winpath, git_repository_path(repo))); + unposix_path(&winpath); + cl_git_pass(git_repository_open(&repo2, winpath.ptr)); + cl_assert(git__suffixcmp(git_repository_path(repo2), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo2), repo_wd) == 0); + git_repository_free(repo2); + + cl_git_pass(git_buf_sets(&winpath, git_repository_path(repo))); + git_buf_truncate(&winpath, winpath.size - 1); /* remove trailing '/' */ + unposix_path(&winpath); + cl_git_pass(git_repository_open(&repo2, winpath.ptr)); + cl_assert(git__suffixcmp(git_repository_path(repo2), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo2), repo_wd) == 0); + git_repository_free(repo2); + + cl_git_pass(git_buf_sets(&winpath, git_repository_workdir(repo))); + unposix_path(&winpath); + cl_git_pass(git_repository_open(&repo2, winpath.ptr)); + cl_assert(git__suffixcmp(git_repository_path(repo2), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo2), repo_wd) == 0); + git_repository_free(repo2); + + cl_git_pass(git_buf_sets(&winpath, git_repository_workdir(repo))); + git_buf_truncate(&winpath, winpath.size - 1); /* remove trailing '/' */ + unposix_path(&winpath); + cl_git_pass(git_repository_open(&repo2, winpath.ptr)); + cl_assert(git__suffixcmp(git_repository_path(repo2), repo_path) == 0); + cl_assert(git__suffixcmp(git_repository_workdir(repo2), repo_wd) == 0); + git_repository_free(repo2); + + git_buf_free(&winpath); +#endif }