[thirdparty/git.git] / setup.c

#include "cache.h"
#include "dir.h"

static int inside_git_dir = -1;
static int inside_work_tree = -1;

static int sanitary_path_copy(char *dst, const char *src)
{
	char *dst0 = dst;

	if (*src == '/') {
		*dst++ = '/';
		while (*src == '/')
			src++;
	}

	for (;;) {
		char c = *src;

		/*
		 * A path component that begins with . could be
		 * special:
		 * (1) "." and ends   -- ignore and terminate.
		 * (2) "./"           -- ignore them, eat slash and continue.
		 * (3) ".." and ends  -- strip one and terminate.
		 * (4) "../"          -- strip one, eat slash and continue.
		 */
		if (c == '.') {
			switch (src[1]) {
			case '\0':
				/* (1) */
				src++;
				break;
			case '/':
				/* (2) */
				src += 2;
				while (*src == '/')
					src++;
				continue;
			case '.':
				switch (src[2]) {
				case '\0':
					/* (3) */
					src += 2;
					goto up_one;
				case '/':
					/* (4) */
					src += 3;
					while (*src == '/')
						src++;
					goto up_one;
				}
			}
		}

		/* copy up to the next '/', and eat all '/' */
		while ((c = *src++) != '\0' && c != '/')
			*dst++ = c;
		if (c == '/') {
			*dst++ = c;
			while (c == '/')
				c = *src++;
			src--;
		} else if (!c)
			break;
		continue;

	up_one:
		/*
		 * dst0..dst is prefix portion, and dst[-1] is '/';
		 * go up one level.
		 */
		dst -= 2; /* go past trailing '/' if any */
		if (dst < dst0)
			return -1;
		while (1) {
			if (dst <= dst0)
				break;
			c = *dst--;
			if (c == '/') {
				dst += 2;
				break;
			}
		}
	}
	*dst = '\0';
	return 0;
}

const char *prefix_path(const char *prefix, int len, const char *path)
{
	const char *orig = path;
	char *sanitized = xmalloc(len + strlen(path) + 1);
	if (is_absolute_path(orig))
		strcpy(sanitized, path);
	else {
		if (len)
			memcpy(sanitized, prefix, len);
		strcpy(sanitized + len, path);
	}
	if (sanitary_path_copy(sanitized, sanitized))
		goto error_out;
	if (is_absolute_path(orig)) {
		const char *work_tree = get_git_work_tree();
		size_t len = strlen(work_tree);
		size_t total = strlen(sanitized) + 1;
		if (strncmp(sanitized, work_tree, len) ||
		    (sanitized[len] != '\0' && sanitized[len] != '/')) {
		error_out:
			error("'%s' is outside repository", orig);
			free(sanitized);
			return NULL;
		}
		if (sanitized[len] == '/')
			len++;
		memmove(sanitized, sanitized + len, total - len);
	}
	return sanitized;
}

/*
 * Unlike prefix_path, this should be used if the named file does
 * not have to interact with index entry; i.e. name of a random file
 * on the filesystem.
 */
const char *prefix_filename(const char *pfx, int pfx_len, const char *arg)
{
	static char path[PATH_MAX];
	if (!pfx || !*pfx || is_absolute_path(arg))
		return arg;
	memcpy(path, pfx, pfx_len);
	strcpy(path + pfx_len, arg);
	return path;
}

/*
 * Verify a filename that we got as an argument for a pathspec
 * entry. Note that a filename that begins with "-" never verifies
 * as true, because even if such a filename were to exist, we want
 * it to be preceded by the "--" marker (or we want the user to
 * use a format like "./-filename")
 */
void verify_filename(const char *prefix, const char *arg)
{
	const char *name;
	struct stat st;

	if (*arg == '-')
		die("bad flag '%s' used after filename", arg);
	name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
	if (!lstat(name, &st))
		return;
	if (errno == ENOENT)
		die("ambiguous argument '%s': unknown revision or path not in the working tree.\n"
		    "Use '--' to separate paths from revisions", arg);
	die("'%s': %s", arg, strerror(errno));
}

/*
 * Opposite of the above: the command line did not have -- marker
 * and we parsed the arg as a refname.  It should not be interpretable
 * as a filename.
 */
