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