#ifndef SETUP_H

#define SETUP_H

#include "refs.h"

#include "string-list.h"

int is_inside_git_dir(struct repository *repo);

int is_inside_work_tree(struct repository *repo);

int get_common_dir_noenv(struct strbuf *sb, const char *gitdir);

int get_common_dir(struct strbuf *sb, const char *gitdir);

/*

 * Return true if the given path is a git directory; note that this _just_

 * looks at the directory itself. If you want to know whether "foo/.git"

 * is a repository, you must feed that path, not just "foo".

 */

int is_git_directory(const char *path);

/*

 * Return 1 if the given path is the root of a git repository or

 * submodule, else 0. Will not return 1 for bare repositories with the

 * exception of creating a bare repository in "foo/.git" and calling

 * is_git_repository("foo").

 *

 * If we run into read errors, we err on the side of saying "yes, it is",

 * as we usually consider sub-repos precious, and would prefer to err on the

 * side of not disrupting or deleting them.

 */

int is_nonbare_repository_dir(struct strbuf *path);

#define READ_GITFILE_ERR_STAT_FAILED 1

#define READ_GITFILE_ERR_NOT_A_FILE 2

#define READ_GITFILE_ERR_OPEN_FAILED 3

#define READ_GITFILE_ERR_READ_FAILED 4

#define READ_GITFILE_ERR_INVALID_FORMAT 5

#define READ_GITFILE_ERR_NO_PATH 6

#define READ_GITFILE_ERR_NOT_A_REPO 7

#define READ_GITFILE_ERR_TOO_LARGE 8

#define READ_GITFILE_ERR_MISSING 9

#define READ_GITFILE_ERR_IS_A_DIR 10

void read_gitfile_error_die(int error_code, const char *path);

const char *read_gitfile_gently(const char *path, int *return_error_code);

int read_gitfile_raw(struct strbuf *contents, const char *path);

#define read_gitfile(path) read_gitfile_gently((path), NULL)

const char *resolve_gitdir_gently(const char *suspect, int *return_error_code);

#define resolve_gitdir(path) resolve_gitdir_gently((path), NULL)

/*

 * Check if a repository is safe and die if it is not, by verifying the

 * ownership of the worktree (if any), the git directory, and the gitfile (if

 * any).

 *

 * Exemptions for known-safe repositories can be added via `safe.directory`

 * config settings; for non-bare repositories, their worktree needs to be

 * added, for bare ones their git directory.

 */

void die_upon_dubious_ownership(const char *gitfile, const char *worktree,

        const char *gitdir);

void setup_work_tree(struct repository *repo);

/*

 * discover_git_directory_reason() is similar to discover_git_directory(),

 * except it returns an enum value instead. It is important to note that

 * a zero-valued return here is actually GIT_DIR_NONE, which is different

 * from discover_git_directory.

 */

enum discovery_result {

  GIT_DIR_EXPLICIT = 1,

  GIT_DIR_DISCOVERED = 2,

  GIT_DIR_BARE = 3,

  /* these are errors */

  GIT_DIR_HIT_CEILING = -1,

  GIT_DIR_HIT_MOUNT_POINT = -2,

  GIT_DIR_INVALID_GITFILE = -3,

  GIT_DIR_INVALID_OWNERSHIP = -4,

  GIT_DIR_DISALLOWED_BARE = -5,

  GIT_DIR_INVALID_FORMAT = -6,

  GIT_DIR_CWD_FAILURE = -7,

};

enum discovery_result discover_git_directory_reason(struct strbuf *commondir,

                struct strbuf *gitdir);

/*

 * Find the commondir and gitdir of the repository that contains the current

 * working directory, without changing the working directory or other global

 * state. The result is appended to commondir and gitdir.  If the discovered

 * gitdir does not correspond to a worktree, then 'commondir' and 'gitdir' will

 * both have the same result appended to the buffer.  The return value is

 * either 0 upon success and -1 if no repository was found.

 */

static inline int discover_git_directory(struct strbuf *commondir,

           struct strbuf *gitdir)

{

  if (discover_git_directory_reason(commondir, gitdir) <= 0)

    return -1;

  return 0;

}

Unexecuted instantiation: commit.c:discover_git_directory

Unexecuted instantiation: config.c:discover_git_directory

Unexecuted instantiation: dir.c:discover_git_directory

Unexecuted instantiation: environment.c:discover_git_directory

Unexecuted instantiation: hook.c:discover_git_directory

Unexecuted instantiation: mailmap.c:discover_git_directory

Unexecuted instantiation: object-file.c:discover_git_directory

Unexecuted instantiation: object-name.c:discover_git_directory