void verify_non_filename(const char *prefix, const char *arg)
{
	const char *name;
	struct stat st;

	if (!is_inside_work_tree() || is_inside_git_dir())
		return;
	if (*arg == '-')
		return; /* flag */
	name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
	if (!lstat(name, &st))
		die("ambiguous argument '%s': both revision and filename\n"
		    "Use '--' to separate filenames from revisions", arg);
	if (errno != ENOENT && errno != ENOTDIR)
		die("'%s': %s", arg, strerror(errno));
}

const char **get_pathspec(const char *prefix, const char **pathspec)
{
	const char *entry = *pathspec;
	const char **src, **dst;
	int prefixlen;

	if (!prefix && !entry)
		return NULL;

	if (!entry) {
		static const char *spec[2];
		spec[0] = prefix;
		spec[1] = NULL;
		return spec;
	}

	/* Otherwise we have to re-write the entries.. */
	src = pathspec;
	dst = pathspec;
	prefixlen = prefix ? strlen(prefix) : 0;
	while (*src) {
		const char *p = prefix_path(prefix, prefixlen, *src);
		if (p)
			*(dst++) = p;
		else
			exit(128); /* error message already given */
		src++;
	}
	*dst = NULL;
	if (!*pathspec)
		return NULL;
	return pathspec;
}

/*
 * Test if it looks like we're at a git directory.
 * We want to see:
 *
 *  - either an objects/ directory _or_ the proper
 *    GIT_OBJECT_DIRECTORY environment variable
 *  - a refs/ directory
 *  - either a HEAD symlink or a HEAD file that is formatted as
 *    a proper "ref:", or a regular file HEAD that has a properly
 *    formatted sha1 object name.
 */
static int is_git_directory(const char *suspect)
{
	char path[PATH_MAX];
	size_t len = strlen(suspect);

	strcpy(path, suspect);
	if (getenv(DB_ENVIRONMENT)) {
		if (access(getenv(DB_ENVIRONMENT), X_OK))
			return 0;
	}
	else {
		strcpy(path + len, "/objects");
		if (access(path, X_OK))
			return 0;
	}

	strcpy(path + len, "/refs");
	if (access(path, X_OK))
		return 0;

	strcpy(path + len, "/HEAD");
	if (validate_headref(path))
		return 0;

	return 1;
}

int is_inside_git_dir(void)
{
	if (inside_git_dir < 0)
		inside_git_dir = is_inside_dir(get_git_dir());
	return inside_git_dir;
}

int is_inside_work_tree(void)
{
	if (inside_work_tree < 0)
		inside_work_tree = is_inside_dir(get_git_work_tree());
	return inside_work_tree;
}

/*
 * set_work_tree() is only ever called if you set GIT_DIR explicitely.
 * The old behaviour (which we retain here) is to set the work tree root
 * to the cwd, unless overridden by the config, the command line, or
 * GIT_WORK_TREE.
 */
static const char *set_work_tree(const char *dir)
{
	char buffer[PATH_MAX + 1];

	if (!getcwd(buffer, sizeof(buffer)))
		die ("Could not get the current working directory");
	git_work_tree_cfg = xstrdup(buffer);
	inside_work_tree = 1;

	return NULL;
}

void setup_work_tree(void)
{
	const char *work_tree, *git_dir;
	static int initialized = 0;

	if (initialized)
		return;
	work_tree = get_git_work_tree();
	git_dir = get_git_dir();
	if (!is_absolute_path(git_dir))
		set_git_dir(make_absolute_path(git_dir));
	if (!work_tree || chdir(work_tree))
		die("This operation must be run in a work tree");
	initialized = 1;
}

static int check_repository_format_gently(int *nongit_ok)
{
	git_config(check_repository_format_version);
	if (GIT_REPO_VERSION < repository_format_version) {
		if (!nongit_ok)
			die ("Expected git repo version <= %d, found %d",
			     GIT_REPO_VERSION, repository_format_version);
		warning("Expected git repo version <= %d, found %d",
			GIT_REPO_VERSION, repository_format_version);
		warning("Please upgrade Git");
		*nongit_ok = -1;
		return -1;
	}
	return 0;
}

