Detached HEAD (experimental)
[git] / setup.c
1 #include "cache.h"
2
3 const char *prefix_path(const char *prefix, int len, const char *path)
4 {
5         const char *orig = path;
6         for (;;) {
7                 char c;
8                 if (*path != '.')
9                         break;
10                 c = path[1];
11                 /* "." */
12                 if (!c) {
13                         path++;
14                         break;
15                 }
16                 /* "./" */
17                 if (c == '/') {
18                         path += 2;
19                         continue;
20                 }
21                 if (c != '.')
22                         break;
23                 c = path[2];
24                 if (!c)
25                         path += 2;
26                 else if (c == '/')
27                         path += 3;
28                 else
29                         break;
30                 /* ".." and "../" */
31                 /* Remove last component of the prefix */
32                 do {
33                         if (!len)
34                                 die("'%s' is outside repository", orig);
35                         len--;
36                 } while (len && prefix[len-1] != '/');
37                 continue;
38         }
39         if (len) {
40                 int speclen = strlen(path);
41                 char *n = xmalloc(speclen + len + 1);
42         
43                 memcpy(n, prefix, len);
44                 memcpy(n + len, path, speclen+1);
45                 path = n;
46         }
47         return path;
48 }
49
50 /* 
51  * Unlike prefix_path, this should be used if the named file does
52  * not have to interact with index entry; i.e. name of a random file
53  * on the filesystem.
54  */
55 const char *prefix_filename(const char *pfx, int pfx_len, const char *arg)
56 {
57         static char path[PATH_MAX];
58         if (!pfx || !*pfx || arg[0] == '/')
59                 return arg;
60         memcpy(path, pfx, pfx_len);
61         strcpy(path + pfx_len, arg);
62         return path;
63 }
64
65 /*
66  * Verify a filename that we got as an argument for a pathspec
67  * entry. Note that a filename that begins with "-" never verifies
68  * as true, because even if such a filename were to exist, we want
69  * it to be preceded by the "--" marker (or we want the user to
70  * use a format like "./-filename")
71  */
72 void verify_filename(const char *prefix, const char *arg)
73 {
74         const char *name;
75         struct stat st;
76
77         if (*arg == '-')
78                 die("bad flag '%s' used after filename", arg);
79         name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
80         if (!lstat(name, &st))
81                 return;
82         if (errno == ENOENT)
83                 die("ambiguous argument '%s': unknown revision or path not in the working tree.\n"
84                     "Use '--' to separate paths from revisions", arg);
85         die("'%s': %s", arg, strerror(errno));
86 }
87
88 /*
89  * Opposite of the above: the command line did not have -- marker
90  * and we parsed the arg as a refname.  It should not be interpretable
91  * as a filename.
92  */
93 void verify_non_filename(const char *prefix, const char *arg)
94 {
95         const char *name;
96         struct stat st;
97
98         if (*arg == '-')
99                 return; /* flag */
100         name = prefix ? prefix_filename(prefix, strlen(prefix), arg) : arg;
101         if (!lstat(name, &st))
102                 die("ambiguous argument '%s': both revision and filename\n"
103                     "Use '--' to separate filenames from revisions", arg);
104         if (errno != ENOENT)
105                 die("'%s': %s", arg, strerror(errno));
106 }
107
108 const char **get_pathspec(const char *prefix, const char **pathspec)
109 {
110         const char *entry = *pathspec;
111         const char **p;
112         int prefixlen;
113
114         if (!prefix && !entry)
115                 return NULL;
116
117         if (!entry) {
118                 static const char *spec[2];
119                 spec[0] = prefix;
120                 spec[1] = NULL;
121                 return spec;
122         }
123
124         /* Otherwise we have to re-write the entries.. */
125         p = pathspec;
126         prefixlen = prefix ? strlen(prefix) : 0;
127         do {
128                 *p = prefix_path(prefix, prefixlen, entry);
129         } while ((entry = *++p) != NULL);
130         return (const char **) pathspec;
131 }
132
133 /*
134  * Test if it looks like we're at a git directory.
135  * We want to see:
136  *
137  *  - either a objects/ directory _or_ the proper
138  *    GIT_OBJECT_DIRECTORY environment variable
139  *  - a refs/ directory
140  *  - either a HEAD symlink or a HEAD file that is formatted as
141  *    a proper "ref:", or a regular file HEAD that has a properly
142  *    formatted sha1 object name.
143  */
144 static int is_git_directory(const char *suspect)
145 {
146         char path[PATH_MAX];
147         size_t len = strlen(suspect);
148
149         strcpy(path, suspect);
150         if (getenv(DB_ENVIRONMENT)) {
151                 if (access(getenv(DB_ENVIRONMENT), X_OK))
152                         return 0;
153         }
154         else {
155                 strcpy(path + len, "/objects");
156                 if (access(path, X_OK))
157                         return 0;
158         }
159
160         strcpy(path + len, "/refs");
161         if (access(path, X_OK))
162                 return 0;
163
164         strcpy(path + len, "/HEAD");
165         if (validate_headref(path))
166                 return 0;
167
168         return 1;
169 }
170
171 const char *setup_git_directory_gently(int *nongit_ok)
172 {
173         static char cwd[PATH_MAX+1];
174         const char *gitdirenv;
175         int len, offset;
176
177         /*
178          * If GIT_DIR is set explicitly, we're not going
179          * to do any discovery, but we still do repository
180          * validation.
181          */
182         gitdirenv = getenv(GIT_DIR_ENVIRONMENT);
183         if (gitdirenv) {
184                 if (PATH_MAX - 40 < strlen(gitdirenv))
185                         die("'$%s' too big", GIT_DIR_ENVIRONMENT);
186                 if (is_git_directory(gitdirenv))
187                         return NULL;
188                 if (nongit_ok) {
189                         *nongit_ok = 1;
190                         return NULL;
191                 }
192                 die("Not a git repository: '%s'", gitdirenv);
193         }
194
195         if (!getcwd(cwd, sizeof(cwd)) || cwd[0] != '/')
196                 die("Unable to read current working directory");
197
198         offset = len = strlen(cwd);
199         for (;;) {
200                 if (is_git_directory(".git"))
201                         break;
202                 chdir("..");
203                 do {
204                         if (!offset) {
205                                 if (is_git_directory(cwd)) {
206                                         if (chdir(cwd))
207                                                 die("Cannot come back to cwd");
208                                         setenv(GIT_DIR_ENVIRONMENT, cwd, 1);
209                                         return NULL;
210                                 }
211                                 if (nongit_ok) {
212                                         if (chdir(cwd))
213                                                 die("Cannot come back to cwd");
214                                         *nongit_ok = 1;
215                                         return NULL;
216                                 }
217                                 die("Not a git repository");
218                         }
219                 } while (cwd[--offset] != '/');
220         }
221
222         if (offset == len)
223                 return NULL;
224
225         /* Make "offset" point to past the '/', and add a '/' at the end */
226         offset++;
227         cwd[len++] = '/';
228         cwd[len] = 0;
229         return cwd + offset;
230 }
231
232 int git_config_perm(const char *var, const char *value)
233 {
234         if (value) {
235                 if (!strcmp(value, "umask"))
236                         return PERM_UMASK;
237                 if (!strcmp(value, "group"))
238                         return PERM_GROUP;
239                 if (!strcmp(value, "all") ||
240                     !strcmp(value, "world") ||
241                     !strcmp(value, "everybody"))
242                         return PERM_EVERYBODY;
243         }
244         return git_config_bool(var, value);
245 }
246
247 int check_repository_format_version(const char *var, const char *value)
248 {
249        if (strcmp(var, "core.repositoryformatversion") == 0)
250                repository_format_version = git_config_int(var, value);
251         else if (strcmp(var, "core.sharedrepository") == 0)
252                 shared_repository = git_config_perm(var, value);
253        return 0;
254 }
255
256 int check_repository_format(void)
257 {
258         git_config(check_repository_format_version);
259         if (GIT_REPO_VERSION < repository_format_version)
260                 die ("Expected git repo version <= %d, found %d",
261                      GIT_REPO_VERSION, repository_format_version);
262         return 0;
263 }
264
265 const char *setup_git_directory(void)
266 {
267         const char *retval = setup_git_directory_gently(NULL);
268         check_repository_format();
269         return retval;
270 }