Unexecuted instantiation: odb.c:discover_git_directory

Unexecuted instantiation: path.c:discover_git_directory

Unexecuted instantiation: pathspec.c:discover_git_directory

Unexecuted instantiation: refs.c:discover_git_directory

Unexecuted instantiation: files-backend.c:discover_git_directory

Unexecuted instantiation: reftable-backend.c:discover_git_directory

Unexecuted instantiation: remote.c:discover_git_directory

Unexecuted instantiation: repo-settings.c:discover_git_directory

Unexecuted instantiation: repository.c:discover_git_directory

Unexecuted instantiation: revision.c:discover_git_directory

Unexecuted instantiation: setup.c:discover_git_directory

Unexecuted instantiation: submodule.c:discover_git_directory

Unexecuted instantiation: symlinks.c:discover_git_directory

Unexecuted instantiation: trace.c:discover_git_directory

Unexecuted instantiation: worktree.c:discover_git_directory

Unexecuted instantiation: wt-status.c:discover_git_directory

Unexecuted instantiation: attr.c:discover_git_directory

Unexecuted instantiation: diff.c:discover_git_directory

Unexecuted instantiation: line-log.c:discover_git_directory

Unexecuted instantiation: parse-options-cb.c:discover_git_directory

Unexecuted instantiation: unpack-trees.c:discover_git_directory

Unexecuted instantiation: apply.c:discover_git_directory

/* Flags that can be passed to `enter_repo()`. */

enum {

  /*

   * Callers that require exact paths (as opposed to allowing known

   * suffixes like ".git", ".git/.git" to be omitted) can set this bit.

   */

  ENTER_REPO_STRICT = (1<<0),

  /*

   * Callers that are willing to run without ownership check can set this

   * bit.

   */

  ENTER_REPO_ANY_OWNER_OK = (1<<1),

};

/*

 * Discover and enter a repository.

 *

 * First, one directory to try is determined by the following algorithm.

 *

 * (0) If "strict" is given, the path is used as given and no DWIM is

 *     done. Otherwise:

 * (1) "~/path" to mean path under the running user's home directory;

 * (2) "~user/path" to mean path under named user's home directory;

 * (3) "relative/path" to mean cwd relative directory; or

 * (4) "/absolute/path" to mean absolute directory.

 *

 * Unless "strict" is given, we check "%s/.git", "%s", "%s.git/.git", "%s.git"

 * in this order. We select the first one that is a valid git repository, and

 * chdir() to it. If none match, or we fail to chdir, we return NULL.

 *

 * If all goes well, we return the directory we used to chdir() (but

 * before ~user is expanded), avoiding getcwd() resolving symbolic

 * links.  User relative paths are also returned as they are given,

 * except DWIM suffixing.

 */

const char *enter_repo(struct repository *repo, const char *path, unsigned flags);

const char *setup_git_directory_gently(struct repository *repo, int *);

const char *setup_git_directory(struct repository *repo);

char *prefix_path(struct repository *repo, const char *prefix, int len, const char *path);

char *prefix_path_gently(struct repository *repo, const char *prefix, int len, int *remaining, const char *path);

int check_filename(const char *prefix, const char *name);

void verify_filename(struct repository *repo,

         const char *prefix,

         const char *name,

         int diagnose_misspelt_rev);

void verify_non_filename(struct repository *repo, const char *prefix, const char *name);

int path_inside_repo(struct repository *repo, const char *prefix, const char *path);

void sanitize_stdfds(void);

/*

 * Daemonize the current process by forking and then exiting the parent

 * process. Returns 0 when successful, in which case the parent process will

 * have exited and it's the child process that continues to run the code.

 * Otherwise, a negative error code is returned and the parent process will

 * continue execution.

 *

 * Note that this function will also perform the following changes:

 *

 *   - Standard file descriptors in the child process are closed.

 *   - The child process is made a session leader via setsid(3p).

 *   - All tempfiles owned by the parent process are reassigned to the

 *     daemonized child process.

 */

int daemonize(void);

/*

 * GIT_REPO_VERSION is the version we write by default. The

 * _READ variant is the highest number we know how to

 * handle.

 */

#define GIT_REPO_VERSION 0

#define GIT_REPO_VERSION_READ 1

/*

 * You _have_ to initialize a `struct repository_format` using

 * `= REPOSITORY_FORMAT_INIT` before calling `read_repository_format()`.

 */

struct repository_format {

  int version;

  int precious_objects;

  char *partial_clone; /* value of extensions.partialclone */

  int worktree_config;

  int relative_worktrees;

  int submodule_path_cfg;

  int is_bare;

  int hash_algo;