/*
 * We cannot decide in this function whether we are in the work tree or
 * not, since the config can only be read _after_ this function was called.
 */
const char *setup_git_directory_gently(int *nongit_ok)
{
	const char *work_tree_env = getenv(GIT_WORK_TREE_ENVIRONMENT);
	static char cwd[PATH_MAX+1];
	const char *gitdirenv;
	int len, offset;

	/*
	 * Let's assume that we are in a git repository.
	 * If it turns out later that we are somewhere else, the value will be
	 * updated accordingly.
	 */
	if (nongit_ok)
		*nongit_ok = 0;

	/*
	 * If GIT_DIR is set explicitly, we're not going
	 * to do any discovery, but we still do repository
	 * validation.
	 */
	gitdirenv = getenv(GIT_DIR_ENVIRONMENT);
	if (gitdirenv) {
		if (PATH_MAX - 40 < strlen(gitdirenv))
			die("'$%s' too big", GIT_DIR_ENVIRONMENT);
		if (is_git_directory(gitdirenv)) {
			static char buffer[1024 + 1];
			const char *retval;

			if (!work_tree_env) {
				retval = set_work_tree(gitdirenv);
				/* config may override worktree */
				if (check_repository_format_gently(nongit_ok))
					return NULL;
				return retval;
			}
			if (check_repository_format_gently(nongit_ok))
				return NULL;
			retval = get_relative_cwd(buffer, sizeof(buffer) - 1,
					get_git_work_tree());
			if (!retval || !*retval)
				return NULL;
			set_git_dir(make_absolute_path(gitdirenv));
			if (chdir(work_tree_env) < 0)
				die ("Could not chdir to %s", work_tree_env);
			strcat(buffer, "/");
			return retval;
		}
		if (nongit_ok) {
			*nongit_ok = 1;
			return NULL;
		}
		die("Not a git repository: '%s'", gitdirenv);
	}

	if (!getcwd(cwd, sizeof(cwd)-1))
		die("Unable to read current working directory");

	/*
	 * Test in the following order (relative to the cwd):
	 * - .git/
	 * - ./ (bare)
	 * - ../.git/
	 * - ../ (bare)
	 * - ../../.git/
	 *   etc.
	 */
	offset = len = strlen(cwd);
	for (;;) {
		if (is_git_directory(DEFAULT_GIT_DIR_ENVIRONMENT))
			break;
		if (is_git_directory(".")) {
			inside_git_dir = 1;
			if (!work_tree_env)
				inside_work_tree = 0;
			setenv(GIT_DIR_ENVIRONMENT, ".", 1);
			check_repository_format_gently(nongit_ok);
			return NULL;
		}
		chdir("..");
		do {
			if (!offset) {
				if (nongit_ok) {
					if (chdir(cwd))
						die("Cannot come back to cwd");
					*nongit_ok = 1;
					return NULL;
				}
				die("Not a git repository");
			}
		} while (cwd[--offset] != '/');
	}

	inside_git_dir = 0;
	if (!work_tree_env)
		inside_work_tree = 1;
	git_work_tree_cfg = xstrndup(cwd, offset);
	if (check_repository_format_gently(nongit_ok))
		return NULL;
	if (offset == len)
		return NULL;

	/* Make "offset" point to past the '/', and add a '/' at the end */
	offset++;
	cwd[len++] = '/';
	cwd[len] = 0;
	return cwd + offset;
}

int git_config_perm(const char *var, const char *value)
{
	if (value) {
		int i;
		if (!strcmp(value, "umask"))
			return PERM_UMASK;
		if (!strcmp(value, "group"))
			return PERM_GROUP;
		if (!strcmp(value, "all") ||
		    !strcmp(value, "world") ||
		    !strcmp(value, "everybody"))
			return PERM_EVERYBODY;
		i = atoi(value);
		if (i > 1)
			return i;
	}
	return git_config_bool(var, value);
}

