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 /*
 253  * N.B. get_pathspec() is deprecated in favor of the "struct pathspec"
 254  * based interface - see pathspec_magic above.
 255  *
 256  * Arguments:
 257  *  - prefix - a path relative to the root of the working tree
 258  *  - pathspec - a list of paths underneath the prefix path
 259  *
 260  * Iterates over pathspec, prepending each path with prefix,
 261  * and return the resulting list.
 262  *
 263  * If pathspec is empty, return a singleton list containing prefix.
 264  *
 265  * If pathspec and prefix are both empty, return an empty list.
 266  *
 267  * This is typically used by built-in commands such as add.c, in order
 268  * to normalize argv arguments provided to the built-in into a list of
 269  * paths to process, all relative to the root of the working tree.
 270  */
 271 const char **get_pathspec(const char *prefix, const char **pathspec)
 272 {
 273         const char *entry = *pathspec;
 274         const char **src, **dst;
 275         int prefixlen;
 276
 277         if (!prefix && !entry)
 278                 return NULL;
 279
 280         if (!entry) {
 281                 static const char *spec[2];
 282                 spec[0] = prefix;
 283                 spec[1] = NULL;
 284                 return spec;
 285         }
 286
 287         /* Otherwise we have to re-write the entries.. */
 288         src = pathspec;
 289         dst = pathspec;
 290         prefixlen = prefix ? strlen(prefix) : 0;
 291         while (*src) {
 292                 *(dst++) = prefix_pathspec(prefix, prefixlen, *src);
 293                 src++;
 294         }
 295         *dst = NULL;
 296         if (!*pathspec)
 297                 return NULL;
 298         return pathspec;
 299 }
 300
 301 /*
 302  * Test if it looks like we're at a git directory.
 303  * We want to see:
 304  *
 305  *  - either an objects/ directory _or_ the proper
 306  *    GIT_OBJECT_DIRECTORY environment variable
 307  *  - a refs/ directory
 308  *  - either a HEAD symlink or a HEAD file that is formatted as
 309  *    a proper "ref:", or a regular file HEAD that has a properly
 310  *    formatted sha1 object name.
 311  */
 312 int is_git_directory(const char *suspect)
 313 {
 314         char path[PATH_MAX];
 315         size_t len = strlen(suspect);
 316
 317         if (PATH_MAX <= len + strlen("/objects"))
 318                 die("Too long path: %.*s", 60, suspect);
 319         strcpy(path, suspect);
 320         if (getenv(DB_ENVIRONMENT)) {
 321                 if (access(getenv(DB_ENVIRONMENT), X_OK))
 322                         return 0;
 323         }
 324         else {
 325                 strcpy(path + len, "/objects");
 326                 if (access(path, X_OK))
 327                         return 0;
 328         }
 329
 330         strcpy(path + len, "/refs");
 331         if (access(path, X_OK))
 332                 return 0;
 333
 334         strcpy(path + len, "/HEAD");
 335         if (validate_headref(path))
 336                 return 0;
 337
 338         return 1;
 339 }
 340
 341 int is_inside_git_dir(void)
 342 {
 343         if (inside_git_dir < 0)
 344                 inside_git_dir = is_inside_dir(get_git_dir());
 345         return inside_git_dir;
 346 }
 347
 348 int is_inside_work_tree(void)
 349 {
 350         if (inside_work_tree < 0)
 351                 inside_work_tree = is_inside_dir(get_git_work_tree());
 352         return inside_work_tree;
 353 }
 354
 355 void setup_work_tree(void)
 356 {
 357         const char *work_tree, *git_dir;
 358         static int initialized = 0;
 359
 360         if (initialized)
 361                 return;
 362         work_tree = get_git_work_tree();
 363         git_dir = get_git_dir();
 364         if (!is_absolute_path(git_dir))
 365                 git_dir = real_path(get_git_dir());
 366         if (!work_tree || chdir(work_tree))
 367                 die("This operation must be run in a work tree");
 368
 369         /*
 370          * Make sure subsequent git processes find correct worktree
 371          * if $GIT_WORK_TREE is set relative
 372          */
 373         if (getenv(GIT_WORK_TREE_ENVIRONMENT))
 374                 setenv(GIT_WORK_TREE_ENVIRONMENT, ".", 1);
 375
 376         set_git_dir(relative_path(git_dir, work_tree));
 377         initialized = 1;
 378 }
 379
 380 static int check_repository_format_gently(const char *gitdir, int *nongit_ok)
 381 {
 382         char repo_config[PATH_MAX+1];
 383
 384         /*
 385          * git_config() can't be used here because it calls git_pathdup()
 386          * to get $GIT_CONFIG/config. That call will make setup_git_env()
 387          * set git_dir to ".git".
 388          *
 389          * We are in gitdir setup, no git dir has been found useable yet.
 390          * Use a gentler version of git_config() to check if this repo
 391          * is a good one.
 392          */
 393         snprintf(repo_config, PATH_MAX, "%s/config", gitdir);
 394         git_config_early(check_repository_format_version, NULL, repo_config);
 395         if (GIT_REPO_VERSION < repository_format_version) {
 396                 if (!nongit_ok)
 397                         die ("Expected git repo version <= %d, found %d",
 398                              GIT_REPO_VERSION, repository_format_version);
 399                 warning("Expected git repo version <= %d, found %d",
 400                         GIT_REPO_VERSION, repository_format_version);
 401                 warning("Please upgrade Git");
 402                 *nongit_ok = -1;
 403                 return -1;
 404         }
 405         return 0;
 406 }
 407
 408 /*
 409  * Try to read the location of the git directory from the .git file,
 410  * return path to git directory if found.
 411  */
 412 const char *read_gitfile(const char *path)
 413 {
 414         char *buf;
 415         char *dir;
 416         const char *slash;
 417         struct stat st;
 418         int fd;
 419         ssize_t len;
 420
 421         if (stat(path, &st))
 422                 return NULL;
 423         if (!S_ISREG(st.st_mode))
 424                 return NULL;
 425         fd = open(path, O_RDONLY);
 426         if (fd < 0)
 427                 die_errno("Error opening '%s'", path);
 428         buf = xmalloc(st.st_size + 1);
 429         len = read_in_full(fd, buf, st.st_size);
 430         close(fd);
 431         if (len != st.st_size)
 432                 die("Error reading %s", path);
 433         buf[len] = '\0';
 434         if (prefixcmp(buf, "gitdir: "))
 435                 die("Invalid gitfile format: %s", path);
 436         while (buf[len - 1] == '\n' || buf[len - 1] == '\r')
 437                 len--;
 438         if (len < 9)
 439                 die("No path in gitfile: %s", path);
 440         buf[len] = '\0';
 441         dir = buf + 8;
 442
 443         if (!is_absolute_path(dir) && (slash = strrchr(path, '/'))) {
 444                 size_t pathlen = slash+1 - path;
 445                 size_t dirlen = pathlen + len - 8;
 446                 dir = xmalloc(dirlen + 1);
 447                 strncpy(dir, path, pathlen);
 448                 strncpy(dir + pathlen, buf + 8, len - 8);
 449                 dir[dirlen] = '\0';
 450                 free(buf);
 451                 buf = dir;
 452         }
 453
 454         if (!is_git_directory(dir))
 455                 die("Not a git repository: %s", dir);
 456         path = real_path(dir);
 457
 458         free(buf);
 459         return path;
 460 }
 461
 462 static const char *setup_explicit_git_dir(const char *gitdirenv,
 463                                           char *cwd, int len,
 464                                           int *nongit_ok)
 465 {
 466         const char *work_tree_env = getenv(GIT_WORK_TREE_ENVIRONMENT);
 467         const char *worktree;
 468         char *gitfile;
 469         int offset;
 470
 471         if (PATH_MAX - 40 < strlen(gitdirenv))
 472                 die("'$%s' too big", GIT_DIR_ENVIRONMENT);
 473
 474         gitfile = (char*)read_gitfile(gitdirenv);
 475         if (gitfile) {
 476                 gitfile = xstrdup(gitfile);
 477                 gitdirenv = gitfile;
 478         }
 479
 480         if (!is_git_directory(gitdirenv)) {
 481                 if (nongit_ok) {
 482                         *nongit_ok = 1;
 483                         free(gitfile);
 484                         return NULL;
 485                 }
 486                 die("Not a git repository: '%s'", gitdirenv);
 487         }
 488
 489         if (check_repository_format_gently(gitdirenv, nongit_ok)) {
 490                 free(gitfile);
 491                 return NULL;
 492         }
 493
 494         /* #3, #7, #11, #15, #19, #23, #27, #31 (see t1510) */
 495         if (work_tree_env)
 496                 set_git_work_tree(work_tree_env);
 497         else if (is_bare_repository_cfg > 0) {
 498                 if (git_work_tree_cfg) /* #22.2, #30 */
 499                         die("core.bare and core.worktree do not make sense");
 500
 501                 /* #18, #26 */
 502                 set_git_dir(gitdirenv);
 503                 free(gitfile);
 504                 return NULL;
 505         }
 506         else if (git_work_tree_cfg) { /* #6, #14 */
 507                 if (is_absolute_path(git_work_tree_cfg))
 508                         set_git_work_tree(git_work_tree_cfg);
 509                 else {
 510                         char core_worktree[PATH_MAX];
 511                         if (chdir(gitdirenv))
 512                                 die_errno("Could not chdir to '%s'", gitdirenv);
 513                         if (chdir(git_work_tree_cfg))
 514                                 die_errno("Could not chdir to '%s'", git_work_tree_cfg);
 515                         if (!getcwd(core_worktree, PATH_MAX))
 516                                 die_errno("Could not get directory '%s'", git_work_tree_cfg);
 517                         if (chdir(cwd))
 518                                 die_errno("Could not come back to cwd");
 519                         set_git_work_tree(core_worktree);
 520                 }
 521         }
 522         else /* #2, #10 */
 523                 set_git_work_tree(".");
 524
 525         /* set_git_work_tree() must have been called by now */
 526         worktree = get_git_work_tree();
 527
 528         /* both get_git_work_tree() and cwd are already normalized */
 529         if (!strcmp(cwd, worktree)) { /* cwd == worktree */
 530                 set_git_dir(gitdirenv);
 531                 free(gitfile);
 532                 return NULL;
 533         }
 534
 535         offset = dir_inside_of(cwd, worktree);
 536         if (offset >= 0) {      /* cwd inside worktree? */
 537                 set_git_dir(real_path(gitdirenv));
 538                 if (chdir(worktree))
 539                         die_errno("Could not chdir to '%s'", worktree);
 540                 cwd[len++] = '/';
 541                 cwd[len] = '\0';
 542                 free(gitfile);
 543                 return cwd + offset;
 544         }
 545
 546         /* cwd outside worktree */
 547         set_git_dir(gitdirenv);
 548         free(gitfile);
 549         return NULL;
 550 }
 551
 552 static const char *setup_discovered_git_dir(const char *gitdir,
 553                                             char *cwd, int offset, int len,
 554                                             int *nongit_ok)
 555 {
 556         if (check_repository_format_gently(gitdir, nongit_ok))
 557                 return NULL;
 558
 559         /* --work-tree is set without --git-dir; use discovered one */
 560         if (getenv(GIT_WORK_TREE_ENVIRONMENT) || git_work_tree_cfg) {
 561                 if (offset != len && !is_absolute_path(gitdir))
 562                         gitdir = xstrdup(real_path(gitdir));
 563                 if (chdir(cwd))
 564                         die_errno("Could not come back to cwd");
 565                 return setup_explicit_git_dir(gitdir, cwd, len, nongit_ok);
 566         }
 567
 568         /* #16.2, #17.2, #20.2, #21.2, #24, #25, #28, #29 (see t1510) */
 569         if (is_bare_repository_cfg > 0) {
 570                 set_git_dir(offset == len ? gitdir : real_path(gitdir));
 571                 if (chdir(cwd))
 572                         die_errno("Could not come back to cwd");
 573                 return NULL;
 574         }
 575
 576         /* #0, #1, #5, #8, #9, #12, #13 */
 577         set_git_work_tree(".");
 578         if (strcmp(gitdir, DEFAULT_GIT_DIR_ENVIRONMENT))
 579                 set_git_dir(gitdir);
 580         inside_git_dir = 0;
 581         inside_work_tree = 1;
 582         if (offset == len)
 583                 return NULL;
 584
 585         /* Make "offset" point to past the '/', and add a '/' at the end */
 586         offset++;
 587         cwd[len++] = '/';
 588         cwd[len] = 0;
 589         return cwd + offset;
 590 }
 591
 592 /* #16.1, #17.1, #20.1, #21.1, #22.1 (see t1510) */
 593 static const char *setup_bare_git_dir(char *cwd, int offset, int len, int *nongit_ok)
 594 {
 595         int root_len;
 596
 597         if (check_repository_format_gently(".", nongit_ok))
 598                 return NULL;
 599
 600         /* --work-tree is set without --git-dir; use discovered one */
 601         if (getenv(GIT_WORK_TREE_ENVIRONMENT) || git_work_tree_cfg) {
 602                 const char *gitdir;
 603
 604                 gitdir = offset == len ? "." : xmemdupz(cwd, offset);
 605                 if (chdir(cwd))
 606                         die_errno("Could not come back to cwd");
 607                 return setup_explicit_git_dir(gitdir, cwd, len, nongit_ok);
 608         }
 609
 610         inside_git_dir = 1;
 611         inside_work_tree = 0;
 612         if (offset != len) {
 613                 if (chdir(cwd))
 614                         die_errno("Cannot come back to cwd");
 615                 root_len = offset_1st_component(cwd);
 616                 cwd[offset > root_len ? offset : root_len] = '\0';
 617                 set_git_dir(cwd);
 618         }
 619         else
 620                 set_git_dir(".");
 621         return NULL;
 622 }
 623
 624 static const char *setup_nongit(const char *cwd, int *nongit_ok)
 625 {
 626         if (!nongit_ok)
 627                 die("Not a git repository (or any of the parent directories): %s", DEFAULT_GIT_DIR_ENVIRONMENT);
 628         if (chdir(cwd))
 629                 die_errno("Cannot come back to cwd");
 630         *nongit_ok = 1;
 631         return NULL;
 632 }
 633
 634 static dev_t get_device_or_die(const char *path, const char *prefix, int prefix_len)
 635 {
 636         struct stat buf;
 637         if (stat(path, &buf)) {
 638                 die_errno("failed to stat '%*s%s%s'",
 639                                 prefix_len,
 640                                 prefix ? prefix : "",
 641                                 prefix ? "/" : "", path);
 642         }
 643         return buf.st_dev;
 644 }
 645
 646 /*
 647  * We cannot decide in this function whether we are in the work tree or
 648  * not, since the config can only be read _after_ this function was called.
 649  */
 650 static const char *setup_git_directory_gently_1(int *nongit_ok)
 651 {
 652         const char *env_ceiling_dirs = getenv(CEILING_DIRECTORIES_ENVIRONMENT);
 653         static char cwd[PATH_MAX+1];
 654         const char *gitdirenv, *ret;
 655         char *gitfile;
 656         int len, offset, offset_parent, ceil_offset;
 657         dev_t current_device = 0;
 658         int one_filesystem = 1;
 659
 660         /*
 661          * Let's assume that we are in a git repository.
 662          * If it turns out later that we are somewhere else, the value will be
 663          * updated accordingly.
 664          */
 665         if (nongit_ok)
 666                 *nongit_ok = 0;
 667
 668         if (!getcwd(cwd, sizeof(cwd)-1))
 669                 die_errno("Unable to read current working directory");
 670         offset = len = strlen(cwd);
 671
 672         /*
 673          * If GIT_DIR is set explicitly, we're not going
 674          * to do any discovery, but we still do repository
 675          * validation.
 676          */
 677         gitdirenv = getenv(GIT_DIR_ENVIRONMENT);
 678         if (gitdirenv)
 679                 return setup_explicit_git_dir(gitdirenv, cwd, len, nongit_ok);
 680
 681         ceil_offset = longest_ancestor_length(cwd, env_ceiling_dirs);
 682         if (ceil_offset < 0 && has_dos_drive_prefix(cwd))
 683                 ceil_offset = 1;
 684
 685         /*
 686          * Test in the following order (relative to the cwd):
 687          * - .git (file containing "gitdir: <path>")
 688          * - .git/
 689          * - ./ (bare)
 690          * - ../.git
 691          * - ../.git/
 692          * - ../ (bare)
 693          * - ../../.git/
 694          *   etc.
 695          */
 696         one_filesystem = !git_env_bool("GIT_DISCOVERY_ACROSS_FILESYSTEM", 0);
 697         if (one_filesystem)
 698                 current_device = get_device_or_die(".", NULL, 0);
 699         for (;;) {
 700                 gitfile = (char*)read_gitfile(DEFAULT_GIT_DIR_ENVIRONMENT);
 701                 if (gitfile)
 702                         gitdirenv = gitfile = xstrdup(gitfile);
 703                 else {
 704                         if (is_git_directory(DEFAULT_GIT_DIR_ENVIRONMENT))
 705                                 gitdirenv = DEFAULT_GIT_DIR_ENVIRONMENT;
 706                 }
 707
 708                 if (gitdirenv) {
 709                         ret = setup_discovered_git_dir(gitdirenv,
 710                                                        cwd, offset, len,
 711                                                        nongit_ok);
 712                         free(gitfile);
 713                         return ret;
 714                 }
 715                 free(gitfile);
 716
 717                 if (is_git_directory("."))
 718                         return setup_bare_git_dir(cwd, offset, len, nongit_ok);
 719
 720                 offset_parent = offset;
 721                 while (--offset_parent > ceil_offset && cwd[offset_parent] != '/');
 722                 if (offset_parent <= ceil_offset)
 723                         return setup_nongit(cwd, nongit_ok);
 724                 if (one_filesystem) {
 725                         dev_t parent_device = get_device_or_die("..", cwd, offset);
 726                         if (parent_device != current_device) {
 727                                 if (nongit_ok) {
 728                                         if (chdir(cwd))
 729                                                 die_errno("Cannot come back to cwd");
 730                                         *nongit_ok = 1;
 731                                         return NULL;
 732                                 }
 733                                 cwd[offset] = '\0';
 734                                 die("Not a git repository (or any parent up to mount point %s)\n"
 735                                 "Stopping at filesystem boundary (GIT_DISCOVERY_ACROSS_FILESYSTEM not set).", cwd);
 736                         }
 737                 }
 738                 if (chdir("..")) {
 739                         cwd[offset] = '\0';
 740                         die_errno("Cannot change to '%s/..'", cwd);
 741                 }
 742                 offset = offset_parent;
 743         }
 744 }
 745
 746 const char *setup_git_directory_gently(int *nongit_ok)
 747 {
 748         const char *prefix;
 749
 750         prefix = setup_git_directory_gently_1(nongit_ok);
 751         if (prefix)
 752                 setenv("GIT_PREFIX", prefix, 1);
 753         else
 754                 setenv("GIT_PREFIX", "", 1);
 755
 756         if (startup_info) {
 757                 startup_info->have_repository = !nongit_ok || !*nongit_ok;
 758                 startup_info->prefix = prefix;
 759         }
 760         return prefix;
 761 }
 762
 763 int git_config_perm(const char *var, const char *value)
 764 {
 765         int i;
 766         char *endptr;
 767
 768         if (value == NULL)
 769                 return PERM_GROUP;
 770
 771         if (!strcmp(value, "umask"))
 772                 return PERM_UMASK;
 773         if (!strcmp(value, "group"))
 774                 return PERM_GROUP;
 775         if (!strcmp(value, "all") ||
 776             !strcmp(value, "world") ||
 777             !strcmp(value, "everybody"))
 778                 return PERM_EVERYBODY;
 779
 780         /* Parse octal numbers */
 781         i = strtol(value, &endptr, 8);
 782
 783         /* If not an octal number, maybe true/false? */
 784         if (*endptr != 0)
 785                 return git_config_bool(var, value) ? PERM_GROUP : PERM_UMASK;
 786
 787         /*
 788          * Treat values 0, 1 and 2 as compatibility cases, otherwise it is
 789          * a chmod value to restrict to.
 790          */
 791         switch (i) {
 792         case PERM_UMASK:               /* 0 */
 793                 return PERM_UMASK;
 794         case OLD_PERM_GROUP:           /* 1 */
 795                 return PERM_GROUP;
 796         case OLD_PERM_EVERYBODY:       /* 2 */
 797                 return PERM_EVERYBODY;
 798         }
 799
 800         /* A filemode value was given: 0xxx */
 801
 802         if ((i & 0600) != 0600)
 803                 die("Problem with core.sharedRepository filemode value "
 804                     "(0%.3o).\nThe owner of files must always have "
 805                     "read and write permissions.", i);
 806
 807         /*
 808          * Mask filemode value. Others can not get write permission.
 809          * x flags for directories are handled separately.
 810          */
 811         return -(i & 0666);
 812 }
 813
 814 int check_repository_format_version(const char *var, const char *value, void *cb)
 815 {
 816         if (strcmp(var, "core.repositoryformatversion") == 0)
 817                 repository_format_version = git_config_int(var, value);
 818         else if (strcmp(var, "core.sharedrepository") == 0)
 819                 shared_repository = git_config_perm(var, value);
 820         else if (strcmp(var, "core.bare") == 0) {
 821                 is_bare_repository_cfg = git_config_bool(var, value);
 822                 if (is_bare_repository_cfg == 1)
 823                         inside_work_tree = -1;
 824         } else if (strcmp(var, "core.worktree") == 0) {
 825                 if (!value)
 826                         return config_error_nonbool(var);
 827                 free(git_work_tree_cfg);
 828                 git_work_tree_cfg = xstrdup(value);
 829                 inside_work_tree = -1;
 830         }
 831         return 0;
 832 }
 833
 834 int check_repository_format(void)
 835 {
 836         return check_repository_format_gently(get_git_dir(), NULL);
 837 }
 838
 839 /*
 840  * Returns the "prefix", a path to the current working directory
 841  * relative to the work tree root, or NULL, if the current working
 842  * directory is not a strict subdirectory of the work tree root. The
 843  * prefix always ends with a '/' character.
 844  */
 845 const char *setup_git_directory(void)
 846 {
 847         return setup_git_directory_gently(NULL);
 848 }
 849
 850 const char *resolve_gitdir(const char *suspect)
 851 {
 852         if (is_git_directory(suspect))
 853                 return suspect;
 854         return read_gitfile(suspect);
 855 }