]>
Commit | Line | Data |
---|---|---|
8bc9a0c7 LT |
1 | /* |
2 | * GIT - The information manager from hell | |
3 | * | |
4 | * Copyright (C) Linus Torvalds, 2005 | |
5 | */ | |
e83c5163 | 6 | #include "cache.h" |
c3c8835f | 7 | #include "builtin.h" |
a47d1813 | 8 | #include "exec_cmd.h" |
e83c5163 | 9 | |
d3af621b | 10 | #ifndef DEFAULT_GIT_TEMPLATE_DIR |
d52fd42a | 11 | #define DEFAULT_GIT_TEMPLATE_DIR "/usr/share/git-core/templates" |
d3af621b JH |
12 | #endif |
13 | ||
c869753e SP |
14 | #ifdef NO_TRUSTABLE_FILEMODE |
15 | #define TEST_FILEMODE 0 | |
16 | #else | |
17 | #define TEST_FILEMODE 1 | |
18 | #endif | |
19 | ||
af6e277c | 20 | static void safe_create_dir(const char *dir, int share) |
cb126d8d | 21 | { |
f312de01 | 22 | if (mkdir(dir, 0777) < 0) { |
cb126d8d ZW |
23 | if (errno != EEXIST) { |
24 | perror(dir); | |
25 | exit(1); | |
26 | } | |
27 | } | |
af6e277c JS |
28 | else if (share && adjust_shared_perm(dir)) |
29 | die("Could not make %s writable by group\n", dir); | |
cb126d8d ZW |
30 | } |
31 | ||
8d5afef0 JH |
32 | static int copy_file(const char *dst, const char *src, int mode) |
33 | { | |
32276c80 | 34 | int fdi, fdo, status; |
8d5afef0 JH |
35 | |
36 | mode = (mode & 0111) ? 0777 : 0666; | |
37 | if ((fdi = open(src, O_RDONLY)) < 0) | |
38 | return fdi; | |
39 | if ((fdo = open(dst, O_WRONLY | O_CREAT | O_EXCL, mode)) < 0) { | |
40 | close(fdi); | |
41 | return fdo; | |
42 | } | |
32276c80 | 43 | status = copy_fd(fdi, fdo); |
91c8d590 JM |
44 | if (close(fdo) != 0) |
45 | return error("%s: write error: %s", dst, strerror(errno)); | |
af6e277c JS |
46 | |
47 | if (!status && adjust_shared_perm(dst)) | |
48 | return -1; | |
49 | ||
32276c80 | 50 | return status; |
8d5afef0 JH |
51 | } |
52 | ||
53 | static void copy_templates_1(char *path, int baselen, | |
54 | char *template, int template_baselen, | |
55 | DIR *dir) | |
56 | { | |
57 | struct dirent *de; | |
58 | ||
59 | /* Note: if ".git/hooks" file exists in the repository being | |
60 | * re-initialized, /etc/core-git/templates/hooks/update would | |
5c94f87e | 61 | * cause git-init to fail here. I think this is sane but |
8d5afef0 JH |
62 | * it means that the set of templates we ship by default, along |
63 | * with the way the namespace under .git/ is organized, should | |
64 | * be really carefully chosen. | |
65 | */ | |
af6e277c | 66 | safe_create_dir(path, 1); |
8d5afef0 JH |
67 | while ((de = readdir(dir)) != NULL) { |
68 | struct stat st_git, st_template; | |
69 | int namelen; | |
70 | int exists = 0; | |
71 | ||
72 | if (de->d_name[0] == '.') | |
73 | continue; | |
74 | namelen = strlen(de->d_name); | |
75 | if ((PATH_MAX <= baselen + namelen) || | |
76 | (PATH_MAX <= template_baselen + namelen)) | |
77 | die("insanely long template name %s", de->d_name); | |
78 | memcpy(path + baselen, de->d_name, namelen+1); | |
79 | memcpy(template + template_baselen, de->d_name, namelen+1); | |
80 | if (lstat(path, &st_git)) { | |
81 | if (errno != ENOENT) | |
82 | die("cannot stat %s", path); | |
83 | } | |
84 | else | |
85 | exists = 1; | |
86 | ||
87 | if (lstat(template, &st_template)) | |
88 | die("cannot stat template %s", template); | |
89 | ||
90 | if (S_ISDIR(st_template.st_mode)) { | |
91 | DIR *subdir = opendir(template); | |
92 | int baselen_sub = baselen + namelen; | |
93 | int template_baselen_sub = template_baselen + namelen; | |
94 | if (!subdir) | |
95 | die("cannot opendir %s", template); | |
96 | path[baselen_sub++] = | |
97 | template[template_baselen_sub++] = '/'; | |
98 | path[baselen_sub] = | |
99 | template[template_baselen_sub] = 0; | |
100 | copy_templates_1(path, baselen_sub, | |
101 | template, template_baselen_sub, | |
102 | subdir); | |
103 | closedir(subdir); | |
104 | } | |
105 | else if (exists) | |
106 | continue; | |
107 | else if (S_ISLNK(st_template.st_mode)) { | |
108 | char lnk[256]; | |
109 | int len; | |
110 | len = readlink(template, lnk, sizeof(lnk)); | |
111 | if (len < 0) | |
112 | die("cannot readlink %s", template); | |
113 | if (sizeof(lnk) <= len) | |
114 | die("insanely long symlink %s", template); | |
115 | lnk[len] = 0; | |
116 | if (symlink(lnk, path)) | |
117 | die("cannot symlink %s %s", lnk, path); | |
118 | } | |
119 | else if (S_ISREG(st_template.st_mode)) { | |
120 | if (copy_file(path, template, st_template.st_mode)) | |
121 | die("cannot copy %s to %s", template, path); | |
122 | } | |
123 | else | |
124 | error("ignoring template %s", template); | |
125 | } | |
126 | } | |
127 | ||
c3c8835f | 128 | static void copy_templates(const char *git_dir, int len, const char *template_dir) |
8d5afef0 JH |
129 | { |
130 | char path[PATH_MAX]; | |
131 | char template_path[PATH_MAX]; | |
d3af621b | 132 | int template_len; |
8d5afef0 JH |
133 | DIR *dir; |
134 | ||
a47d1813 | 135 | if (!template_dir) |
d4ebc36c | 136 | template_dir = getenv(TEMPLATE_DIR_ENVIRONMENT); |
a47d1813 JS |
137 | if (!template_dir) { |
138 | /* | |
139 | * if the hard-coded template is relative, it is | |
140 | * interpreted relative to the exec_dir | |
141 | */ | |
142 | template_dir = DEFAULT_GIT_TEMPLATE_DIR; | |
143 | if (!is_absolute_path(template_dir)) { | |
ef5b9d6e JS |
144 | struct strbuf d = STRBUF_INIT; |
145 | strbuf_addf(&d, "%s/%s", git_exec_path(), template_dir); | |
146 | template_dir = strbuf_detach(&d, NULL); | |
a47d1813 | 147 | } |
8683a45d | 148 | } |
8d5afef0 JH |
149 | strcpy(template_path, template_dir); |
150 | template_len = strlen(template_path); | |
151 | if (template_path[template_len-1] != '/') { | |
152 | template_path[template_len++] = '/'; | |
153 | template_path[template_len] = 0; | |
154 | } | |
8d5afef0 | 155 | dir = opendir(template_path); |
d3af621b JH |
156 | if (!dir) { |
157 | fprintf(stderr, "warning: templates not found %s\n", | |
158 | template_dir); | |
8d5afef0 | 159 | return; |
d3af621b JH |
160 | } |
161 | ||
4f629539 JH |
162 | /* Make sure that template is from the correct vintage */ |
163 | strcpy(template_path + template_len, "config"); | |
164 | repository_format_version = 0; | |
165 | git_config_from_file(check_repository_format_version, | |
166 | template_path); | |
167 | template_path[template_len] = 0; | |
168 | ||
169 | if (repository_format_version && | |
170 | repository_format_version != GIT_REPO_VERSION) { | |
171 | fprintf(stderr, "warning: not copying templates of " | |
172 | "a wrong format version %d from '%s'\n", | |
173 | repository_format_version, | |
174 | template_dir); | |
175 | closedir(dir); | |
176 | return; | |
177 | } | |
178 | ||
d3af621b | 179 | memcpy(path, git_dir, len); |
1f961c19 | 180 | path[len] = 0; |
8d5afef0 JH |
181 | copy_templates_1(path, len, |
182 | template_path, template_len, | |
183 | dir); | |
184 | closedir(dir); | |
185 | } | |
186 | ||
e90fdc39 | 187 | static int create_default_files(const char *git_dir, const char *template_path) |
cad88fdf LT |
188 | { |
189 | unsigned len = strlen(git_dir); | |
190 | static char path[PATH_MAX]; | |
8098a178 | 191 | unsigned char sha1[20]; |
4f629539 JH |
192 | struct stat st1; |
193 | char repo_version_string[10]; | |
ef0a89a6 | 194 | int reinit; |
c869753e | 195 | int filemode; |
cad88fdf LT |
196 | |
197 | if (len > sizeof(path)-50) | |
198 | die("insane git directory %s", git_dir); | |
199 | memcpy(path, git_dir, len); | |
200 | ||
201 | if (len && path[len-1] != '/') | |
202 | path[len++] = '/'; | |
203 | ||
204 | /* | |
205 | * Create .git/refs/{heads,tags} | |
206 | */ | |
207 | strcpy(path + len, "refs"); | |
af6e277c | 208 | safe_create_dir(path, 1); |
cad88fdf | 209 | strcpy(path + len, "refs/heads"); |
af6e277c | 210 | safe_create_dir(path, 1); |
cad88fdf | 211 | strcpy(path + len, "refs/tags"); |
af6e277c | 212 | safe_create_dir(path, 1); |
cad88fdf | 213 | |
4f629539 JH |
214 | /* First copy the templates -- we might have the default |
215 | * config file there, in which case we would want to read | |
216 | * from it after installing. | |
217 | */ | |
218 | path[len] = 0; | |
219 | copy_templates(path, len, template_path); | |
220 | ||
221 | git_config(git_default_config); | |
222 | ||
138086a7 JH |
223 | /* |
224 | * We would have created the above under user's umask -- under | |
225 | * shared-repository settings, we would need to fix them up. | |
226 | */ | |
227 | if (shared_repository) { | |
228 | path[len] = 0; | |
229 | adjust_shared_perm(path); | |
230 | strcpy(path + len, "refs"); | |
231 | adjust_shared_perm(path); | |
232 | strcpy(path + len, "refs/heads"); | |
233 | adjust_shared_perm(path); | |
234 | strcpy(path + len, "refs/tags"); | |
235 | adjust_shared_perm(path); | |
236 | } | |
237 | ||
cad88fdf LT |
238 | /* |
239 | * Create the default symlink from ".git/HEAD" to the "master" | |
8098a178 | 240 | * branch, if it does not exist yet. |
cad88fdf LT |
241 | */ |
242 | strcpy(path + len, "HEAD"); | |
ef0a89a6 SP |
243 | reinit = !read_ref("HEAD", sha1); |
244 | if (!reinit) { | |
8b5157e4 | 245 | if (create_symref("HEAD", "refs/heads/master", NULL) < 0) |
cad88fdf | 246 | exit(1); |
cad88fdf | 247 | } |
e24317b4 | 248 | |
4f629539 JH |
249 | /* This forces creation of new config file */ |
250 | sprintf(repo_version_string, "%d", GIT_REPO_VERSION); | |
251 | git_config_set("core.repositoryformatversion", repo_version_string); | |
252 | ||
253 | path[len] = 0; | |
e24317b4 | 254 | strcpy(path + len, "config"); |
4f629539 JH |
255 | |
256 | /* Check filemode trustability */ | |
c869753e SP |
257 | filemode = TEST_FILEMODE; |
258 | if (TEST_FILEMODE && !lstat(path, &st1)) { | |
4f629539 | 259 | struct stat st2; |
c869753e | 260 | filemode = (!chmod(path, st1.st_mode ^ S_IXUSR) && |
4f629539 JH |
261 | !lstat(path, &st2) && |
262 | st1.st_mode != st2.st_mode); | |
e24317b4 | 263 | } |
c869753e | 264 | git_config_set("core.filemode", filemode ? "true" : "false"); |
ef0a89a6 | 265 | |
e90fdc39 | 266 | if (is_bare_repository()) |
7d1864ce | 267 | git_config_set("core.bare", "true"); |
7d1864ce | 268 | else { |
e90fdc39 | 269 | const char *work_tree = get_git_work_tree(); |
7d1864ce | 270 | git_config_set("core.bare", "false"); |
196055c2 AR |
271 | /* allow template config file to override the default */ |
272 | if (log_all_ref_updates == -1) | |
273 | git_config_set("core.logallrefupdates", "true"); | |
e90fdc39 JS |
274 | if (work_tree != git_work_tree_cfg) |
275 | git_config_set("core.worktree", work_tree); | |
7d1864ce | 276 | } |
75d24499 JH |
277 | |
278 | /* Check if symlink is supported in the work tree */ | |
279 | if (!reinit) { | |
280 | path[len] = 0; | |
281 | strcpy(path + len, "tXXXXXX"); | |
282 | if (!close(xmkstemp(path)) && | |
283 | !unlink(path) && | |
284 | !symlink("testing", path) && | |
285 | !lstat(path, &st1) && | |
286 | S_ISLNK(st1.st_mode)) | |
287 | unlink(path); /* good */ | |
288 | else | |
289 | git_config_set("core.symlinks", "false"); | |
290 | } | |
291 | ||
ef0a89a6 | 292 | return reinit; |
cad88fdf LT |
293 | } |
294 | ||
6adcca3f JH |
295 | static void guess_repository_type(const char *git_dir) |
296 | { | |
297 | char cwd[PATH_MAX]; | |
298 | const char *slash; | |
299 | ||
300 | if (0 <= is_bare_repository_cfg) | |
301 | return; | |
302 | if (!git_dir) | |
303 | return; | |
304 | ||
305 | /* | |
306 | * "GIT_DIR=. git init" is always bare. | |
307 | * "GIT_DIR=`pwd` git init" too. | |
308 | */ | |
309 | if (!strcmp(".", git_dir)) | |
310 | goto force_bare; | |
311 | if (!getcwd(cwd, sizeof(cwd))) | |
312 | die("cannot tell cwd"); | |
313 | if (!strcmp(git_dir, cwd)) | |
314 | goto force_bare; | |
315 | /* | |
316 | * "GIT_DIR=.git or GIT_DIR=something/.git is usually not. | |
317 | */ | |
318 | if (!strcmp(git_dir, ".git")) | |
319 | return; | |
320 | slash = strrchr(git_dir, '/'); | |
321 | if (slash && !strcmp(slash, "/.git")) | |
322 | return; | |
323 | ||
324 | /* | |
325 | * Otherwise it is often bare. At this point | |
326 | * we are just guessing. | |
327 | */ | |
328 | force_bare: | |
329 | is_bare_repository_cfg = 1; | |
330 | return; | |
331 | } | |
332 | ||
d3af621b | 333 | static const char init_db_usage[] = |
4576518d | 334 | "git-init [-q | --quiet] [--template=<template-directory>] [--shared]"; |
d3af621b | 335 | |
4696cb93 ZW |
336 | /* |
337 | * If you want to, you can share the DB area with any number of branches. | |
338 | * That has advantages: you can save space by sharing all the SHA1 objects. | |
339 | * On the other hand, it might just make lookup slower and messier. You | |
340 | * be the judge. The default case is to have one DB per managed directory. | |
341 | */ | |
a633fca0 | 342 | int cmd_init_db(int argc, const char **argv, const char *prefix) |
e83c5163 | 343 | { |
cad88fdf | 344 | const char *git_dir; |
d19938ab | 345 | const char *sha1_dir; |
c3c8835f TH |
346 | const char *template_dir = NULL; |
347 | char *path; | |
ef0a89a6 | 348 | int len, i, reinit; |
4576518d | 349 | int quiet = 0; |
e83c5163 | 350 | |
d3af621b | 351 | for (i = 1; i < argc; i++, argv++) { |
c3c8835f | 352 | const char *arg = argv[1]; |
cc44c765 | 353 | if (!prefixcmp(arg, "--template=")) |
d3af621b | 354 | template_dir = arg+11; |
af6e277c | 355 | else if (!strcmp(arg, "--shared")) |
94df2506 | 356 | shared_repository = PERM_GROUP; |
cc44c765 | 357 | else if (!prefixcmp(arg, "--shared=")) |
94df2506 | 358 | shared_repository = git_config_perm("arg", arg+9); |
4576518d JO |
359 | else if (!strcmp(arg, "-q") || !strcmp(arg, "--quiet")) |
360 | quiet = 1; | |
d3af621b | 361 | else |
8cdf3364 | 362 | usage(init_db_usage); |
d3af621b JH |
363 | } |
364 | ||
6adcca3f JH |
365 | /* |
366 | * GIT_WORK_TREE makes sense only in conjunction with GIT_DIR | |
367 | * without --bare. Catch the error early. | |
368 | */ | |
369 | git_dir = getenv(GIT_DIR_ENVIRONMENT); | |
370 | if ((!git_dir || is_bare_repository_cfg == 1) | |
371 | && getenv(GIT_WORK_TREE_ENVIRONMENT)) | |
372 | die("%s (or --work-tree=<directory>) not allowed without " | |
373 | "specifying %s (or --git-dir=<directory>)", | |
374 | GIT_WORK_TREE_ENVIRONMENT, | |
375 | GIT_DIR_ENVIRONMENT); | |
376 | ||
377 | guess_repository_type(git_dir); | |
378 | ||
379 | if (is_bare_repository_cfg <= 0) { | |
380 | git_work_tree_cfg = xcalloc(PATH_MAX, 1); | |
381 | if (!getcwd(git_work_tree_cfg, PATH_MAX)) | |
382 | die ("Cannot access current working directory."); | |
383 | if (access(get_git_work_tree(), X_OK)) | |
384 | die ("Cannot access work tree '%s'", | |
385 | get_git_work_tree()); | |
386 | } | |
ef6f0af2 | 387 | |
cad88fdf LT |
388 | /* |
389 | * Set up the default .git directory contents | |
390 | */ | |
a9ab586a | 391 | git_dir = getenv(GIT_DIR_ENVIRONMENT); |
ef0a89a6 | 392 | if (!git_dir) |
cad88fdf | 393 | git_dir = DEFAULT_GIT_DIR_ENVIRONMENT; |
af6e277c | 394 | safe_create_dir(git_dir, 0); |
4f629539 JH |
395 | |
396 | /* Check to see if the repository version is right. | |
397 | * Note that a newly created repository does not have | |
398 | * config file, so this will not fail. What we are catching | |
399 | * is an attempt to reinitialize new repository with an old tool. | |
400 | */ | |
401 | check_repository_format(); | |
402 | ||
e90fdc39 | 403 | reinit = create_default_files(git_dir, template_dir); |
cad88fdf LT |
404 | |
405 | /* | |
406 | * And set up the object store. | |
407 | */ | |
408 | sha1_dir = get_object_directory(); | |
e83c5163 | 409 | len = strlen(sha1_dir); |
812666c8 | 410 | path = xmalloc(len + 40); |
e83c5163 | 411 | memcpy(path, sha1_dir, len); |
cb126d8d | 412 | |
af6e277c | 413 | safe_create_dir(sha1_dir, 1); |
f49fb35d | 414 | strcpy(path+len, "/pack"); |
af6e277c | 415 | safe_create_dir(path, 1); |
d57306c7 | 416 | strcpy(path+len, "/info"); |
af6e277c JS |
417 | safe_create_dir(path, 1); |
418 | ||
94df2506 JH |
419 | if (shared_repository) { |
420 | char buf[10]; | |
421 | /* We do not spell "group" and such, so that | |
422 | * the configuration can be read by older version | |
423 | * of git. | |
424 | */ | |
425 | sprintf(buf, "%d", shared_repository); | |
426 | git_config_set("core.sharedrepository", buf); | |
11031d7e | 427 | git_config_set("receive.denyNonFastforwards", "true"); |
94df2506 | 428 | } |
af6e277c | 429 | |
4576518d JO |
430 | if (!quiet) |
431 | printf("%s%s Git repository in %s/\n", | |
432 | reinit ? "Reinitialized existing" : "Initialized empty", | |
433 | shared_repository ? " shared" : "", | |
434 | git_dir); | |
ef0a89a6 | 435 | |
e83c5163 LT |
436 | return 0; |
437 | } |