int check_repository_format_version(const char *var, const char *value)
{
	if (strcmp(var, "core.repositoryformatversion") == 0)
		repository_format_version = git_config_int(var, value);
	else if (strcmp(var, "core.sharedrepository") == 0)
		shared_repository = git_config_perm(var, value);
	else if (strcmp(var, "core.bare") == 0) {
		is_bare_repository_cfg = git_config_bool(var, value);
		if (is_bare_repository_cfg == 1)
			inside_work_tree = -1;
	} else if (strcmp(var, "core.worktree") == 0) {
		if (!value)
			return config_error_nonbool(var);
		free(git_work_tree_cfg);
		git_work_tree_cfg = xstrdup(value);
		inside_work_tree = -1;
	}
	return 0;
}

int check_repository_format(void)
{
	return check_repository_format_gently(NULL);
}

const char *setup_git_directory(void)
{
	const char *retval = setup_git_directory_gently(NULL);

	/* If the work tree is not the default one, recompute prefix */
	if (inside_work_tree < 0) {
		static char buffer[PATH_MAX + 1];
		char *rel;
		if (retval && chdir(retval))
			die ("Could not jump back into original cwd");
		rel = get_relative_cwd(buffer, PATH_MAX, get_git_work_tree());
		return rel && *rel ? strcat(rel, "/") : NULL;
	}

	return retval;
}
Commit	Line	Data
d288a700	1	#include "cache.h"
e90fdc39 JS	2	#include "dir.h"
	3
	4	static int inside_git_dir = -1;
	5	static int inside_work_tree = -1;
d288a700	6
d089ebaa	7	static int sanitary_path_copy(char dst, const char src)
f332726e	8	{
d089ebaa JH	9	char *dst0 = dst;
	10
	11	if (*src == '/') {
	12	*dst++ = '/';
	13	while (*src == '/')
	14	src++;
	15	}
	16
f332726e	17	for (;;) {
d089ebaa JH	18	char c = *src;
	19
	20	/*
	21	* A path component that begins with . could be
	22	* special:
	23	* (1) "." and ends -- ignore and terminate.
	24	* (2) "./" -- ignore them, eat slash and continue.
	25	* (3) ".." and ends -- strip one and terminate.
	26	* (4) "../" -- strip one, eat slash and continue.
	27	*/
	28	if (c == '.') {
	29	switch (src[1]) {
	30	case '\0':
	31	/* (1) */
	32	src++;
	33	break;
	34	case '/':
	35	/* (2) */
	36	src += 2;
	37	while (*src == '/')
	38	src++;
	39	continue;
	40	case '.':
	41	switch (src[2]) {
	42	case '\0':
	43	/* (3) */
	44	src += 2;
	45	goto up_one;
	46	case '/':
	47	/* (4) */
	48	src += 3;
	49	while (*src == '/')
	50	src++;
	51	goto up_one;
	52	}
	53	}
f332726e	54	}
d089ebaa JH	55
	56	/* copy up to the next '/', and eat all '/' */
	57	while ((c = *src++) != '\0' && c != '/')
	58	*dst++ = c;
f332726e	59	if (c == '/') {
d089ebaa JH	60	*dst++ = c;
	61	while (c == '/')
	62	c = *src++;
	63	src--;
	64	} else if (!c)
f332726e	65	break;
f332726e	66	continue;
d089ebaa JH	67
	68	up_one:
	69	/*
	70	* dst0..dst is prefix portion, and dst[-1] is '/';
	71	* go up one level.
	72	*/
	73	dst -= 2; /* go past trailing '/' if any */
	74	if (dst < dst0)
	75	return -1;
	76	while (1) {
	77	if (dst <= dst0)
	78	break;
	79	c = *dst--;
	80	if (c == '/') {
	81	dst += 2;
	82	break;
	83	}
	84	}
f332726e	85	}
d089ebaa JH	86	*dst = '\0';
	87	return 0;
	88	}
