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 || arg[0] =='/') 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 a 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 209/* 210 * We cannot decide in this function whether we are in the work tree or 211 * not, since the config can only be read _after_ this function was called. 212 */ 213const char*setup_git_directory_gently(int*nongit_ok) 214{ 215const char*work_tree_env =getenv(GIT_WORK_TREE_ENVIRONMENT); 216static char cwd[PATH_MAX+1]; 217const char*gitdirenv; 218int len, offset; 219 220/* 221 * If GIT_DIR is set explicitly, we're not going 222 * to do any discovery, but we still do repository 223 * validation. 224 */ 225 gitdirenv =getenv(GIT_DIR_ENVIRONMENT); 226if(gitdirenv) { 227if(PATH_MAX -40<strlen(gitdirenv)) 228die("'$%s' too big", GIT_DIR_ENVIRONMENT); 229if(is_git_directory(gitdirenv)) { 230static char buffer[1024+1]; 231const char*retval; 232 233if(!work_tree_env) { 234 retval =set_work_tree(gitdirenv); 235/* config may override worktree 236 * see set_work_tree comment */ 237check_repository_format(); 238return retval; 239} 240check_repository_format(); 241 retval =get_relative_cwd(buffer,sizeof(buffer) -1, 242get_git_work_tree()); 243if(!retval || !*retval) 244return NULL; 245set_git_dir(make_absolute_path(gitdirenv)); 246if(chdir(work_tree_env) <0) 247die("Could not chdir to%s", work_tree_env); 248strcat(buffer,"/"); 249 inside_work_tree =1; 250return retval; 251} 252if(nongit_ok) { 253*nongit_ok =1; 254return NULL; 255} 256die("Not a git repository: '%s'", gitdirenv); 257} 258 259if(!getcwd(cwd,sizeof(cwd)-1)) 260die("Unable to read current working directory"); 261 262/* 263 * Test in the following order (relative to the cwd): 264 * - .git/ 265 * - ./ (bare) 266 * - ../.git/ 267 * - ../ (bare) 268 * - ../../.git/ 269 * etc. 270 */ 271 offset = len =strlen(cwd); 272for(;;) { 273if(is_git_directory(DEFAULT_GIT_DIR_ENVIRONMENT)) 274break; 275if(is_git_directory(".")) { 276 inside_git_dir =1; 277if(!work_tree_env) 278 inside_work_tree =0; 279setenv(GIT_DIR_ENVIRONMENT,".",1); 280check_repository_format(); 281return NULL; 282} 283chdir(".."); 284do{ 285if(!offset) { 286if(nongit_ok) { 287if(chdir(cwd)) 288die("Cannot come back to cwd"); 289*nongit_ok =1; 290return NULL; 291} 292die("Not a git repository"); 293} 294}while(cwd[--offset] !='/'); 295} 296 297 inside_git_dir =0; 298if(!work_tree_env) 299 inside_work_tree =1; 300 git_work_tree_cfg =xstrndup(cwd, offset); 301check_repository_format(); 302if(offset == len) 303return NULL; 304 305/* Make "offset" point to past the '/', and add a '/' at the end */ 306 offset++; 307 cwd[len++] ='/'; 308 cwd[len] =0; 309return cwd + offset; 310} 311 312intgit_config_perm(const char*var,const char*value) 313{ 314if(value) { 315int i; 316if(!strcmp(value,"umask")) 317return PERM_UMASK; 318if(!strcmp(value,"group")) 319return PERM_GROUP; 320if(!strcmp(value,"all") || 321!strcmp(value,"world") || 322!strcmp(value,"everybody")) 323return PERM_EVERYBODY; 324 i =atoi(value); 325if(i >1) 326return i; 327} 328returngit_config_bool(var, value); 329} 330 331intcheck_repository_format_version(const char*var,const char*value) 332{ 333if(strcmp(var,"core.repositoryformatversion") ==0) 334 repository_format_version =git_config_int(var, value); 335else if(strcmp(var,"core.sharedrepository") ==0) 336 shared_repository =git_config_perm(var, value); 337else if(strcmp(var,"core.bare") ==0) { 338 is_bare_repository_cfg =git_config_bool(var, value); 339if(is_bare_repository_cfg ==1) 340 inside_work_tree = -1; 341}else if(strcmp(var,"core.worktree") ==0) { 342if(git_work_tree_cfg) 343free(git_work_tree_cfg); 344 git_work_tree_cfg =xstrdup(value); 345 inside_work_tree = -1; 346} 347return0; 348} 349 350intcheck_repository_format(void) 351{ 352git_config(check_repository_format_version); 353if(GIT_REPO_VERSION < repository_format_version) 354die("Expected git repo version <=%d, found%d", 355 GIT_REPO_VERSION, repository_format_version); 356return0; 357} 358 359const char*setup_git_directory(void) 360{ 361const char*retval =setup_git_directory_gently(NULL); 362 363/* If the work tree is not the default one, recompute prefix */ 364if(inside_work_tree <0) { 365static char buffer[PATH_MAX +1]; 366char*rel; 367if(retval &&chdir(retval)) 368die("Could not jump back into original cwd"); 369 rel =get_relative_cwd(buffer, PATH_MAX,get_git_work_tree()); 370return rel && *rel ?strcat(rel,"/") : NULL; 371} 372 373return retval; 374}