6f3fbed8ed
The "core.hooksPath" setting is stored in a global variable and populated via the `git_default_core_config`. This may cause issues in the case where one is handling multiple different repositories in a single process with different values for that config key, as we may or may not see the correct value in that case. Furthermore, global state blocks our path towards libification. Refactor the code so that we instead store the value in `struct repo_settings`. The value is computed as-needed and cached. The result should be functionally the same as there aren't ever any code paths where we'd execute hooks outside the context of a repository. Note that this requires us to change the passed-in repository in the `repo_git_path()` family of functions to be non-constant, as we call `adjust_git_path()` there. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>
240 lines
7.9 KiB
C
240 lines
7.9 KiB
C
#ifndef PATH_H
|
|
#define PATH_H
|
|
|
|
struct repository;
|
|
struct strbuf;
|
|
struct string_list;
|
|
struct worktree;
|
|
|
|
/*
|
|
* The result to all functions which return statically allocated memory may be
|
|
* overwritten by another call to _any_ one of these functions. Consider using
|
|
* the safer variants which operate on strbufs or return allocated memory.
|
|
*/
|
|
|
|
/*
|
|
* Return a statically allocated path.
|
|
*/
|
|
const char *mkpath(const char *fmt, ...)
|
|
__attribute__((format (printf, 1, 2)));
|
|
|
|
/*
|
|
* Return a path.
|
|
*/
|
|
char *mkpathdup(const char *fmt, ...)
|
|
__attribute__((format (printf, 1, 2)));
|
|
|
|
/*
|
|
* The `repo_common_path` family of functions will construct a path into a
|
|
* repository's common git directory, which is shared by all worktrees.
|
|
*/
|
|
char *repo_common_path(const struct repository *repo,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 2, 3)));
|
|
const char *repo_common_path_append(const struct repository *repo,
|
|
struct strbuf *sb,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 3, 4)));
|
|
const char *repo_common_path_replace(const struct repository *repo,
|
|
struct strbuf *sb,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 3, 4)));
|
|
|
|
/*
|
|
* The `repo_git_path` family of functions will construct a path into a repository's
|
|
* git directory.
|
|
*
|
|
* These functions will perform adjustments to the resultant path to account
|
|
* for special paths which are either considered common among worktrees (e.g.
|
|
* paths into the object directory) or have been explicitly set via an
|
|
* environment variable or config (e.g. path to the index file).
|
|
*
|
|
* For an exhaustive list of the adjustments made look at `common_list` and
|
|
* `adjust_git_path` in path.c.
|
|
*/
|
|
char *repo_git_path(struct repository *repo,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 2, 3)));
|
|
const char *repo_git_path_append(struct repository *repo,
|
|
struct strbuf *sb,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 3, 4)));
|
|
const char *repo_git_path_replace(struct repository *repo,
|
|
struct strbuf *sb,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 3, 4)));
|
|
|
|
/*
|
|
* Similar to repo_git_path() but can produce paths for a specified
|
|
* worktree instead of current one. When no worktree is given, then the path is
|
|
* computed relative to main worktree of the given repository.
|
|
*/
|
|
const char *worktree_git_path(struct repository *r,
|
|
const struct worktree *wt,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 3, 4)));
|
|
|
|
/*
|
|
* The `repo_worktree_path` family of functions will construct a path into a
|
|
* repository's worktree.
|
|
*
|
|
* Returns a `NULL` pointer in case the repository has no worktree.
|
|
*/
|
|
char *repo_worktree_path(const struct repository *repo,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 2, 3)));
|
|
const char *repo_worktree_path_append(const struct repository *repo,
|
|
struct strbuf *sb,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 3, 4)));
|
|
const char *repo_worktree_path_replace(const struct repository *repo,
|
|
struct strbuf *sb,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 3, 4)));
|
|
|
|
/*
|
|
* The `repo_submodule_path` family of functions will construct a path into a
|
|
* submodule's git directory located at `path`. `path` must be a submodule path
|
|
* as found in the index and must be part of the given repository.
|
|
*
|
|
* Returns a `NULL` pointer in case the submodule cannot be found.
|
|
*/
|
|
char *repo_submodule_path(struct repository *repo,
|
|
const char *path,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 3, 4)));
|
|
const char *repo_submodule_path_append(struct repository *repo,
|
|
struct strbuf *sb,
|
|
const char *path,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 4, 5)));
|
|
const char *repo_submodule_path_replace(struct repository *repo,
|
|
struct strbuf *sb,
|
|
const char *path,
|
|
const char *fmt, ...)
|
|
__attribute__((format (printf, 4, 5)));
|
|
|
|
void report_linked_checkout_garbage(struct repository *r);
|
|
|
|
/*
|
|
* You can define a static memoized git path like:
|
|
*
|
|
* static REPO_GIT_PATH_FUNC(git_path_foo, "FOO")
|
|
*
|
|
* or use one of the global ones below.
|
|
*/
|
|
#define REPO_GIT_PATH_FUNC(var, filename) \
|
|
const char *git_path_##var(struct repository *r) \
|
|
{ \
|
|
if (!r->cached_paths.var) \
|
|
r->cached_paths.var = repo_git_path(r, filename); \
|
|
return r->cached_paths.var; \
|
|
}
|
|
|
|
const char *git_path_squash_msg(struct repository *r);
|
|
const char *git_path_merge_msg(struct repository *r);
|
|
const char *git_path_merge_rr(struct repository *r);
|
|
const char *git_path_merge_mode(struct repository *r);
|
|
const char *git_path_merge_head(struct repository *r);
|
|
const char *git_path_fetch_head(struct repository *r);
|
|
const char *git_path_shallow(struct repository *r);
|
|
|
|
int ends_with_path_components(const char *path, const char *components);
|
|
|
|
int calc_shared_perm(int mode);
|
|
int adjust_shared_perm(const char *path);
|
|
|
|
char *interpolate_path(const char *path, int real_home);
|
|
|
|
/* The bits are as follows:
|
|
*
|
|
* - ENTER_REPO_STRICT: callers that require exact paths (as opposed
|
|
* to allowing known suffixes like ".git", ".git/.git" to be
|
|
* omitted) can set this bit.
|
|
*
|
|
* - ENTER_REPO_ANY_OWNER_OK: callers that are willing to run without
|
|
* ownership check can set this bit.
|
|
*/
|
|
enum {
|
|
ENTER_REPO_STRICT = (1<<0),
|
|
ENTER_REPO_ANY_OWNER_OK = (1<<1),
|
|
};
|
|
|
|
const char *enter_repo(const char *path, unsigned flags);
|
|
const char *remove_leading_path(const char *in, const char *prefix);
|
|
const char *relative_path(const char *in, const char *prefix, struct strbuf *sb);
|
|
int normalize_path_copy_len(char *dst, const char *src, int *prefix_len);
|
|
int normalize_path_copy(char *dst, const char *src);
|
|
/**
|
|
* Normalize in-place the path contained in the strbuf. If an error occurs,
|
|
* the contents of "sb" are left untouched, and -1 is returned.
|
|
*/
|
|
int strbuf_normalize_path(struct strbuf *src);
|
|
int longest_ancestor_length(const char *path, struct string_list *prefixes);
|
|
char *strip_path_suffix(const char *path, const char *suffix);
|
|
int daemon_avoid_alias(const char *path);
|
|
|
|
/*
|
|
* These functions match their is_hfs_dotgit() counterparts; see utf8.h for
|
|
* details.
|
|
*/
|
|
int is_ntfs_dotgit(const char *name);
|
|
int is_ntfs_dotgitmodules(const char *name);
|
|
int is_ntfs_dotgitignore(const char *name);
|
|
int is_ntfs_dotgitattributes(const char *name);
|
|
int is_ntfs_dotmailmap(const char *name);
|
|
|
|
/*
|
|
* Returns true iff "str" could be confused as a command-line option when
|
|
* passed to a sub-program like "ssh". Note that this has nothing to do with
|
|
* shell-quoting, which should be handled separately; we're assuming here that
|
|
* the string makes it verbatim to the sub-program.
|
|
*/
|
|
int looks_like_command_line_option(const char *str);
|
|
|
|
/**
|
|
* Return a newly allocated string with the evaluation of
|
|
* "$XDG_CONFIG_HOME/$subdir/$filename" if $XDG_CONFIG_HOME is non-empty, otherwise
|
|
* "$HOME/.config/$subdir/$filename". Return NULL upon error.
|
|
*/
|
|
char *xdg_config_home_for(const char *subdir, const char *filename);
|
|
|
|
/**
|
|
* Return a newly allocated string with the evaluation of
|
|
* "$XDG_CONFIG_HOME/git/$filename" if $XDG_CONFIG_HOME is non-empty, otherwise
|
|
* "$HOME/.config/git/$filename". Return NULL upon error.
|
|
*/
|
|
char *xdg_config_home(const char *filename);
|
|
|
|
/**
|
|
* Return a newly allocated string with the evaluation of
|
|
* "$XDG_CACHE_HOME/git/$filename" if $XDG_CACHE_HOME is non-empty, otherwise
|
|
* "$HOME/.cache/git/$filename". Return NULL upon error.
|
|
*/
|
|
char *xdg_cache_home(const char *filename);
|
|
|
|
/*
|
|
* Create a directory and (if share is nonzero) adjust its permissions
|
|
* according to the shared_repository setting. Only use this for
|
|
* directories under $GIT_DIR. Don't use it for working tree
|
|
* directories.
|
|
*/
|
|
void safe_create_dir(const char *dir, int share);
|
|
|
|
# ifdef USE_THE_REPOSITORY_VARIABLE
|
|
# include "strbuf.h"
|
|
# include "repository.h"
|
|
|
|
#define GIT_PATH_FUNC(func, filename) \
|
|
const char *func(void) \
|
|
{ \
|
|
static char *ret; \
|
|
if (!ret) \
|
|
ret = repo_git_path(the_repository, filename); \
|
|
return ret; \
|
|
}
|
|
|
|
# endif /* USE_THE_REPOSITORY_VARIABLE */
|
|
|
|
#endif /* PATH_H */
|