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