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