Merge branch 'kk/maint-for-each-ref-multi-sort' into maint-1.7.11
[git] / setup.c
1 #include "cache.h"
2 #include "dir.h"
3
4 static int inside_git_dir = -1;
5 static int inside_work_tree = -1;
6
7 static char *prefix_path_gently(const char *prefix, int len, const char *path)
8 {
9         const char *orig = path;
10         char *sanitized;
11         if (is_absolute_path(orig)) {
12                 const char *temp = real_path(path);
13                 sanitized = xmalloc(len + strlen(temp) + 1);
14                 strcpy(sanitized, temp);
15         } else {
16                 sanitized = xmalloc(len + strlen(path) + 1);
17                 if (len)
18                         memcpy(sanitized, prefix, len);
19                 strcpy(sanitized + len, path);
20         }
21         if (normalize_path_copy(sanitized, sanitized))
22                 goto error_out;
23         if (is_absolute_path(orig)) {
24                 size_t root_len, len, total;
25                 const char *work_tree = get_git_work_tree();
26                 if (!work_tree)
27                         goto error_out;
28                 len = strlen(work_tree);
29                 root_len = offset_1st_component(work_tree);
30                 total = strlen(sanitized) + 1;
31                 if (strncmp(sanitized, work_tree, len) ||
32                     (len > root_len && sanitized[len] != '\0' && sanitized[len] != '/')) {
33                 error_out:
34                         free(sanitized);
35                         return NULL;
36                 }
37                 if (sanitized[len] == '/')
38                         len++;
39                 memmove(sanitized, sanitized + len, total - len);
40         }
41         return sanitized;
42 }
43
44 char *prefix_path(const char *prefix, int len, const char *path)
45 {
46         char *r = prefix_path_gently(prefix, len, path);
47         if (!r)
48                 die("'%s' is outside repository", path);
49         return r;
50 }
51
52 int path_inside_repo(const char *prefix, const char *path)
53 {
54         int len = prefix ? strlen(prefix) : 0;
55         char *r = prefix_path_gently(prefix, len, path);
56         if (r) {
57                 free(r);
58                 return 1;
59         }
60         return 0;
61 }
62
63 int check_filename(const char *prefix, const char *arg)
64 {
65         const char *name;
66         struct stat st;
67
68         name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
69         if (!lstat(name, &st))
70                 return 1; /* file exists */
71         if (errno == ENOENT || errno == ENOTDIR)
72                 return 0; /* file does not exist */
73         die_errno("failed to stat '%s'", arg);
74 }
75
76 static void NORETURN die_verify_filename(const char *prefix,
77                                          const char *arg,
78                                          int diagnose_misspelt_rev)
79 {
80         unsigned char sha1[20];
81         unsigned mode;
82
83         if (!diagnose_misspelt_rev)
84                 die("%s: no such path in the working tree.\n"
85                     "Use 'git <command> -- <path>...' to specify paths that do not exist locally.",
86                     arg);
87         /*
88          * Saying "'(icase)foo' does not exist in the index" when the
89          * user gave us ":(icase)foo" is just stupid.  A magic pathspec
90          * begins with a colon and is followed by a non-alnum; do not
91          * let get_sha1_with_mode_1(only_to_die=1) to even trigger.
92          */
93         if (!(arg[0] == ':' && !isalnum(arg[1])))
94                 /* try a detailed diagnostic ... */
95                 get_sha1_with_mode_1(arg, sha1, &mode, 1, prefix);
96
97         /* ... or fall back the most general message. */
98         die("ambiguous argument '%s': unknown revision or path not in the working tree.\n"
99             "Use '--' to separate paths from revisions, like this:\n"
100             "'git <command> [<revision>...] -- [<file>...]'", arg);
101
102 }
103
104 /*
105  * Verify a filename that we got as an argument for a pathspec
106  * entry. Note that a filename that begins with "-" never verifies
107  * as true, because even if such a filename were to exist, we want
108  * it to be preceded by the "--" marker (or we want the user to
109  * use a format like "./-filename")
110  *
111  * The "diagnose_misspelt_rev" is used to provide a user-friendly
112  * diagnosis when dying upon finding that "name" is not a pathname.
113  * If set to 1, the diagnosis will try to diagnose "name" as an
114  * invalid object name (e.g. HEAD:foo). If set to 0, the diagnosis
115  * will only complain about an inexisting file.
116  *
117  * This function is typically called to check that a "file or rev"
118  * argument is unambiguous. In this case, the caller will want
119  * diagnose_misspelt_rev == 1 when verifying the first non-rev
120  * argument (which could have been a revision), and
121  * diagnose_misspelt_rev == 0 for the next ones (because we already
122  * saw a filename, there's not ambiguity anymore).
123  */
124 void verify_filename(const char *prefix,
125                      const char *arg,
126                      int diagnose_misspelt_rev)
127 {
128         if (*arg == '-')
129                 die("bad flag '%s' used after filename", arg);
130         if (check_filename(prefix, arg))
131                 return;
132         die_verify_filename(prefix, arg, diagnose_misspelt_rev);
133 }
134
135 /*
136  * Opposite of the above: the command line did not have -- marker
137  * and we parsed the arg as a refname.  It should not be interpretable
138  * as a filename.
139  */
140 void verify_non_filename(const char *prefix, const char *arg)
141 {
142         if (!is_inside_work_tree() || is_inside_git_dir())
143                 return;
144         if (*arg == '-')
145                 return; /* flag */
146         if (!check_filename(prefix, arg))
147                 return;
148         die("ambiguous argument '%s': both revision and filename\n"
149             "Use '--' to separate paths from revisions, like this:\n"
150             "'git <command> [<revision>...] -- [<file>...]'", arg);
151 }
152
153 /*
154  * Magic pathspec
155  *
156  * NEEDSWORK: These need to be moved to dir.h or even to a new
157  * pathspec.h when we restructure get_pathspec() users to use the
158  * "struct pathspec" interface.
159  *
160  * Possible future magic semantics include stuff like:
161  *
162  *      { PATHSPEC_NOGLOB, '!', "noglob" },
163  *      { PATHSPEC_ICASE, '\0', "icase" },
164  *      { PATHSPEC_RECURSIVE, '*', "recursive" },
165  *      { PATHSPEC_REGEXP, '\0', "regexp" },
166  *
167  */
168 #define PATHSPEC_FROMTOP    (1<<0)
169
170 static struct pathspec_magic {
171         unsigned bit;
172         char mnemonic; /* this cannot be ':'! */
173         const char *name;
174 } pathspec_magic[] = {
175         { PATHSPEC_FROMTOP, '/', "top" },
176 };
177
178 /*
179  * Take an element of a pathspec and check for magic signatures.
180  * Append the result to the prefix.
181  *
182  * For now, we only parse the syntax and throw out anything other than
183  * "top" magic.
184  *
185  * NEEDSWORK: This needs to be rewritten when we start migrating
186  * get_pathspec() users to use the "struct pathspec" interface.  For
187  * example, a pathspec element may be marked as case-insensitive, but
188  * the prefix part must always match literally, and a single stupid
189  * string cannot express such a case.
190  */
191 static const char *prefix_pathspec(const char *prefix, int prefixlen, const char *elt)
192 {
193         unsigned magic = 0;
194         const char *copyfrom = elt;
195         int i;
196
197         if (elt[0] != ':') {
198                 ; /* nothing to do */
199         } else if (elt[1] == '(') {
200                 /* longhand */
201                 const char *nextat;
202                 for (copyfrom = elt + 2;
203                      *copyfrom && *copyfrom != ')';
204                      copyfrom = nextat) {
205                         size_t len = strcspn(copyfrom, ",)");
206                         if (copyfrom[len] == ')')
207                                 nextat = copyfrom + len;
208                         else
209                                 nextat = copyfrom + len + 1;
210                         if (!len)
211                                 continue;
212                         for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++)
213                                 if (strlen(pathspec_magic[i].name) == len &&
214                                     !strncmp(pathspec_magic[i].name, copyfrom, len)) {
215                                         magic |= pathspec_magic[i].bit;
216                                         break;
217                                 }
218                         if (ARRAY_SIZE(pathspec_magic) <= i)
219                                 die("Invalid pathspec magic '%.*s' in '%s'",
220                                     (int) len, copyfrom, elt);
221                 }
222                 if (*copyfrom == ')')
223                         copyfrom++;
224         } else {
225                 /* shorthand */
226                 for (copyfrom = elt + 1;
227                      *copyfrom && *copyfrom != ':';
228                      copyfrom++) {
229                         char ch = *copyfrom;
230
231                         if (!is_pathspec_magic(ch))
232                                 break;
233                         for (i = 0; i < ARRAY_SIZE(pathspec_magic); i++)
234                                 if (pathspec_magic[i].mnemonic == ch) {
235                                         magic |= pathspec_magic[i].bit;
236                                         break;
237                                 }
238                         if (ARRAY_SIZE(pathspec_magic) <= i)
239                                 die("Unimplemented pathspec magic '%c' in '%s'",
240                                     ch, elt);
241                 }
242                 if (*copyfrom == ':')
243                         copyfrom++;
244         }
245
246         if (magic & PATHSPEC_FROMTOP)
247                 return xstrdup(copyfrom);
248         else
249                 return prefix_path(prefix, prefixlen, copyfrom);
250 }
251
252 const char **get_pathspec(const char *prefix, const char **pathspec)
253 {
254         const char *entry = *pathspec;
255         const char **src, **dst;
256         int prefixlen;
257
258         if (!prefix && !entry)
259                 return NULL;
260
261         if (!entry) {
262                 static const char *spec[2];
263                 spec[0] = prefix;
264                 spec[1] = NULL;
265                 return spec;
266         }
267
268         /* Otherwise we have to re-write the entries.. */
269         src = pathspec;
270         dst = pathspec;
271         prefixlen = prefix ? strlen(prefix) : 0;
272         while (*src) {
273                 *(dst++) = prefix_pathspec(prefix, prefixlen, *src);
274                 src++;
275         }
276         *dst = NULL;
277         if (!*pathspec)
278                 return NULL;
279         return pathspec;
280 }
281
282 /*
283  * Test if it looks like we're at a git directory.
284  * We want to see:
285  *
286  *  - either an objects/ directory _or_ the proper
287  *    GIT_OBJECT_DIRECTORY environment variable
288  *  - a refs/ directory
289  *  - either a HEAD symlink or a HEAD file that is formatted as
290  *    a proper "ref:", or a regular file HEAD that has a properly
291  *    formatted sha1 object name.
292  */
293 int is_git_directory(const char *suspect)
294 {
295         char path[PATH_MAX];
296         size_t len = strlen(suspect);
297
298         if (PATH_MAX <= len + strlen("/objects"))
299                 die("Too long path: %.*s", 60, suspect);
300         strcpy(path, suspect);
301         if (getenv(DB_ENVIRONMENT)) {
302                 if (access(getenv(DB_ENVIRONMENT), X_OK))
303                         return 0;
304         }
305         else {
306                 strcpy(path + len, "/objects");
307                 if (access(path, X_OK))
308                         return 0;
309         }
310
311         strcpy(path + len, "/refs");
312         if (access(path, X_OK))
313                 return 0;
314
315         strcpy(path + len, "/HEAD");
316         if (validate_headref(path))
317                 return 0;
318
319         return 1;
320 }
321
322 int is_inside_git_dir(void)
323 {
324         if (inside_git_dir < 0)
325                 inside_git_dir = is_inside_dir(get_git_dir());
326         return inside_git_dir;
327 }
328
329 int is_inside_work_tree(void)
330 {
331         if (inside_work_tree < 0)
332                 inside_work_tree = is_inside_dir(get_git_work_tree());
333         return inside_work_tree;
334 }
335
336 void setup_work_tree(void)
337 {
338         const char *work_tree, *git_dir;
339         static int initialized = 0;
340
341         if (initialized)
342                 return;
343         work_tree = get_git_work_tree();
344         git_dir = get_git_dir();
345         if (!is_absolute_path(git_dir))
346                 git_dir = real_path(get_git_dir());
347         if (!work_tree || chdir(work_tree))
348                 die("This operation must be run in a work tree");
349
350         /*
351          * Make sure subsequent git processes find correct worktree
352          * if $GIT_WORK_TREE is set relative
353          */
354         if (getenv(GIT_WORK_TREE_ENVIRONMENT))
355                 setenv(GIT_WORK_TREE_ENVIRONMENT, ".", 1);
356
357         set_git_dir(relative_path(git_dir, work_tree));
358         initialized = 1;
359 }
360
361 static int check_repository_format_gently(const char *gitdir, int *nongit_ok)
362 {
363         char repo_config[PATH_MAX+1];
364
365         /*
366          * git_config() can't be used here because it calls git_pathdup()
367          * to get $GIT_CONFIG/config. That call will make setup_git_env()
368          * set git_dir to ".git".
369          *
370          * We are in gitdir setup, no git dir has been found useable yet.
371          * Use a gentler version of git_config() to check if this repo
372          * is a good one.
373          */
374         snprintf(repo_config, PATH_MAX, "%s/config", gitdir);
375         git_config_early(check_repository_format_version, NULL, repo_config);
376         if (GIT_REPO_VERSION < repository_format_version) {
377                 if (!nongit_ok)
378                         die ("Expected git repo version <= %d, found %d",
379                              GIT_REPO_VERSION, repository_format_version);
380                 warning("Expected git repo version <= %d, found %d",
381                         GIT_REPO_VERSION, repository_format_version);
382                 warning("Please upgrade Git");
383                 *nongit_ok = -1;
384                 return -1;
385         }
386         return 0;
387 }
388
389 /*
390  * Try to read the location of the git directory from the .git file,
391  * return path to git directory if found.
392  */
393 const char *read_gitfile(const char *path)
394 {
395         char *buf;
396         char *dir;
397         const char *slash;
398         struct stat st;
399         int fd;
400         ssize_t len;
401
402         if (stat(path, &st))
403                 return NULL;
404         if (!S_ISREG(st.st_mode))
405                 return NULL;
406         fd = open(path, O_RDONLY);
407         if (fd < 0)
408                 die_errno("Error opening '%s'", path);
409         buf = xmalloc(st.st_size + 1);
410         len = read_in_full(fd, buf, st.st_size);
411         close(fd);
412         if (len != st.st_size)
413                 die("Error reading %s", path);
414         buf[len] = '\0';
415         if (prefixcmp(buf, "gitdir: "))
416                 die("Invalid gitfile format: %s", path);
417         while (buf[len - 1] == '\n' || buf[len - 1] == '\r')
418                 len--;
419         if (len < 9)
420                 die("No path in gitfile: %s", path);
421         buf[len] = '\0';
422         dir = buf + 8;
423
424         if (!is_absolute_path(dir) && (slash = strrchr(path, '/'))) {
425                 size_t pathlen = slash+1 - path;
426                 size_t dirlen = pathlen + len - 8;
427                 dir = xmalloc(dirlen + 1);
428                 strncpy(dir, path, pathlen);
429                 strncpy(dir + pathlen, buf + 8, len - 8);
430                 dir[dirlen] = '\0';
431                 free(buf);
432                 buf = dir;
433         }
434
435         if (!is_git_directory(dir))
436                 die("Not a git repository: %s", dir);
437         path = real_path(dir);
438
439         free(buf);
440         return path;
441 }
442
443 static const char *setup_explicit_git_dir(const char *gitdirenv,
444                                           char *cwd, int len,
445                                           int *nongit_ok)
446 {
447         const char *work_tree_env = getenv(GIT_WORK_TREE_ENVIRONMENT);
448         const char *worktree;
449         char *gitfile;
450         int offset;
451
452         if (PATH_MAX - 40 < strlen(gitdirenv))
453                 die("'$%s' too big", GIT_DIR_ENVIRONMENT);
454
455         gitfile = (char*)read_gitfile(gitdirenv);
456         if (gitfile) {
457                 gitfile = xstrdup(gitfile);
458                 gitdirenv = gitfile;
459         }
460
461         if (!is_git_directory(gitdirenv)) {
462                 if (nongit_ok) {
463                         *nongit_ok = 1;
464                         free(gitfile);
465                         return NULL;
466                 }
467                 die("Not a git repository: '%s'", gitdirenv);
468         }
469
470         if (check_repository_format_gently(gitdirenv, nongit_ok)) {
471                 free(gitfile);
472                 return NULL;
473         }
474
475         /* #3, #7, #11, #15, #19, #23, #27, #31 (see t1510) */
476         if (work_tree_env)
477                 set_git_work_tree(work_tree_env);
478         else if (is_bare_repository_cfg > 0) {
479                 if (git_work_tree_cfg) /* #22.2, #30 */
480                         die("core.bare and core.worktree do not make sense");
481
482                 /* #18, #26 */
483                 set_git_dir(gitdirenv);
484                 free(gitfile);
485                 return NULL;
486         }
487         else if (git_work_tree_cfg) { /* #6, #14 */
488                 if (is_absolute_path(git_work_tree_cfg))
489                         set_git_work_tree(git_work_tree_cfg);
490                 else {
491                         char core_worktree[PATH_MAX];
492                         if (chdir(gitdirenv))
493                                 die_errno("Could not chdir to '%s'", gitdirenv);
494                         if (chdir(git_work_tree_cfg))
495                                 die_errno("Could not chdir to '%s'", git_work_tree_cfg);
496                         if (!getcwd(core_worktree, PATH_MAX))
497                                 die_errno("Could not get directory '%s'", git_work_tree_cfg);
498                         if (chdir(cwd))
499                                 die_errno("Could not come back to cwd");
500                         set_git_work_tree(core_worktree);
501                 }
502         }
503         else /* #2, #10 */
504                 set_git_work_tree(".");
505
506         /* set_git_work_tree() must have been called by now */
507         worktree = get_git_work_tree();
508
509         /* both get_git_work_tree() and cwd are already normalized */
510         if (!strcmp(cwd, worktree)) { /* cwd == worktree */
511                 set_git_dir(gitdirenv);
512                 free(gitfile);
513                 return NULL;
514         }
515
516         offset = dir_inside_of(cwd, worktree);
517         if (offset >= 0) {      /* cwd inside worktree? */
518                 set_git_dir(real_path(gitdirenv));
519                 if (chdir(worktree))
520                         die_errno("Could not chdir to '%s'", worktree);
521                 cwd[len++] = '/';
522                 cwd[len] = '\0';
523                 free(gitfile);
524                 return cwd + offset;
525         }
526
527         /* cwd outside worktree */
528         set_git_dir(gitdirenv);
529         free(gitfile);
530         return NULL;
531 }
532
533 static const char *setup_discovered_git_dir(const char *gitdir,
534                                             char *cwd, int offset, int len,
535                                             int *nongit_ok)
536 {
537         if (check_repository_format_gently(gitdir, nongit_ok))
538                 return NULL;
539
540         /* --work-tree is set without --git-dir; use discovered one */
541         if (getenv(GIT_WORK_TREE_ENVIRONMENT) || git_work_tree_cfg) {
542                 if (offset != len && !is_absolute_path(gitdir))
543                         gitdir = xstrdup(real_path(gitdir));
544                 if (chdir(cwd))
545                         die_errno("Could not come back to cwd");
546                 return setup_explicit_git_dir(gitdir, cwd, len, nongit_ok);
547         }
548
549         /* #16.2, #17.2, #20.2, #21.2, #24, #25, #28, #29 (see t1510) */
550         if (is_bare_repository_cfg > 0) {
551                 set_git_dir(offset == len ? gitdir : real_path(gitdir));
552                 if (chdir(cwd))
553                         die_errno("Could not come back to cwd");
554                 return NULL;
555         }
556
557         /* #0, #1, #5, #8, #9, #12, #13 */
558         set_git_work_tree(".");
559         if (strcmp(gitdir, DEFAULT_GIT_DIR_ENVIRONMENT))
560                 set_git_dir(gitdir);
561         inside_git_dir = 0;
562         inside_work_tree = 1;
563         if (offset == len)
564                 return NULL;
565
566         /* Make "offset" point to past the '/', and add a '/' at the end */
567         offset++;
568         cwd[len++] = '/';
569         cwd[len] = 0;
570         return cwd + offset;
571 }
572
573 /* #16.1, #17.1, #20.1, #21.1, #22.1 (see t1510) */
574 static const char *setup_bare_git_dir(char *cwd, int offset, int len, int *nongit_ok)
575 {
576         int root_len;
577
578         if (check_repository_format_gently(".", nongit_ok))
579                 return NULL;
580
581         /* --work-tree is set without --git-dir; use discovered one */
582         if (getenv(GIT_WORK_TREE_ENVIRONMENT) || git_work_tree_cfg) {
583                 const char *gitdir;
584
585                 gitdir = offset == len ? "." : xmemdupz(cwd, offset);
586                 if (chdir(cwd))
587                         die_errno("Could not come back to cwd");
588                 return setup_explicit_git_dir(gitdir, cwd, len, nongit_ok);
589         }
590
591         inside_git_dir = 1;
592         inside_work_tree = 0;
593         if (offset != len) {
594                 if (chdir(cwd))
595                         die_errno("Cannot come back to cwd");
596                 root_len = offset_1st_component(cwd);
597                 cwd[offset > root_len ? offset : root_len] = '\0';
598                 set_git_dir(cwd);
599         }
600         else
601                 set_git_dir(".");
602         return NULL;
603 }
604
605 static const char *setup_nongit(const char *cwd, int *nongit_ok)
606 {
607         if (!nongit_ok)
608                 die("Not a git repository (or any of the parent directories): %s", DEFAULT_GIT_DIR_ENVIRONMENT);
609         if (chdir(cwd))
610                 die_errno("Cannot come back to cwd");
611         *nongit_ok = 1;
612         return NULL;
613 }
614
615 static dev_t get_device_or_die(const char *path, const char *prefix, int prefix_len)
616 {
617         struct stat buf;
618         if (stat(path, &buf)) {
619                 die_errno("failed to stat '%*s%s%s'",
620                                 prefix_len,
621                                 prefix ? prefix : "",
622                                 prefix ? "/" : "", path);
623         }
624         return buf.st_dev;
625 }
626
627 /*
628  * We cannot decide in this function whether we are in the work tree or
629  * not, since the config can only be read _after_ this function was called.
630  */
631 static const char *setup_git_directory_gently_1(int *nongit_ok)
632 {
633         const char *env_ceiling_dirs = getenv(CEILING_DIRECTORIES_ENVIRONMENT);
634         static char cwd[PATH_MAX+1];
635         const char *gitdirenv, *ret;
636         char *gitfile;
637         int len, offset, offset_parent, ceil_offset;
638         dev_t current_device = 0;
639         int one_filesystem = 1;
640
641         /*
642          * Let's assume that we are in a git repository.
643          * If it turns out later that we are somewhere else, the value will be
644          * updated accordingly.
645          */
646         if (nongit_ok)
647                 *nongit_ok = 0;
648
649         if (!getcwd(cwd, sizeof(cwd)-1))
650                 die_errno("Unable to read current working directory");
651         offset = len = strlen(cwd);
652
653         /*
654          * If GIT_DIR is set explicitly, we're not going
655          * to do any discovery, but we still do repository
656          * validation.
657          */
658         gitdirenv = getenv(GIT_DIR_ENVIRONMENT);
659         if (gitdirenv)
660                 return setup_explicit_git_dir(gitdirenv, cwd, len, nongit_ok);
661
662         ceil_offset = longest_ancestor_length(cwd, env_ceiling_dirs);
663         if (ceil_offset < 0 && has_dos_drive_prefix(cwd))
664                 ceil_offset = 1;
665
666         /*
667          * Test in the following order (relative to the cwd):
668          * - .git (file containing "gitdir: <path>")
669          * - .git/
670          * - ./ (bare)
671          * - ../.git
672          * - ../.git/
673          * - ../ (bare)
674          * - ../../.git/
675          *   etc.
676          */
677         one_filesystem = !git_env_bool("GIT_DISCOVERY_ACROSS_FILESYSTEM", 0);
678         if (one_filesystem)
679                 current_device = get_device_or_die(".", NULL, 0);
680         for (;;) {
681                 gitfile = (char*)read_gitfile(DEFAULT_GIT_DIR_ENVIRONMENT);
682                 if (gitfile)
683                         gitdirenv = gitfile = xstrdup(gitfile);
684                 else {
685                         if (is_git_directory(DEFAULT_GIT_DIR_ENVIRONMENT))
686                                 gitdirenv = DEFAULT_GIT_DIR_ENVIRONMENT;
687                 }
688
689                 if (gitdirenv) {
690                         ret = setup_discovered_git_dir(gitdirenv,
691                                                        cwd, offset, len,
692                                                        nongit_ok);
693                         free(gitfile);
694                         return ret;
695                 }
696                 free(gitfile);
697
698                 if (is_git_directory("."))
699                         return setup_bare_git_dir(cwd, offset, len, nongit_ok);
700
701                 offset_parent = offset;
702                 while (--offset_parent > ceil_offset && cwd[offset_parent] != '/');
703                 if (offset_parent <= ceil_offset)
704                         return setup_nongit(cwd, nongit_ok);
705                 if (one_filesystem) {
706                         dev_t parent_device = get_device_or_die("..", cwd, offset);
707                         if (parent_device != current_device) {
708                                 if (nongit_ok) {
709                                         if (chdir(cwd))
710                                                 die_errno("Cannot come back to cwd");
711                                         *nongit_ok = 1;
712                                         return NULL;
713                                 }
714                                 cwd[offset] = '\0';
715                                 die("Not a git repository (or any parent up to mount point %s)\n"
716                                 "Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set).", cwd);
717                         }
718                 }
719                 if (chdir("..")) {
720                         cwd[offset] = '\0';
721                         die_errno("Cannot change to '%s/..'", cwd);
722                 }
723                 offset = offset_parent;
724         }
725 }
726
727 const char *setup_git_directory_gently(int *nongit_ok)
728 {
729         const char *prefix;
730
731         prefix = setup_git_directory_gently_1(nongit_ok);
732         if (prefix)
733                 setenv("GIT_PREFIX", prefix, 1);
734         else
735                 setenv("GIT_PREFIX", "", 1);
736
737         if (startup_info) {
738                 startup_info->have_repository = !nongit_ok || !*nongit_ok;
739                 startup_info->prefix = prefix;
740         }
741         return prefix;
742 }
743
744 int git_config_perm(const char *var, const char *value)
745 {
746         int i;
747         char *endptr;
748
749         if (value == NULL)
750                 return PERM_GROUP;
751
752         if (!strcmp(value, "umask"))
753                 return PERM_UMASK;
754         if (!strcmp(value, "group"))
755                 return PERM_GROUP;
756         if (!strcmp(value, "all") ||
757             !strcmp(value, "world") ||
758             !strcmp(value, "everybody"))
759                 return PERM_EVERYBODY;
760
761         /* Parse octal numbers */
762         i = strtol(value, &endptr, 8);
763
764         /* If not an octal number, maybe true/false? */
765         if (*endptr != 0)
766                 return git_config_bool(var, value) ? PERM_GROUP : PERM_UMASK;
767
768         /*
769          * Treat values 0, 1 and 2 as compatibility cases, otherwise it is
770          * a chmod value to restrict to.
771          */
772         switch (i) {
773         case PERM_UMASK:               /* 0 */
774                 return PERM_UMASK;
775         case OLD_PERM_GROUP:           /* 1 */
776                 return PERM_GROUP;
777         case OLD_PERM_EVERYBODY:       /* 2 */
778                 return PERM_EVERYBODY;
779         }
780
781         /* A filemode value was given: 0xxx */
782
783         if ((i & 0600) != 0600)
784                 die("Problem with core.sharedRepository filemode value "
785                     "(0%.3o).\nThe owner of files must always have "
786                     "read and write permissions.", i);
787
788         /*
789          * Mask filemode value. Others can not get write permission.
790          * x flags for directories are handled separately.
791          */
792         return -(i & 0666);
793 }
794
795 int check_repository_format_version(const char *var, const char *value, void *cb)
796 {
797         if (strcmp(var, "core.repositoryformatversion") == 0)
798                 repository_format_version = git_config_int(var, value);
799         else if (strcmp(var, "core.sharedrepository") == 0)
800                 shared_repository = git_config_perm(var, value);
801         else if (strcmp(var, "core.bare") == 0) {
802                 is_bare_repository_cfg = git_config_bool(var, value);
803                 if (is_bare_repository_cfg == 1)
804                         inside_work_tree = -1;
805         } else if (strcmp(var, "core.worktree") == 0) {
806                 if (!value)
807                         return config_error_nonbool(var);
808                 free(git_work_tree_cfg);
809                 git_work_tree_cfg = xstrdup(value);
810                 inside_work_tree = -1;
811         }
812         return 0;
813 }
814
815 int check_repository_format(void)
816 {
817         return check_repository_format_gently(get_git_dir(), NULL);
818 }
819
820 /*
821  * Returns the "prefix", a path to the current working directory
822  * relative to the work tree root, or NULL, if the current working
823  * directory is not a strict subdirectory of the work tree root. The
824  * prefix always ends with a '/' character.
825  */
826 const char *setup_git_directory(void)
827 {
828         return setup_git_directory_gently(NULL);
829 }
830
831 const char *resolve_gitdir(const char *suspect)
832 {
833         if (is_git_directory(suspect))
834                 return suspect;
835         return read_gitfile(suspect);
836 }