a6080a0a	89
d089ebaa JH	90	const char prefix_path(const char prefix, int len, const char *path)
	91	{
	92	const char *orig = path;
	93	char *sanitized = xmalloc(len + strlen(path) + 1);
9a13ba1b	94	if (is_absolute_path(orig))
d089ebaa JH	95	strcpy(sanitized, path);
	96	else {
	97	if (len)
	98	memcpy(sanitized, prefix, len);
	99	strcpy(sanitized + len, path);
f332726e	100	}
d089ebaa JH	101	if (sanitary_path_copy(sanitized, sanitized))
d089ebaa JH	102	goto error_out;
9a13ba1b	103	if (is_absolute_path(orig)) {
d089ebaa JH	104	const char *work_tree = get_git_work_tree();
	105	size_t len = strlen(work_tree);
	106	size_t total = strlen(sanitized) + 1;
	107	if (strncmp(sanitized, work_tree, len) \|\|
	108	(sanitized[len] != '\0' && sanitized[len] != '/')) {
	109	error_out:
	110	error("'%s' is outside repository", orig);
	111	free(sanitized);
	112	return NULL;
	113	}
	114	if (sanitized[len] == '/')
	115	len++;
	116	memmove(sanitized, sanitized + len, total - len);
	117	}
	118	return sanitized;
f332726e LT	119	}
f332726e LT	120
a6080a0a	121	/*
4ca06608 JH	122	* Unlike prefix_path, this should be used if the named file does
	123	* not have to interact with index entry; i.e. name of a random file
	124	* on the filesystem.
	125	*/
	126	const char prefix_filename(const char pfx, int pfx_len, const char *arg)
	127	{
	128	static char path[PATH_MAX];
ecf4831d	129	if (!pfx \|\| !*pfx \|\| is_absolute_path(arg))
4ca06608 JH	130	return arg;
	131	memcpy(path, pfx, pfx_len);
	132	strcpy(path + pfx_len, arg);
	133	return path;
	134	}
	135
e23d0b4a LT	136	/*
	137	* Verify a filename that we got as an argument for a pathspec
	138	* entry. Note that a filename that begins with "-" never verifies
	139	* as true, because even if such a filename were to exist, we want
	140	* it to be preceded by the "--" marker (or we want the user to
	141	* use a format like "./-filename")
	142	*/
	143	void verify_filename(const char prefix, const char arg)
	144	{
	145	const char *name;
	146	struct stat st;
	147
	148	if (*arg == '-')
	149	die("bad flag '%s' used after filename", arg);
	150	name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
	151	if (!lstat(name, &st))
	152	return;
	153	if (errno == ENOENT)
ea92f41f JH	154	die("ambiguous argument '%s': unknown revision or path not in the working tree.\n"
ea92f41f JH	155	"Use '--' to separate paths from revisions", arg);
e23d0b4a LT	156	die("'%s': %s", arg, strerror(errno));
	157	}
	158
ea92f41f JH	159	/*
	160	* Opposite of the above: the command line did not have -- marker
	161	* and we parsed the arg as a refname. It should not be interpretable
	162	* as a filename.
	163	*/
	164	void verify_non_filename(const char prefix, const char arg)
	165	{
	166	const char *name;
	167	struct stat st;
	168
7ae3df8c	169	if (!is_inside_work_tree() \|\| is_inside_git_dir())
68025633	170	return;
ea92f41f JH	171	if (*arg == '-')
	172	return; /* flag */
	173	name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
	174	if (!lstat(name, &st))
	175	die("ambiguous argument '%s': both revision and filename\n"
	176	"Use '--' to separate filenames from revisions", arg);
33a798c8	177	if (errno != ENOENT && errno != ENOTDIR)
ea92f41f JH	178	die("'%s': %s", arg, strerror(errno));
	179	}
	180
