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