1#include "cache.h"
2const char *prefix_path(const char *prefix, int len, const char *path)
4{
5 const char *orig = path;
6 for (;;) {
7 char c;
8 if (*path != '.')
9 break;
10 c = path[1];
11 /* "." */
12 if (!c) {
13 path++;
14 break;
15 }
16 /* "./" */
17 if (c == '/') {
18 path += 2;
19 continue;
20 }
21 if (c != '.')
22 break;
23 c = path[2];
24 if (!c)
25 path += 2;
26 else if (c == '/')
27 path += 3;
28 else
29 break;
30 /* ".." and "../" */
31 /* Remove last component of the prefix */
32 do {
33 if (!len)
34 die("'%s' is outside repository", orig);
35 len--;
36 } while (len && prefix[len-1] != '/');
37 continue;
38 }
39 if (len) {
40 int speclen = strlen(path);
41 char *n = xmalloc(speclen + len + 1);
42
43 memcpy(n, prefix, len);
44 memcpy(n + len, path, speclen+1);
45 path = n;
46 }
47 return path;
48}
49/*
51 * Unlike prefix_path, this should be used if the named file does
52 * not have to interact with index entry; i.e. name of a random file
53 * on the filesystem.
54 */
55const char *prefix_filename(const char *pfx, int pfx_len, const char *arg)
56{
57 static char path[PATH_MAX];
58 if (!pfx || !*pfx || arg[0] == '/')
59 return arg;
60 memcpy(path, pfx, pfx_len);
61 strcpy(path + pfx_len, arg);
62 return path;
63}
64/*
66 * Verify a filename that we got as an argument for a pathspec
67 * entry. Note that a filename that begins with "-" never verifies
68 * as true, because even if such a filename were to exist, we want
69 * it to be preceded by the "--" marker (or we want the user to
70 * use a format like "./-filename")
71 */
72void verify_filename(const char *prefix, const char *arg)
73{
74 const char *name;
75 struct stat st;
76 if (*arg == '-')
78 die("bad flag '%s' used after filename", arg);
79 name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
80 if (!lstat(name, &st))
81 return;
82 if (errno == ENOENT)
83 die("ambiguous argument '%s': unknown revision or path not in the working tree.\n"
84 "Use '--' to separate paths from revisions", arg);
85 die("'%s': %s", arg, strerror(errno));
86}
87/*
89 * Opposite of the above: the command line did not have -- marker
90 * and we parsed the arg as a refname. It should not be interpretable
91 * as a filename.
92 */
93void verify_non_filename(const char *prefix, const char *arg)
94{
95 const char *name;
96 struct stat st;
97 if (is_inside_git_dir())
99 return;
100 if (*arg == '-')
101 return; /* flag */
102 name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
103 if (!lstat(name, &st))
104 die("ambiguous argument '%s': both revision and filename\n"
105 "Use '--' to separate filenames from revisions", arg);
106 if (errno != ENOENT)
107 die("'%s': %s", arg, strerror(errno));
108}
109const char **get_pathspec(const char *prefix, const char **pathspec)
111{
112 const char *entry = *pathspec;
113 const char **p;
114 int prefixlen;
115 if (!prefix && !entry)
117 return NULL;
118 if (!entry) {
120 static const char *spec[2];
121 spec[0] = prefix;
122 spec[1] = NULL;
123 return spec;
124 }
125 /* Otherwise we have to re-write the entries.. */
127 p = pathspec;
128 prefixlen = prefix ? strlen(prefix) : 0;
129 do {
130 *p = prefix_path(prefix, prefixlen, entry);
131 } while ((entry = *++p) != NULL);
132 return (const char **) pathspec;
133}
134/*
136 * Test if it looks like we're at a git directory.
137 * We want to see:
138 *
139 * - either a objects/ directory _or_ the proper
140 * GIT_OBJECT_DIRECTORY environment variable
141 * - a refs/ directory
142 * - either a HEAD symlink or a HEAD file that is formatted as
143 * a proper "ref:", or a regular file HEAD that has a properly
144 * formatted sha1 object name.
145 */
146static int is_git_directory(const char *suspect)
147{
148 char path[PATH_MAX];
149 size_t len = strlen(suspect);
150 strcpy(path, suspect);
152 if (getenv(DB_ENVIRONMENT)) {
153 if (access(getenv(DB_ENVIRONMENT), X_OK))
154 return 0;
155 }
156 else {
157 strcpy(path + len, "/objects");
158 if (access(path, X_OK))
159 return 0;
160 }
161 strcpy(path + len, "/refs");
163 if (access(path, X_OK))
164 return 0;
165 strcpy(path + len, "/HEAD");
167 if (validate_headref(path))
168 return 0;
169 return 1;
171}
172static int inside_git_dir = -1;
174int is_inside_git_dir(void)
176{
177 if (inside_git_dir < 0) {
178 char buffer[1024];
179 if (is_bare_repository())
181 return (inside_git_dir = 1);
182 if (getcwd(buffer, sizeof(buffer))) {
183 const char *git_dir = get_git_dir(), *cwd = buffer;
184 while (*git_dir && *git_dir == *cwd) {
185 git_dir++;
186 cwd++;
187 }
188 inside_git_dir = !*git_dir;
189 } else
190 inside_git_dir = 0;
191 }
192 return inside_git_dir;
193}
194const char *setup_git_directory_gently(int *nongit_ok)
196{
197 static char cwd[PATH_MAX+1];
198 const char *gitdirenv;
199 int len, offset;
200 /*
202 * If GIT_DIR is set explicitly, we're not going
203 * to do any discovery, but we still do repository
204 * validation.
205 */
206 gitdirenv = getenv(GIT_DIR_ENVIRONMENT);
207 if (gitdirenv) {
208 if (PATH_MAX - 40 < strlen(gitdirenv))
209 die("'$%s' too big", GIT_DIR_ENVIRONMENT);
210 if (is_git_directory(gitdirenv))
211 return NULL;
212 if (nongit_ok) {
213 *nongit_ok = 1;
214 return NULL;
215 }
216 die("Not a git repository: '%s'", gitdirenv);
217 }
218 if (!getcwd(cwd, sizeof(cwd)-1) || cwd[0] != '/')
220 die("Unable to read current working directory");
221 offset = len = strlen(cwd);
223 for (;;) {
224 if (is_git_directory(".git"))
225 break;
226 chdir("..");
227 do {
228 if (!offset) {
229 if (is_git_directory(cwd)) {
230 if (chdir(cwd))
231 die("Cannot come back to cwd");
232 setenv(GIT_DIR_ENVIRONMENT, cwd, 1);
233 inside_git_dir = 1;
234 return NULL;
235 }
236 if (nongit_ok) {
237 if (chdir(cwd))
238 die("Cannot come back to cwd");
239 *nongit_ok = 1;
240 return NULL;
241 }
242 die("Not a git repository");
243 }
244 } while (cwd[--offset] != '/');
245 }
246 if (offset == len)
248 return NULL;
249 /* Make "offset" point to past the '/', and add a '/' at the end */
251 offset++;
252 cwd[len++] = '/';
253 cwd[len] = 0;
254 inside_git_dir = !prefixcmp(cwd + offset, ".git/");
255 return cwd + offset;
256}
257int git_config_perm(const char *var, const char *value)
259{
260 if (value) {
261 if (!strcmp(value, "umask"))
262 return PERM_UMASK;
263 if (!strcmp(value, "group"))
264 return PERM_GROUP;
265 if (!strcmp(value, "all") ||
266 !strcmp(value, "world") ||
267 !strcmp(value, "everybody"))
268 return PERM_EVERYBODY;
269 }
270 return git_config_bool(var, value);
271}
272int check_repository_format_version(const char *var, const char *value)
274{
275 if (strcmp(var, "core.repositoryformatversion") == 0)
276 repository_format_version = git_config_int(var, value);
277 else if (strcmp(var, "core.sharedrepository") == 0)
278 shared_repository = git_config_perm(var, value);
279 return 0;
280}
281int check_repository_format(void)
283{
284 git_config(check_repository_format_version);
285 if (GIT_REPO_VERSION < repository_format_version)
286 die ("Expected git repo version <= %d, found %d",
287 GIT_REPO_VERSION, repository_format_version);
288 return 0;
289}
290const char *setup_git_directory(void)
292{
293 const char *retval = setup_git_directory_gently(NULL);
294 check_repository_format();
295 return retval;
296}