6b5ee137	181	const char *get_pathspec(const char prefix, const char **pathspec)
d288a700	182	{
6b5ee137	183	const char entry = pathspec;
d089ebaa	184	const char src, dst;
d288a700 LT	185	int prefixlen;
d288a700 LT	186
f332726e LT	187	if (!prefix && !entry)
f332726e LT	188	return NULL;
d288a700 LT	189
	190	if (!entry) {
	191	static const char *spec[2];
	192	spec[0] = prefix;
	193	spec[1] = NULL;
	194	return spec;
	195	}
	196
	197	/* Otherwise we have to re-write the entries.. */
d089ebaa JH	198	src = pathspec;
d089ebaa JH	199	dst = pathspec;
f332726e	200	prefixlen = prefix ? strlen(prefix) : 0;
d089ebaa JH	201	while (*src) {
	202	const char p = prefix_path(prefix, prefixlen, src);
	203	if (p)
	204	*(dst++) = p;
3296766e JH	205	else
3296766e JH	206	exit(128); /* error message already given */
d089ebaa JH	207	src++;
	208	}
	209	*dst = NULL;
	210	if (!*pathspec)
	211	return NULL;
	212	return pathspec;
d288a700 LT	213	}
d288a700 LT	214
5f5608bc	215	/*
ad1a382f	216	* Test if it looks like we're at a git directory.
5e7bfe25	217	* We want to see:
5f5608bc	218	*
790296fd	219	* - either an objects/ directory _or_ the proper
5f5608bc	220	* GIT_OBJECT_DIRECTORY environment variable
ad1a382f	221	* - a refs/ directory
8098a178	222	* - either a HEAD symlink or a HEAD file that is formatted as
c847f537 JH	223	* a proper "ref:", or a regular file HEAD that has a properly
c847f537 JH	224	* formatted sha1 object name.
5f5608bc	225	*/
ad1a382f	226	static int is_git_directory(const char *suspect)
5f5608bc	227	{
ad1a382f SP	228	char path[PATH_MAX];
	229	size_t len = strlen(suspect);
	230
	231	strcpy(path, suspect);
	232	if (getenv(DB_ENVIRONMENT)) {
	233	if (access(getenv(DB_ENVIRONMENT), X_OK))
	234	return 0;
	235	}
	236	else {
	237	strcpy(path + len, "/objects");
	238	if (access(path, X_OK))
	239	return 0;
	240	}
	241
	242	strcpy(path + len, "/refs");
	243	if (access(path, X_OK))
8098a178	244	return 0;
ad1a382f SP	245
ad1a382f SP	246	strcpy(path + len, "/HEAD");
c847f537	247	if (validate_headref(path))
ad1a382f SP	248	return 0;
ad1a382f SP	249
8098a178	250	return 1;
5f5608bc LT	251	}
5f5608bc LT	252
68025633 JS	253	int is_inside_git_dir(void)
68025633 JS	254	{
e90fdc39 JS	255	if (inside_git_dir < 0)
	256	inside_git_dir = is_inside_dir(get_git_dir());
	257	return inside_git_dir;
892c41b9 ML	258	}
892c41b9 ML	259
892c41b9 ML	260	int is_inside_work_tree(void)
892c41b9 ML	261	{
e90fdc39 JS	262	if (inside_work_tree < 0)
	263	inside_work_tree = is_inside_dir(get_git_work_tree());
	264	return inside_work_tree;
892c41b9 ML	265	}
892c41b9 ML	266
e90fdc39	267	/*
7efeb8f0 JS	268	* set_work_tree() is only ever called if you set GIT_DIR explicitely.
	269	* The old behaviour (which we retain here) is to set the work tree root
	270	* to the cwd, unless overridden by the config, the command line, or
	271	* GIT_WORK_TREE.
e90fdc39	272	*/
7efeb8f0	273	static const char set_work_tree(const char dir)
892c41b9	274	{
7efeb8f0	275	char buffer[PATH_MAX + 1];
e90fdc39	276
7efeb8f0 JS	277	if (!getcwd(buffer, sizeof(buffer)))
	278	die ("Could not get the current working directory");
	279	git_work_tree_cfg = xstrdup(buffer);
e90fdc39 JS	280	inside_work_tree = 1;
e90fdc39 JS	281
7efeb8f0	282	return NULL;
68025633 JS	283	}
68025633 JS	284
f3fa1838 JH	285	void setup_work_tree(void)
f3fa1838 JH	286	{
354e6534 JS	287	const char work_tree, git_dir;
	288	static int initialized = 0;
	289
	290	if (initialized)
	291	return;
	292	work_tree = get_git_work_tree();
	293	git_dir = get_git_dir();
59f0f2f3 MH	294	if (!is_absolute_path(git_dir))
	295	set_git_dir(make_absolute_path(git_dir));
	296	if (!work_tree \|\| chdir(work_tree))
	297	die("This operation must be run in a work tree");
354e6534	298	initialized = 1;
59f0f2f3 MH	299	}
59f0f2f3 MH	300
9459aa77 NTND	301	static int check_repository_format_gently(int *nongit_ok)
	302	{
	303	git_config(check_repository_format_version);
	304	if (GIT_REPO_VERSION < repository_format_version) {
	305	if (!nongit_ok)
	306	die ("Expected git repo version <= %d, found %d",
	307	GIT_REPO_VERSION, repository_format_version);
	308	warning("Expected git repo version <= %d, found %d",
	309	GIT_REPO_VERSION, repository_format_version);
	310	warning("Please upgrade Git");
	311	*nongit_ok = -1;
	312	return -1;
	313	}
	314	return 0;
	315	}
	316