  int compat_hash_algo;

  enum ref_storage_format ref_storage_format;

  char *ref_storage_payload;

  int sparse_index;

  char *work_tree;

  struct string_list unknown_extensions;

  struct string_list v1_only_extensions;

};

/*

 * Always use this to initialize a `struct repository_format`

 * to a well-defined, default state before calling

 * `read_repository()`.

 */

#define REPOSITORY_FORMAT_INIT \

{ \

  .version = -1, \

  .is_bare = -1, \

  .hash_algo = GIT_HASH_DEFAULT, \

  .ref_storage_format = REF_STORAGE_FORMAT_FILES, \

  .unknown_extensions = STRING_LIST_INIT_DUP, \

  .v1_only_extensions = STRING_LIST_INIT_DUP, \

}

/*

 * Read the repository format characteristics from the config file "path" into

 * "format" struct. Returns the numeric version. On error, or if no version is

 * found in the configuration, -1 is returned, format->version is set to -1,

 * and all other fields in the struct are set to the default configuration

 * (REPOSITORY_FORMAT_INIT). Always initialize the struct using

 * REPOSITORY_FORMAT_INIT before calling this function.

 */

int read_repository_format(struct repository_format *format, const char *path);

/*

 * Free the memory held onto by `format`, but not the struct itself.

 * (No need to use this after `read_repository_format()` fails.)

 */

void clear_repository_format(struct repository_format *format);

/*

 * Verify that the repository described by repository_format is something we

 * can read. If it is, return 0. Otherwise, return -1, and "err" will describe

 * any errors encountered.

 */

int verify_repository_format(const struct repository_format *format,

           struct strbuf *err);

enum apply_repository_format_flags {

  /*

   * Honor environment variables when applying the repository format to

   * the repository. For now, this only covers environment variables that

   * relate to the object database.

   */

  APPLY_REPOSITORY_FORMAT_HONOR_ENV = (1 << 0),

};

/*

 * Apply the given repository format to the repo. This initializes extensions

 * required for normal operation. Returns 0 on success, a negative error code

 * when the format is not valid as determined by

 * `verify_repository_format()`.

 */

int apply_repository_format(struct repository *repo,

          const struct repository_format *format,

          enum apply_repository_format_flags flags,

          struct strbuf *err);

const char *get_template_dir(const char *option_template);

/*

 * Create the repository by creating the necessary directory structures,

 * setting up the configuration and configuring the repository's format. If

 * `template_dir` is set, copy over templates from that directory. Furthermore,

 * if and only if `reinit_ok` is a non-NULL pointer, then the function may

 * reinitialize a preexisting repository. In that case, the pointer will be set

 * to `1` in case the repo was reinitialized and `0` if it didn't exist yet.

 *

 * Note that this function does not create the reference and object databases.

 */

void create_repository(struct repository *repo,

           const char *git_dir,

           const char *real_git_dir,

           const char *worktree,

           const char *template_dir,

           int hash_algo,

           const char *ref_storage_format_uri,

           int init_shared_repository,

           int *reinit_ok);

void initialize_repository_version(struct repository *repo,

           int hash_algo,

           enum ref_storage_format ref_storage_format,

           int reinit);

/*

 * Create the reference database for the repository. The repository and its ref

 * storage format must have already been configured properly before calling

 * this function. When set, `initial_branch` overrides the default branch that

 * HEAD will point to.

 */

void create_reference_database(struct repository *repo, const char *initial_branch, int quiet);

/*

 * Create the object database for the repository. The repository must have

 * already been configured properly before calling this function. When set,

 * `alternates` is the list of alternates that should be written into the

 * object database.

 */

void create_object_database(struct repository *repo, const struct strvec *alternates);

/*

 * NOTE NOTE NOTE!!

 *

 * PERM_UMASK, OLD_PERM_GROUP and OLD_PERM_EVERYBODY enumerations must

 * not be changed. Old repositories have core.sharedrepository written in

 * numeric format, and therefore these values are preserved for compatibility

 * reasons.

 */

enum sharedrepo {

  PERM_UMASK          = 0,

  OLD_PERM_GROUP      = 1,

  OLD_PERM_EVERYBODY  = 2,

  PERM_GROUP          = 0660,

  PERM_EVERYBODY      = 0664

};

int git_config_perm(const char *var, const char *value);

struct startup_info {

  /*

   * Whether the user is asking us to treat the repository as bare via

   * `git --bare`, even if it's not.

   */

  bool force_bare_repository;

  int have_repository;

  const char *original_cwd;

};

extern struct startup_info *startup_info;

extern const char *tmp_original_cwd;

#endif /* SETUP_H */