1#include"cache.h" 2#include"dir.h" 3 4static int inside_git_dir = -1; 5static int inside_work_tree = -1; 6 7const char*prefix_path(const char*prefix,int len,const char*path) 8{ 9const char*orig = path; 10for(;;) { 11char c; 12if(*path !='.') 13break; 14 c = path[1]; 15/* "." */ 16if(!c) { 17 path++; 18break; 19} 20/* "./" */ 21if(c =='/') { 22 path +=2; 23continue; 24} 25if(c !='.') 26break; 27 c = path[2]; 28if(!c) 29 path +=2; 30else if(c =='/') 31 path +=3; 32else 33break; 34/* ".." and "../" */ 35/* Remove last component of the prefix */ 36do{ 37if(!len) 38die("'%s' is outside repository", orig); 39 len--; 40}while(len && prefix[len-1] !='/'); 41continue; 42} 43if(len) { 44int speclen =strlen(path); 45char*n =xmalloc(speclen + len +1); 46 47memcpy(n, prefix, len); 48memcpy(n + len, path, speclen+1); 49 path = n; 50} 51return path; 52} 53 54/* 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 */ 59const char*prefix_filename(const char*pfx,int pfx_len,const char*arg) 60{ 61static char path[PATH_MAX]; 62if(!pfx || !*pfx ||is_absolute_path(arg)) 63return arg; 64memcpy(path, pfx, pfx_len); 65strcpy(path + pfx_len, arg); 66return path; 67} 68 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 */ 76voidverify_filename(const char*prefix,const char*arg) 77{ 78const char*name; 79struct stat st; 80 81if(*arg =='-') 82die("bad flag '%s' used after filename", arg); 83 name = prefix ?prefix_filename(prefix,strlen(prefix), arg) : arg; 84if(!lstat(name, &st)) 85return; 86if(errno == ENOENT) 87die("ambiguous argument '%s': unknown revision or path not in the working tree.\n" 88"Use '--' to separate paths from revisions", arg); 89die("'%s':%s", arg,strerror(errno)); 90} 91 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 */ 97voidverify_non_filename(const char*prefix,const char*arg) 98{ 99const char*name; 100struct stat st; 101 102if(!is_inside_work_tree() ||is_inside_git_dir()) 103return; 104if(*arg =='-') 105return;/* flag */ 106 name = prefix ?prefix_filename(prefix,strlen(prefix), arg) : arg; 107if(!lstat(name, &st)) 108die("ambiguous argument '%s': both revision and filename\n" 109"Use '--' to separate filenames from revisions", arg); 110if(errno != ENOENT && errno != ENOTDIR) 111die("'%s':%s", arg,strerror(errno)); 112} 113 114const char**get_pathspec(const char*prefix,const char**pathspec) 115{ 116const char*entry = *pathspec; 117const char**p; 118int prefixlen; 119 120if(!prefix && !entry) 121return NULL; 122 123if(!entry) { 124static const char*spec[2]; 125 spec[0] = prefix; 126 spec[1] = NULL; 127return spec; 128} 129 130/* Otherwise we have to re-write the entries.. */ 131 p = pathspec; 132 prefixlen = prefix ?strlen(prefix) :0; 133do{ 134*p =prefix_path(prefix, prefixlen, entry); 135}while((entry = *++p) != NULL); 136return(const char**) pathspec; 137} 138 139/* 140 * Test if it looks like we're at a git directory. 141 * We want to see: 142 * 143 * - either an objects/ directory _or_ the proper 144 * GIT_OBJECT_DIRECTORY environment variable 145 * - a refs/ directory 146 * - either a HEAD symlink or a HEAD file that is formatted as 147 * a proper "ref:", or a regular file HEAD that has a properly 148 * formatted sha1 object name. 149 */ 150static intis_git_directory(const char*suspect) 151{ 152char path[PATH_MAX]; 153size_t len =strlen(suspect); 154 155strcpy(path, suspect); 156if(getenv(DB_ENVIRONMENT)) { 157if(access(getenv(DB_ENVIRONMENT), X_OK)) 158return0; 159} 160else{ 161strcpy(path + len,"/objects"); 162if(access(path, X_OK)) 163return0; 164} 165 166strcpy(path + len,"/refs"); 167if(access(path, X_OK)) 168return0; 169 170strcpy(path + len,"/HEAD"); 171if(validate_headref(path)) 172return0; 173 174return1; 175} 176 177intis_inside_git_dir(void) 178{ 179if(inside_git_dir <0) 180 inside_git_dir =is_inside_dir(get_git_dir()); 181return inside_git_dir; 182} 183 184intis_inside_work_tree(void) 185{ 186if(inside_work_tree <0) 187 inside_work_tree =is_inside_dir(get_git_work_tree()); 188return inside_work_tree; 189} 190 191/* 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. 196 */ 197static const char*set_work_tree(const char*dir) 198{ 199char buffer[PATH_MAX +1]; 200 201if(!getcwd(buffer,sizeof(buffer))) 202die("Could not get the current working directory"); 203 git_work_tree_cfg =xstrdup(buffer); 204 inside_work_tree =1; 205 206return NULL; 207} 208 209voidsetup_work_tree(void) 210{ 211const char*work_tree, *git_dir; 212static int initialized =0; 213 214if(initialized) 215return; 216 work_tree =get_git_work_tree(); 217 git_dir =get_git_dir(); 218if(!is_absolute_path(git_dir)) 219set_git_dir(make_absolute_path(git_dir)); 220if(!work_tree ||chdir(work_tree)) 221die("This operation must be run in a work tree"); 222 initialized =1; 223} 224 225static intcheck_repository_format_gently(int*nongit_ok) 226{ 227git_config(check_repository_format_version); 228if(GIT_REPO_VERSION < repository_format_version) { 229if(!nongit_ok) 230die("Expected git repo version <=%d, found%d", 231 GIT_REPO_VERSION, repository_format_version); 232warning("Expected git repo version <=%d, found%d", 233 GIT_REPO_VERSION, repository_format_version); 234warning("Please upgrade Git"); 235*nongit_ok = -1; 236return-1; 237} 238return0; 239} 240 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 */ 245const char*setup_git_directory_gently(int*nongit_ok) 246{ 247const char*work_tree_env =getenv(GIT_WORK_TREE_ENVIRONMENT); 248static char cwd[PATH_MAX+1]; 249const char*gitdirenv; 250int len, offset; 251 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 */ 257 gitdirenv =getenv(GIT_DIR_ENVIRONMENT); 258if(gitdirenv) { 259if(PATH_MAX -40<strlen(gitdirenv)) 260die("'$%s' too big", GIT_DIR_ENVIRONMENT); 261if(is_git_directory(gitdirenv)) { 262static char buffer[1024+1]; 263const char*retval; 264 265if(!work_tree_env) { 266 retval =set_work_tree(gitdirenv); 267/* config may override worktree */ 268if(check_repository_format_gently(nongit_ok)) 269return NULL; 270return retval; 271} 272if(check_repository_format_gently(nongit_ok)) 273return NULL; 274 retval =get_relative_cwd(buffer,sizeof(buffer) -1, 275get_git_work_tree()); 276if(!retval || !*retval) 277return NULL; 278set_git_dir(make_absolute_path(gitdirenv)); 279if(chdir(work_tree_env) <0) 280die("Could not chdir to%s", work_tree_env); 281strcat(buffer,"/"); 282return retval; 283} 284if(nongit_ok) { 285*nongit_ok =1; 286return NULL; 287} 288die("Not a git repository: '%s'", gitdirenv); 289} 290 291if(!getcwd(cwd,sizeof(cwd)-1)) 292die("Unable to read current working directory"); 293 294/* 295 * Test in the following order (relative to the cwd): 296 * - .git/ 297 * - ./ (bare) 298 * - ../.git/ 299 * - ../ (bare) 300 * - ../../.git/ 301 * etc. 302 */ 303 offset = len =strlen(cwd); 304for(;;) { 305if(is_git_directory(DEFAULT_GIT_DIR_ENVIRONMENT)) 306break; 307if(is_git_directory(".")) { 308 inside_git_dir =1; 309if(!work_tree_env) 310 inside_work_tree =0; 311setenv(GIT_DIR_ENVIRONMENT,".",1); 312check_repository_format_gently(nongit_ok); 313return NULL; 314} 315chdir(".."); 316do{ 317if(!offset) { 318if(nongit_ok) { 319if(chdir(cwd)) 320die("Cannot come back to cwd"); 321*nongit_ok =1; 322return NULL; 323} 324die("Not a git repository"); 325} 326}while(cwd[--offset] !='/'); 327} 328 329 inside_git_dir =0; 330if(!work_tree_env) 331 inside_work_tree =1; 332 git_work_tree_cfg =xstrndup(cwd, offset); 333if(check_repository_format_gently(nongit_ok)) 334return NULL; 335if(offset == len) 336return NULL; 337 338/* Make "offset" point to past the '/', and add a '/' at the end */ 339 offset++; 340 cwd[len++] ='/'; 341 cwd[len] =0; 342return cwd + offset; 343} 344 345intgit_config_perm(const char*var,const char*value) 346{ 347if(value) { 348int i; 349if(!strcmp(value,"umask")) 350return PERM_UMASK; 351if(!strcmp(value,"group")) 352return PERM_GROUP; 353if(!strcmp(value,"all") || 354!strcmp(value,"world") || 355!strcmp(value,"everybody")) 356return PERM_EVERYBODY; 357 i =atoi(value); 358if(i >1) 359return i; 360} 361returngit_config_bool(var, value); 362} 363 364intcheck_repository_format_version(const char*var,const char*value) 365{ 366if(strcmp(var,"core.repositoryformatversion") ==0) 367 repository_format_version =git_config_int(var, value); 368else if(strcmp(var,"core.sharedrepository") ==0) 369 shared_repository =git_config_perm(var, value); 370else if(strcmp(var,"core.bare") ==0) { 371 is_bare_repository_cfg =git_config_bool(var, value); 372if(is_bare_repository_cfg ==1) 373 inside_work_tree = -1; 374}else if(strcmp(var,"core.worktree") ==0) { 375if(!value) 376returnconfig_error_nonbool(var); 377if(git_work_tree_cfg) 378free(git_work_tree_cfg); 379 git_work_tree_cfg =xstrdup(value); 380 inside_work_tree = -1; 381} 382return0; 383} 384 385intcheck_repository_format(void) 386{ 387returncheck_repository_format_gently(NULL); 388} 389 390const char*setup_git_directory(void) 391{ 392const char*retval =setup_git_directory_gently(NULL); 393 394/* If the work tree is not the default one, recompute prefix */ 395if(inside_work_tree <0) { 396static char buffer[PATH_MAX +1]; 397char*rel; 398if(retval &&chdir(retval)) 399die("Could not jump back into original cwd"); 400 rel =get_relative_cwd(buffer, PATH_MAX,get_git_work_tree()); 401return rel && *rel ?strcat(rel,"/") : NULL; 402} 403 404return retval; 405}