e90fdc39 JS	317	/*
	318	* We cannot decide in this function whether we are in the work tree or
	319	* not, since the config can only be read _after_ this function was called.
	320	*/
4ca06608	321	const char setup_git_directory_gently(int nongit_ok)
d288a700	322	{
e90fdc39	323	const char *work_tree_env = getenv(GIT_WORK_TREE_ENVIRONMENT);
d288a700	324	static char cwd[PATH_MAX+1];
e90fdc39 JS	325	const char *gitdirenv;
e90fdc39 JS	326	int len, offset;
d288a700	327
af05d679 SG	328	/*
	329	* Let's assume that we are in a git repository.
	330	* If it turns out later that we are somewhere else, the value will be
	331	* updated accordingly.
	332	*/
	333	if (nongit_ok)
	334	*nongit_ok = 0;
	335
e90fdc39 JS	336	/*
	337	* If GIT_DIR is set explicitly, we're not going
	338	* to do any discovery, but we still do repository
	339	* validation.
	340	*/
ad1a382f	341	gitdirenv = getenv(GIT_DIR_ENVIRONMENT);
e90fdc39 JS	342	if (gitdirenv) {
	343	if (PATH_MAX - 40 < strlen(gitdirenv))
	344	die("'$%s' too big", GIT_DIR_ENVIRONMENT);
	345	if (is_git_directory(gitdirenv)) {
dd5c8af1 JS	346	static char buffer[1024 + 1];
	347	const char *retval;
	348
138dd1e9 NTND	349	if (!work_tree_env) {
138dd1e9 NTND	350	retval = set_work_tree(gitdirenv);
9459aa77 NTND	351	/* config may override worktree */
	352	if (check_repository_format_gently(nongit_ok))
	353	return NULL;
138dd1e9 NTND	354	return retval;
138dd1e9 NTND	355	}
9459aa77 NTND	356	if (check_repository_format_gently(nongit_ok))
9459aa77 NTND	357	return NULL;
dd5c8af1 JS	358	retval = get_relative_cwd(buffer, sizeof(buffer) - 1,
	359	get_git_work_tree());
	360	if (!retval \|\| !*retval)
	361	return NULL;
	362	set_git_dir(make_absolute_path(gitdirenv));
	363	if (chdir(work_tree_env) < 0)
	364	die ("Could not chdir to %s", work_tree_env);
	365	strcat(buffer, "/");
	366	return retval;
892c41b9	367	}
3a3c3fc4	368	if (nongit_ok) {
41e95f69 ML	369	*nongit_ok = 1;
	370	return NULL;
	371	}
ad1a382f	372	die("Not a git repository: '%s'", gitdirenv);
5e7bfe25	373	}
d288a700	374
f66a4d68	375	if (!getcwd(cwd, sizeof(cwd)-1))
d288a700 LT	376	die("Unable to read current working directory");
d288a700 LT	377
892c41b9	378	/*
e90fdc39 JS	379	* Test in the following order (relative to the cwd):
	380	* - .git/
	381	* - ./ (bare)
	382	* - ../.git/
	383	* - ../ (bare)
	384	* - ../../.git/
	385	* etc.
892c41b9	386	*/
e90fdc39 JS	387	offset = len = strlen(cwd);
	388	for (;;) {
	389	if (is_git_directory(DEFAULT_GIT_DIR_ENVIRONMENT))
	390	break;
	391	if (is_git_directory(".")) {
	392	inside_git_dir = 1;
	393	if (!work_tree_env)
	394	inside_work_tree = 0;
	395	setenv(GIT_DIR_ENVIRONMENT, ".", 1);
9459aa77	396	check_repository_format_gently(nongit_ok);
892c41b9 ML	397	return NULL;
892c41b9 ML	398	}
e90fdc39 JS	399	chdir("..");
	400	do {
	401	if (!offset) {
	402	if (nongit_ok) {
	403	if (chdir(cwd))
	404	die("Cannot come back to cwd");
	405	*nongit_ok = 1;
	406	return NULL;
	407	}
	408	die("Not a git repository");
	409	}
	410	} while (cwd[--offset] != '/');
892c41b9 ML	411	}
892c41b9 ML	412
e90fdc39 JS	413	inside_git_dir = 0;
	414	if (!work_tree_env)
	415	inside_work_tree = 1;
	416	git_work_tree_cfg = xstrndup(cwd, offset);
9459aa77 NTND	417	if (check_repository_format_gently(nongit_ok))
9459aa77 NTND	418	return NULL;
e90fdc39	419	if (offset == len)
d288a700 LT	420	return NULL;
d288a700 LT	421
e90fdc39 JS	422	/* Make "offset" point to past the '/', and add a '/' at the end */
	423	offset++;
	424	cwd[len++] = '/';
	425	cwd[len] = 0;
	426	return cwd + offset;
d288a700	427	}
5e7bfe25	428
94df2506 JH	429	int git_config_perm(const char var, const char value)
	430	{
	431	if (value) {
83525227	432	int i;
94df2506 JH	433	if (!strcmp(value, "umask"))
	434	return PERM_UMASK;
	435	if (!strcmp(value, "group"))
	436	return PERM_GROUP;
	437	if (!strcmp(value, "all") \|\|
	438	!strcmp(value, "world") \|\|
	439	!strcmp(value, "everybody"))
	440	return PERM_EVERYBODY;
83525227 JS	441	i = atoi(value);
	442	if (i > 1)
	443	return i;
94df2506 JH	444	}
	445	return git_config_bool(var, value);
	446	}
	447
