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{ 9 const char *orig = path; 10 for (;;) { 11 char c; 12 if (*path != '.') 13 break; 14 c = path[1]; 15 /* "." */ 16 if (!c) { 17 path++; 18 break; 19 } 20 /* "./" */ 21 if (c == '/') { 22 path += 2; 23 continue; 24 } 25 if (c != '.') 26 break; 27 c = path[2]; 28 if (!c) 29 path += 2; 30 else if (c == '/') 31 path += 3; 32 else 33 break; 34 /* ".." and "../" */ 35 /* Remove last component of the prefix */ 36 do { 37 if (!len) 38 die("'%s' is outside repository", orig); 39 len--; 40 } while (len && prefix[len-1] != '/'); 41 continue; 42 } 43 if (len) { 44 int speclen = strlen(path); 45 char *n = xmalloc(speclen + len + 1); 46 47 memcpy(n, prefix, len); 48 memcpy(n + len, path, speclen+1); 49 path = n; 50 } 51 return 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{ 61 static char path[PATH_MAX]; 62 if (!pfx || !*pfx || arg[0] == '/') 63 return arg; 64 memcpy(path, pfx, pfx_len); 65 strcpy(path + pfx_len, arg); 66 return 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 */ 76void verify_filename(const char *prefix, const char *arg) 77{ 78 const char *name; 79 struct stat st; 80 81 if (*arg == '-') 82 die("bad flag '%s' used after filename", arg); 83 name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg; 84 if (!lstat(name, &st)) 85 return; 86 if (errno == ENOENT) 87 die("ambiguous argument '%s': unknown revision or path not in the working tree.\n" 88 "Use '--' to separate paths from revisions", arg); 89 die("'%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 */ 97void verify_non_filename(const char *prefix, const char *arg) 98{ 99 const char *name; 100 struct stat st; 101 102 if (!is_inside_work_tree() || is_inside_git_dir()) 103 return; 104 if (*arg == '-') 105 return; /* flag */ 106 name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg; 107 if (!lstat(name, &st)) 108 die("ambiguous argument '%s': both revision and filename\n" 109 "Use '--' to separate filenames from revisions", arg); 110 if (errno != ENOENT && errno != ENOTDIR) 111 die("'%s': %s", arg, strerror(errno)); 112} 113 114const char **get_pathspec(const char *prefix, const char **pathspec) 115{ 116 const char *entry = *pathspec; 117 const char **p; 118 int prefixlen; 119 120 if (!prefix && !entry) 121 return NULL; 122 123 if (!entry) { 124 static const char *spec[2]; 125 spec[0] = prefix; 126 spec[1] = NULL; 127 return spec; 128 } 129 130 /* Otherwise we have to re-write the entries.. */ 131 p = pathspec; 132 prefixlen = prefix ? strlen(prefix) : 0; 133 do { 134 *p = prefix_path(prefix, prefixlen, entry); 135 } while ((entry = *++p) != NULL); 136 return (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 int is_git_directory(const char *suspect) 151{ 152 char path[PATH_MAX]; 153 size_t len = strlen(suspect); 154 155 strcpy(path, suspect); 156 if (getenv(DB_ENVIRONMENT)) { 157 if (access(getenv(DB_ENVIRONMENT), X_OK)) 158 return 0; 159 } 160 else { 161 strcpy(path + len, "/objects"); 162 if (access(path, X_OK)) 163 return 0; 164 } 165 166 strcpy(path + len, "/refs"); 167 if (access(path, X_OK)) 168 return 0; 169 170 strcpy(path + len, "/HEAD"); 171 if (validate_headref(path)) 172 return 0; 173 174 return 1; 175} 176 177int is_inside_git_dir(void) 178{ 179 if (inside_git_dir < 0) 180 inside_git_dir = is_inside_dir(get_git_dir()); 181 return inside_git_dir; 182} 183 184int is_inside_work_tree(void) 185{ 186 if (inside_work_tree < 0) 187 inside_work_tree = is_inside_dir(get_git_work_tree()); 188 return 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{ 199 char buffer[PATH_MAX + 1]; 200 201 if (!getcwd(buffer, sizeof(buffer))) 202 die ("Could not get the current working directory"); 203 git_work_tree_cfg = xstrdup(buffer); 204 inside_work_tree = 1; 205 206 return NULL; 207} 208 209void setup_work_tree(void) 210{ 211 const char *work_tree, *git_dir; 212 static int initialized = 0; 213 214 if (initialized) 215 return; 216 work_tree = get_git_work_tree(); 217 git_dir = get_git_dir(); 218 if (!is_absolute_path(git_dir)) 219 set_git_dir(make_absolute_path(git_dir)); 220 if (!work_tree || chdir(work_tree)) 221 die("This operation must be run in a work tree"); 222 initialized = 1; 223} 224 225/* 226 * We cannot decide in this function whether we are in the work tree or 227 * not, since the config can only be read _after_ this function was called. 228 */ 229const char *setup_git_directory_gently(int *nongit_ok) 230{ 231 const char *work_tree_env = getenv(GIT_WORK_TREE_ENVIRONMENT); 232 static char cwd[PATH_MAX+1]; 233 const char *gitdirenv; 234 int len, offset; 235 236 /* 237 * If GIT_DIR is set explicitly, we're not going 238 * to do any discovery, but we still do repository 239 * validation. 240 */ 241 gitdirenv = getenv(GIT_DIR_ENVIRONMENT); 242 if (gitdirenv) { 243 if (PATH_MAX - 40 < strlen(gitdirenv)) 244 die("'$%s' too big", GIT_DIR_ENVIRONMENT); 245 if (is_git_directory(gitdirenv)) { 246 static char buffer[1024 + 1]; 247 const char *retval; 248 249 if (!work_tree_env) 250 return set_work_tree(gitdirenv); 251 retval = get_relative_cwd(buffer, sizeof(buffer) - 1, 252 get_git_work_tree()); 253 if (!retval || !*retval) 254 return NULL; 255 set_git_dir(make_absolute_path(gitdirenv)); 256 if (chdir(work_tree_env) < 0) 257 die ("Could not chdir to %s", work_tree_env); 258 strcat(buffer, "/"); 259 return retval; 260 } 261 if (nongit_ok) { 262 *nongit_ok = 1; 263 return NULL; 264 } 265 die("Not a git repository: '%s'", gitdirenv); 266 } 267 268 if (!getcwd(cwd, sizeof(cwd)-1)) 269 die("Unable to read current working directory"); 270 271 /* 272 * Test in the following order (relative to the cwd): 273 * - .git/ 274 * - ./ (bare) 275 * - ../.git/ 276 * - ../ (bare) 277 * - ../../.git/ 278 * etc. 279 */ 280 offset = len = strlen(cwd); 281 for (;;) { 282 if (is_git_directory(DEFAULT_GIT_DIR_ENVIRONMENT)) 283 break; 284 if (is_git_directory(".")) { 285 inside_git_dir = 1; 286 if (!work_tree_env) 287 inside_work_tree = 0; 288 setenv(GIT_DIR_ENVIRONMENT, ".", 1); 289 return NULL; 290 } 291 chdir(".."); 292 do { 293 if (!offset) { 294 if (nongit_ok) { 295 if (chdir(cwd)) 296 die("Cannot come back to cwd"); 297 *nongit_ok = 1; 298 return NULL; 299 } 300 die("Not a git repository"); 301 } 302 } while (cwd[--offset] != '/'); 303 } 304 305 inside_git_dir = 0; 306 if (!work_tree_env) 307 inside_work_tree = 1; 308 git_work_tree_cfg = xstrndup(cwd, offset); 309 if (offset == len) 310 return NULL; 311 312 /* Make "offset" point to past the '/', and add a '/' at the end */ 313 offset++; 314 cwd[len++] = '/'; 315 cwd[len] = 0; 316 return cwd + offset; 317} 318 319int git_config_perm(const char *var, const char *value) 320{ 321 if (value) { 322 int i; 323 if (!strcmp(value, "umask")) 324 return PERM_UMASK; 325 if (!strcmp(value, "group")) 326 return PERM_GROUP; 327 if (!strcmp(value, "all") || 328 !strcmp(value, "world") || 329 !strcmp(value, "everybody")) 330 return PERM_EVERYBODY; 331 i = atoi(value); 332 if (i > 1) 333 return i; 334 } 335 return git_config_bool(var, value); 336} 337 338int check_repository_format_version(const char *var, const char *value) 339{ 340 if (strcmp(var, "core.repositoryformatversion") == 0) 341 repository_format_version = git_config_int(var, value); 342 else if (strcmp(var, "core.sharedrepository") == 0) 343 shared_repository = git_config_perm(var, value); 344 else if (strcmp(var, "core.bare") == 0) { 345 is_bare_repository_cfg = git_config_bool(var, value); 346 if (is_bare_repository_cfg == 1) 347 inside_work_tree = -1; 348 } else if (strcmp(var, "core.worktree") == 0) { 349 if (git_work_tree_cfg) 350 free(git_work_tree_cfg); 351 git_work_tree_cfg = xstrdup(value); 352 inside_work_tree = -1; 353 } 354 return 0; 355} 356 357int check_repository_format(void) 358{ 359 git_config(check_repository_format_version); 360 if (GIT_REPO_VERSION < repository_format_version) 361 die ("Expected git repo version <= %d, found %d", 362 GIT_REPO_VERSION, repository_format_version); 363 return 0; 364} 365 366const char *setup_git_directory(void) 367{ 368 const char *retval = setup_git_directory_gently(NULL); 369 check_repository_format(); 370 371 /* If the work tree is not the default one, recompute prefix */ 372 if (inside_work_tree < 0) { 373 static char buffer[PATH_MAX + 1]; 374 char *rel; 375 if (retval && chdir(retval)) 376 die ("Could not jump back into original cwd"); 377 rel = get_relative_cwd(buffer, PATH_MAX, get_git_work_tree()); 378 return rel && *rel ? strcat(rel, "/") : NULL; 379 } 380 381 return retval; 382}