ab9cb76f JH	448	int check_repository_format_version(const char var, const char value)
ab9cb76f JH	449	{
299726d5 JS	450	if (strcmp(var, "core.repositoryformatversion") == 0)
299726d5 JS	451	repository_format_version = git_config_int(var, value);
457f06d6	452	else if (strcmp(var, "core.sharedrepository") == 0)
94df2506	453	shared_repository = git_config_perm(var, value);
e90fdc39 JS	454	else if (strcmp(var, "core.bare") == 0) {
	455	is_bare_repository_cfg = git_config_bool(var, value);
	456	if (is_bare_repository_cfg == 1)
	457	inside_work_tree = -1;
	458	} else if (strcmp(var, "core.worktree") == 0) {
180483c5 JH	459	if (!value)
180483c5 JH	460	return config_error_nonbool(var);
8e0f7003	461	free(git_work_tree_cfg);
e90fdc39 JS	462	git_work_tree_cfg = xstrdup(value);
	463	inside_work_tree = -1;
	464	}
299726d5	465	return 0;
ab9cb76f JH	466	}
	467
	468	int check_repository_format(void)
	469	{
9459aa77	470	return check_repository_format_gently(NULL);
ab9cb76f JH	471	}
ab9cb76f JH	472
5e7bfe25 JH	473	const char *setup_git_directory(void)
5e7bfe25 JH	474	{
4ca06608	475	const char *retval = setup_git_directory_gently(NULL);
e90fdc39 JS	476
	477	/* If the work tree is not the default one, recompute prefix */
	478	if (inside_work_tree < 0) {
	479	static char buffer[PATH_MAX + 1];
	480	char *rel;
	481	if (retval && chdir(retval))
	482	die ("Could not jump back into original cwd");
	483	rel = get_relative_cwd(buffer, PATH_MAX, get_git_work_tree());
	484	return rel && *rel ? strcat(rel, "/") : NULL;
	485	}
	486
5e7bfe25 JH	487	return retval;
5e7bfe25 JH	488	}