]>
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" |
0b027f6c | 7 | #include "abspath.h" |
b2141fc1 | 8 | #include "config.h" |
d5fff46f | 9 | #include "copy.h" |
32a8f510 | 10 | #include "environment.h" |
f394e093 | 11 | #include "gettext.h" |
fb58c8d5 | 12 | #include "refs.h" |
c3c8835f | 13 | #include "builtin.h" |
d807c4a0 | 14 | #include "exec-cmd.h" |
87bed179 | 15 | #include "object-file.h" |
596f91ee | 16 | #include "parse-options.h" |
d1cbe1e6 | 17 | #include "path.h" |
e38da487 | 18 | #include "setup.h" |
42264bc8 | 19 | #include "worktree.h" |
d5ebb50d | 20 | #include "wrapper.h" |
e83c5163 | 21 | |
d3af621b | 22 | #ifndef DEFAULT_GIT_TEMPLATE_DIR |
d52fd42a | 23 | #define DEFAULT_GIT_TEMPLATE_DIR "/usr/share/git-core/templates" |
d3af621b JH |
24 | #endif |
25 | ||
c869753e SP |
26 | #ifdef NO_TRUSTABLE_FILEMODE |
27 | #define TEST_FILEMODE 0 | |
28 | #else | |
29 | #define TEST_FILEMODE 1 | |
30 | #endif | |
31 | ||
3c9331a1 | 32 | #define GIT_DEFAULT_HASH_ENVIRONMENT "GIT_DEFAULT_HASH" |
33 | ||
0a2c7eea DM |
34 | static int init_is_bare_repository = 0; |
35 | static int init_shared_repository = -1; | |
36 | ||
fa0fccae | 37 | static void copy_templates_1(struct strbuf *path, struct strbuf *template_path, |
8d5afef0 JH |
38 | DIR *dir) |
39 | { | |
9c28390b | 40 | size_t path_baselen = path->len; |
fa0fccae | 41 | size_t template_baselen = template_path->len; |
8d5afef0 JH |
42 | struct dirent *de; |
43 | ||
44 | /* Note: if ".git/hooks" file exists in the repository being | |
45 | * re-initialized, /etc/core-git/templates/hooks/update would | |
f18d244a | 46 | * cause "git init" to fail here. I think this is sane but |
8d5afef0 JH |
47 | * it means that the set of templates we ship by default, along |
48 | * with the way the namespace under .git/ is organized, should | |
49 | * be really carefully chosen. | |
50 | */ | |
9c28390b | 51 | safe_create_dir(path->buf, 1); |
8d5afef0 JH |
52 | while ((de = readdir(dir)) != NULL) { |
53 | struct stat st_git, st_template; | |
8d5afef0 JH |
54 | int exists = 0; |
55 | ||
9c28390b | 56 | strbuf_setlen(path, path_baselen); |
fa0fccae | 57 | strbuf_setlen(template_path, template_baselen); |
9c28390b | 58 | |
8d5afef0 JH |
59 | if (de->d_name[0] == '.') |
60 | continue; | |
9c28390b | 61 | strbuf_addstr(path, de->d_name); |
fa0fccae | 62 | strbuf_addstr(template_path, de->d_name); |
9c28390b | 63 | if (lstat(path->buf, &st_git)) { |
8d5afef0 | 64 | if (errno != ENOENT) |
9c28390b | 65 | die_errno(_("cannot stat '%s'"), path->buf); |
8d5afef0 JH |
66 | } |
67 | else | |
68 | exists = 1; | |
69 | ||
fa0fccae BW |
70 | if (lstat(template_path->buf, &st_template)) |
71 | die_errno(_("cannot stat template '%s'"), template_path->buf); | |
8d5afef0 JH |
72 | |
73 | if (S_ISDIR(st_template.st_mode)) { | |
fa0fccae | 74 | DIR *subdir = opendir(template_path->buf); |
8d5afef0 | 75 | if (!subdir) |
fa0fccae | 76 | die_errno(_("cannot opendir '%s'"), template_path->buf); |
9c28390b | 77 | strbuf_addch(path, '/'); |
fa0fccae BW |
78 | strbuf_addch(template_path, '/'); |
79 | copy_templates_1(path, template_path, subdir); | |
8d5afef0 JH |
80 | closedir(subdir); |
81 | } | |
82 | else if (exists) | |
83 | continue; | |
84 | else if (S_ISLNK(st_template.st_mode)) { | |
9c28390b | 85 | struct strbuf lnk = STRBUF_INIT; |
765b496d JK |
86 | if (strbuf_readlink(&lnk, template_path->buf, |
87 | st_template.st_size) < 0) | |
fa0fccae | 88 | die_errno(_("cannot readlink '%s'"), template_path->buf); |
9c28390b JK |
89 | if (symlink(lnk.buf, path->buf)) |
90 | die_errno(_("cannot symlink '%s' '%s'"), | |
91 | lnk.buf, path->buf); | |
92 | strbuf_release(&lnk); | |
8d5afef0 JH |
93 | } |
94 | else if (S_ISREG(st_template.st_mode)) { | |
fa0fccae | 95 | if (copy_file(path->buf, template_path->buf, st_template.st_mode)) |
9c28390b | 96 | die_errno(_("cannot copy '%s' to '%s'"), |
fa0fccae | 97 | template_path->buf, path->buf); |
8d5afef0 JH |
98 | } |
99 | else | |
fa0fccae | 100 | error(_("ignoring template %s"), template_path->buf); |
8d5afef0 JH |
101 | } |
102 | } | |
103 | ||
e4de4502 | 104 | static void copy_templates(const char *template_dir, const char *init_template_dir) |
8d5afef0 | 105 | { |
9c28390b JK |
106 | struct strbuf path = STRBUF_INIT; |
107 | struct strbuf template_path = STRBUF_INIT; | |
108 | size_t template_len; | |
e8805af1 | 109 | struct repository_format template_format = REPOSITORY_FORMAT_INIT; |
94ce1672 | 110 | struct strbuf err = STRBUF_INIT; |
8d5afef0 | 111 | DIR *dir; |
59362e56 | 112 | char *to_free = NULL; |
8d5afef0 | 113 | |
a47d1813 | 114 | if (!template_dir) |
d4ebc36c | 115 | template_dir = getenv(TEMPLATE_DIR_ENVIRONMENT); |
90b45187 | 116 | if (!template_dir) |
e4de4502 | 117 | template_dir = init_template_dir; |
2de9de5e | 118 | if (!template_dir) |
59362e56 JH |
119 | template_dir = to_free = system_path(DEFAULT_GIT_TEMPLATE_DIR); |
120 | if (!template_dir[0]) { | |
121 | free(to_free); | |
172035f0 | 122 | return; |
59362e56 | 123 | } |
9c28390b JK |
124 | |
125 | strbuf_addstr(&template_path, template_dir); | |
126 | strbuf_complete(&template_path, '/'); | |
127 | template_len = template_path.len; | |
128 | ||
129 | dir = opendir(template_path.buf); | |
d3af621b | 130 | if (!dir) { |
44f560fc | 131 | warning(_("templates not found in %s"), template_dir); |
59362e56 | 132 | goto free_return; |
d3af621b JH |
133 | } |
134 | ||
4f629539 | 135 | /* Make sure that template is from the correct vintage */ |
9c28390b | 136 | strbuf_addstr(&template_path, "config"); |
94ce1672 | 137 | read_repository_format(&template_format, template_path.buf); |
9c28390b | 138 | strbuf_setlen(&template_path, template_len); |
4f629539 | 139 | |
94ce1672 JK |
140 | /* |
141 | * No mention of version at all is OK, but anything else should be | |
142 | * verified. | |
143 | */ | |
144 | if (template_format.version >= 0 && | |
145 | verify_repository_format(&template_format, &err) < 0) { | |
146 | warning(_("not copying templates from '%s': %s"), | |
147 | template_dir, err.buf); | |
148 | strbuf_release(&err); | |
59362e56 | 149 | goto close_free_return; |
4f629539 JH |
150 | } |
151 | ||
fe9aa0b2 | 152 | strbuf_addstr(&path, get_git_common_dir()); |
9c28390b JK |
153 | strbuf_complete(&path, '/'); |
154 | copy_templates_1(&path, &template_path, dir); | |
59362e56 | 155 | close_free_return: |
8d5afef0 | 156 | closedir(dir); |
59362e56 JH |
157 | free_return: |
158 | free(to_free); | |
9c28390b JK |
159 | strbuf_release(&path); |
160 | strbuf_release(&template_path); | |
e8805af1 | 161 | clear_repository_format(&template_format); |
8d5afef0 JH |
162 | } |
163 | ||
84ccad8d JK |
164 | /* |
165 | * If the git_dir is not directly inside the working tree, then git will not | |
166 | * find it by default, and we need to set the worktree explicitly. | |
167 | */ | |
168 | static int needs_work_tree_config(const char *git_dir, const char *work_tree) | |
169 | { | |
170 | if (!strcmp(work_tree, "/") && !strcmp(git_dir, "/.git")) | |
171 | return 0; | |
172 | if (skip_prefix(git_dir, work_tree, &git_dir) && | |
173 | !strcmp(git_dir, "/.git")) | |
174 | return 0; | |
175 | return 1; | |
176 | } | |
177 | ||
47ac9703 | 178 | void initialize_repository_version(int hash_algo, int reinit) |
efa7ae36 | 179 | { |
180 | char repo_version_string[10]; | |
181 | int repo_version = GIT_REPO_VERSION; | |
182 | ||
efa7ae36 | 183 | if (hash_algo != GIT_HASH_SHA1) |
184 | repo_version = GIT_REPO_VERSION_READ; | |
185 | ||
186 | /* This forces creation of new config file */ | |
187 | xsnprintf(repo_version_string, sizeof(repo_version_string), | |
188 | "%d", repo_version); | |
189 | git_config_set("core.repositoryformatversion", repo_version_string); | |
190 | ||
191 | if (hash_algo != GIT_HASH_SHA1) | |
192 | git_config_set("extensions.objectformat", | |
193 | hash_algos[hash_algo].name); | |
47ac9703 | 194 | else if (reinit) |
195 | git_config_set_gently("extensions.objectformat", NULL); | |
efa7ae36 | 196 | } |
197 | ||
6311cfaf | 198 | static int create_default_files(const char *template_path, |
8b8f7189 | 199 | const char *original_git_dir, |
32ba12da | 200 | const char *initial_branch, |
cc0f13c5 JS |
201 | const struct repository_format *fmt, |
202 | int quiet) | |
cad88fdf | 203 | { |
4f629539 | 204 | struct stat st1; |
9c28390b JK |
205 | struct strbuf buf = STRBUF_INIT; |
206 | char *path; | |
5cc8f372 | 207 | char junk[2]; |
ef0a89a6 | 208 | int reinit; |
c869753e | 209 | int filemode; |
6fb5acfd | 210 | struct strbuf err = STRBUF_INIT; |
e4de4502 | 211 | const char *init_template_dir = NULL; |
75555676 | 212 | const char *work_tree = get_git_work_tree(); |
cad88fdf | 213 | |
7c0a842b JK |
214 | /* |
215 | * First copy the templates -- we might have the default | |
4f629539 JH |
216 | * config file there, in which case we would want to read |
217 | * from it after installing. | |
4543926b JK |
218 | * |
219 | * Before reading that config, we also need to clear out any cached | |
220 | * values (since we've just potentially changed what's available on | |
221 | * disk). | |
4f629539 | 222 | */ |
a185dd58 | 223 | git_config_get_pathname("init.templatedir", &init_template_dir); |
e4de4502 | 224 | copy_templates(template_path, init_template_dir); |
a185dd58 | 225 | free((char *)init_template_dir); |
4543926b JK |
226 | git_config_clear(); |
227 | reset_shared_repository(); | |
ef90d6d4 | 228 | git_config(git_default_config, NULL); |
5a688fe4 | 229 | |
7c0a842b JK |
230 | /* |
231 | * We must make sure command-line options continue to override any | |
232 | * values we might have just re-read from the config. | |
233 | */ | |
75555676 | 234 | is_bare_repository_cfg = init_is_bare_repository || !work_tree; |
0a2c7eea | 235 | if (init_shared_repository != -1) |
7875acb6 | 236 | set_shared_repository(init_shared_repository); |
4f629539 | 237 | |
138086a7 JH |
238 | /* |
239 | * We would have created the above under user's umask -- under | |
240 | * shared-repository settings, we would need to fix them up. | |
241 | */ | |
7875acb6 | 242 | if (get_shared_repository()) { |
f225aeb2 | 243 | adjust_shared_perm(get_git_dir()); |
138086a7 JH |
244 | } |
245 | ||
6fb5acfd DT |
246 | /* |
247 | * We need to create a "refs" dir in any case so that older | |
248 | * versions of git can tell that this is a repository. | |
249 | */ | |
250 | safe_create_dir(git_path("refs"), 1); | |
251 | adjust_shared_perm(git_path("refs")); | |
252 | ||
253 | if (refs_init_db(&err)) | |
254 | die("failed to set up refs db: %s", err.buf); | |
255 | ||
cad88fdf | 256 | /* |
32ba12da JS |
257 | * Point the HEAD symref to the initial branch with if HEAD does |
258 | * not yet exist. | |
cad88fdf | 259 | */ |
9c28390b | 260 | path = git_path_buf(&buf, "HEAD"); |
5cc8f372 JS |
261 | reinit = (!access(path, R_OK) |
262 | || readlink(path, junk, sizeof(junk)-1) != -1); | |
ef0a89a6 | 263 | if (!reinit) { |
32ba12da JS |
264 | char *ref; |
265 | ||
266 | if (!initial_branch) | |
cc0f13c5 | 267 | initial_branch = git_default_branch_name(quiet); |
32ba12da JS |
268 | |
269 | ref = xstrfmt("refs/heads/%s", initial_branch); | |
270 | if (check_refname_format(ref, 0) < 0) | |
271 | die(_("invalid initial branch name: '%s'"), | |
272 | initial_branch); | |
273 | ||
274 | if (create_symref("HEAD", ref, NULL) < 0) | |
cad88fdf | 275 | exit(1); |
32ba12da | 276 | free(ref); |
cad88fdf | 277 | } |
e24317b4 | 278 | |
47ac9703 | 279 | initialize_repository_version(fmt->hash_algo, 0); |
4f629539 | 280 | |
4f629539 | 281 | /* Check filemode trustability */ |
9c28390b | 282 | path = git_path_buf(&buf, "config"); |
c869753e SP |
283 | filemode = TEST_FILEMODE; |
284 | if (TEST_FILEMODE && !lstat(path, &st1)) { | |
4f629539 | 285 | struct stat st2; |
c869753e | 286 | filemode = (!chmod(path, st1.st_mode ^ S_IXUSR) && |
4f629539 | 287 | !lstat(path, &st2) && |
1f32ecff MH |
288 | st1.st_mode != st2.st_mode && |
289 | !chmod(path, st1.st_mode)); | |
c7bf68d6 TB |
290 | if (filemode && !reinit && (st1.st_mode & S_IXUSR)) |
291 | filemode = 0; | |
e24317b4 | 292 | } |
3d180648 | 293 | git_config_set("core.filemode", filemode ? "true" : "false"); |
ef0a89a6 | 294 | |
e90fdc39 | 295 | if (is_bare_repository()) |
3d180648 | 296 | git_config_set("core.bare", "true"); |
7d1864ce | 297 | else { |
3d180648 | 298 | git_config_set("core.bare", "false"); |
196055c2 | 299 | /* allow template config file to override the default */ |
341fb286 | 300 | if (log_all_ref_updates == LOG_REFS_UNSET) |
3d180648 | 301 | git_config_set("core.logallrefupdates", "true"); |
6311cfaf | 302 | if (needs_work_tree_config(original_git_dir, work_tree)) |
3d180648 | 303 | git_config_set("core.worktree", work_tree); |
7d1864ce | 304 | } |
75d24499 | 305 | |
75d24499 | 306 | if (!reinit) { |
2455406a | 307 | /* Check if symlink is supported in the work tree */ |
9c28390b | 308 | path = git_path_buf(&buf, "tXXXXXX"); |
75d24499 JH |
309 | if (!close(xmkstemp(path)) && |
310 | !unlink(path) && | |
311 | !symlink("testing", path) && | |
312 | !lstat(path, &st1) && | |
313 | S_ISLNK(st1.st_mode)) | |
314 | unlink(path); /* good */ | |
315 | else | |
3d180648 | 316 | git_config_set("core.symlinks", "false"); |
2455406a DP |
317 | |
318 | /* Check if the filesystem is case-insensitive */ | |
9c28390b | 319 | path = git_path_buf(&buf, "CoNfIg"); |
2455406a | 320 | if (!access(path, F_OK)) |
3d180648 | 321 | git_config_set("core.ignorecase", "true"); |
fdf72966 | 322 | probe_utf8_pathname_composition(); |
75d24499 JH |
323 | } |
324 | ||
9c28390b | 325 | strbuf_release(&buf); |
ef0a89a6 | 326 | return reinit; |
cad88fdf LT |
327 | } |
328 | ||
9173912b JN |
329 | static void create_object_directory(void) |
330 | { | |
9c28390b JK |
331 | struct strbuf path = STRBUF_INIT; |
332 | size_t baselen; | |
333 | ||
334 | strbuf_addstr(&path, get_object_directory()); | |
335 | baselen = path.len; | |
336 | ||
337 | safe_create_dir(path.buf, 1); | |
9173912b | 338 | |
9c28390b JK |
339 | strbuf_setlen(&path, baselen); |
340 | strbuf_addstr(&path, "/pack"); | |
341 | safe_create_dir(path.buf, 1); | |
9173912b | 342 | |
9c28390b JK |
343 | strbuf_setlen(&path, baselen); |
344 | strbuf_addstr(&path, "/info"); | |
345 | safe_create_dir(path.buf, 1); | |
9173912b | 346 | |
9c28390b | 347 | strbuf_release(&path); |
9173912b JN |
348 | } |
349 | ||
822d9406 | 350 | static void separate_git_dir(const char *git_dir, const char *git_link) |
b57fb80a NTND |
351 | { |
352 | struct stat st; | |
b57fb80a NTND |
353 | |
354 | if (!stat(git_link, &st)) { | |
355 | const char *src; | |
356 | ||
357 | if (S_ISREG(st.st_mode)) | |
13d6ec91 | 358 | src = read_gitfile(git_link); |
b57fb80a NTND |
359 | else if (S_ISDIR(st.st_mode)) |
360 | src = git_link; | |
361 | else | |
97f261b1 | 362 | die(_("unable to handle file type %d"), (int)st.st_mode); |
b57fb80a NTND |
363 | |
364 | if (rename(src, git_dir)) | |
2c050e01 | 365 | die_errno(_("unable to move %s to %s"), src, git_dir); |
42264bc8 | 366 | repair_worktrees(NULL, NULL); |
b57fb80a NTND |
367 | } |
368 | ||
1f76a10b | 369 | write_file(git_link, "gitdir: %s", git_dir); |
b57fb80a NTND |
370 | } |
371 | ||
8b8f7189 | 372 | static void validate_hash_algorithm(struct repository_format *repo_fmt, int hash) |
373 | { | |
3c9331a1 | 374 | const char *env = getenv(GIT_DEFAULT_HASH_ENVIRONMENT); |
8b8f7189 | 375 | /* |
376 | * If we already have an initialized repo, don't allow the user to | |
377 | * specify a different algorithm, as that could cause corruption. | |
378 | * Otherwise, if the user has specified one on the command line, use it. | |
379 | */ | |
380 | if (repo_fmt->version >= 0 && hash != GIT_HASH_UNKNOWN && hash != repo_fmt->hash_algo) | |
381 | die(_("attempt to reinitialize repository with different hash")); | |
382 | else if (hash != GIT_HASH_UNKNOWN) | |
383 | repo_fmt->hash_algo = hash; | |
3c9331a1 | 384 | else if (env) { |
385 | int env_algo = hash_algo_by_name(env); | |
386 | if (env_algo == GIT_HASH_UNKNOWN) | |
387 | die(_("unknown hash algorithm '%s'"), env); | |
388 | repo_fmt->hash_algo = env_algo; | |
389 | } | |
8b8f7189 | 390 | } |
391 | ||
33158701 | 392 | int init_db(const char *git_dir, const char *real_git_dir, |
32ba12da JS |
393 | const char *template_dir, int hash, const char *initial_branch, |
394 | unsigned int flags) | |
f225aeb2 | 395 | { |
9173912b | 396 | int reinit; |
1bd19079 | 397 | int exist_ok = flags & INIT_DB_EXIST_OK; |
ce83eadd | 398 | char *original_git_dir = real_pathdup(git_dir, 1); |
8b8f7189 | 399 | struct repository_format repo_fmt = REPOSITORY_FORMAT_INIT; |
33158701 | 400 | |
1bd19079 NTND |
401 | if (real_git_dir) { |
402 | struct stat st; | |
33158701 | 403 | |
1bd19079 NTND |
404 | if (!exist_ok && !stat(git_dir, &st)) |
405 | die(_("%s already exists"), git_dir); | |
406 | ||
407 | if (!exist_ok && !stat(real_git_dir, &st)) | |
408 | die(_("%s already exists"), real_git_dir); | |
f225aeb2 | 409 | |
0915a5b4 | 410 | set_git_dir(real_git_dir, 1); |
822d9406 NTND |
411 | git_dir = get_git_dir(); |
412 | separate_git_dir(git_dir, original_git_dir); | |
1bd19079 NTND |
413 | } |
414 | else { | |
0915a5b4 | 415 | set_git_dir(git_dir, 1); |
822d9406 | 416 | git_dir = get_git_dir(); |
1bd19079 NTND |
417 | } |
418 | startup_info->have_repository = 1; | |
f225aeb2 | 419 | |
e4de4502 AH |
420 | /* Ensure `core.hidedotfiles` is processed */ |
421 | git_config(platform_core_config, NULL); | |
28785339 | 422 | |
b57fb80a | 423 | safe_create_dir(git_dir, 0); |
f225aeb2 | 424 | |
0a2c7eea DM |
425 | init_is_bare_repository = is_bare_repository(); |
426 | ||
f225aeb2 DB |
427 | /* Check to see if the repository version is right. |
428 | * Note that a newly created repository does not have | |
429 | * config file, so this will not fail. What we are catching | |
430 | * is an attempt to reinitialize new repository with an old tool. | |
431 | */ | |
8b8f7189 | 432 | check_repository_format(&repo_fmt); |
f225aeb2 | 433 | |
8b8f7189 | 434 | validate_hash_algorithm(&repo_fmt, hash); |
435 | ||
32ba12da | 436 | reinit = create_default_files(template_dir, original_git_dir, |
cc0f13c5 JS |
437 | initial_branch, &repo_fmt, |
438 | flags & INIT_DB_QUIET); | |
32ba12da JS |
439 | if (reinit && initial_branch) |
440 | warning(_("re-init: ignored --initial-branch=%s"), | |
441 | initial_branch); | |
f225aeb2 | 442 | |
9173912b | 443 | create_object_directory(); |
f225aeb2 | 444 | |
7875acb6 | 445 | if (get_shared_repository()) { |
f225aeb2 DB |
446 | char buf[10]; |
447 | /* We do not spell "group" and such, so that | |
448 | * the configuration can be read by older version | |
449 | * of git. Note, we use octal numbers for new share modes, | |
450 | * and compatibility values for PERM_GROUP and | |
451 | * PERM_EVERYBODY. | |
452 | */ | |
7875acb6 | 453 | if (get_shared_repository() < 0) |
5a688fe4 | 454 | /* force to the mode value */ |
7875acb6 JK |
455 | xsnprintf(buf, sizeof(buf), "0%o", -get_shared_repository()); |
456 | else if (get_shared_repository() == PERM_GROUP) | |
5096d490 | 457 | xsnprintf(buf, sizeof(buf), "%d", OLD_PERM_GROUP); |
7875acb6 | 458 | else if (get_shared_repository() == PERM_EVERYBODY) |
5096d490 | 459 | xsnprintf(buf, sizeof(buf), "%d", OLD_PERM_EVERYBODY); |
f225aeb2 | 460 | else |
033abf97 | 461 | BUG("invalid value for shared_repository"); |
3d180648 PS |
462 | git_config_set("core.sharedrepository", buf); |
463 | git_config_set("receive.denyNonFastforwards", "true"); | |
f225aeb2 DB |
464 | } |
465 | ||
d06f15d9 | 466 | if (!(flags & INIT_DB_QUIET)) { |
d06f15d9 | 467 | int len = strlen(git_dir); |
3e5dd7e9 | 468 | |
c30364d0 VA |
469 | if (reinit) |
470 | printf(get_shared_repository() | |
471 | ? _("Reinitialized existing shared Git repository in %s%s\n") | |
472 | : _("Reinitialized existing Git repository in %s%s\n"), | |
473 | git_dir, len && git_dir[len-1] != '/' ? "/" : ""); | |
474 | else | |
475 | printf(get_shared_repository() | |
476 | ? _("Initialized empty shared Git repository in %s%s\n") | |
477 | : _("Initialized empty Git repository in %s%s\n"), | |
478 | git_dir, len && git_dir[len-1] != '/' ? "/" : ""); | |
d06f15d9 | 479 | } |
f225aeb2 | 480 | |
6311cfaf | 481 | free(original_git_dir); |
f225aeb2 DB |
482 | return 0; |
483 | } | |
484 | ||
485 | static int guess_repository_type(const char *git_dir) | |
6adcca3f | 486 | { |
6adcca3f | 487 | const char *slash; |
56b9f6e7 RS |
488 | char *cwd; |
489 | int cwd_is_git_dir; | |
6adcca3f | 490 | |
6adcca3f JH |
491 | /* |
492 | * "GIT_DIR=. git init" is always bare. | |
493 | * "GIT_DIR=`pwd` git init" too. | |
494 | */ | |
495 | if (!strcmp(".", git_dir)) | |
f225aeb2 | 496 | return 1; |
56b9f6e7 RS |
497 | cwd = xgetcwd(); |
498 | cwd_is_git_dir = !strcmp(git_dir, cwd); | |
499 | free(cwd); | |
500 | if (cwd_is_git_dir) | |
f225aeb2 | 501 | return 1; |
6adcca3f JH |
502 | /* |
503 | * "GIT_DIR=.git or GIT_DIR=something/.git is usually not. | |
504 | */ | |
505 | if (!strcmp(git_dir, ".git")) | |
f225aeb2 | 506 | return 0; |
6adcca3f JH |
507 | slash = strrchr(git_dir, '/'); |
508 | if (slash && !strcmp(slash, "/.git")) | |
f225aeb2 | 509 | return 0; |
6adcca3f JH |
510 | |
511 | /* | |
512 | * Otherwise it is often bare. At this point | |
513 | * we are just guessing. | |
514 | */ | |
f225aeb2 | 515 | return 1; |
6adcca3f JH |
516 | } |
517 | ||
596f91ee MK |
518 | static int shared_callback(const struct option *opt, const char *arg, int unset) |
519 | { | |
517fe807 | 520 | BUG_ON_OPT_NEG(unset); |
596f91ee MK |
521 | *((int *) opt->value) = (arg) ? git_config_perm("arg", arg) : PERM_GROUP; |
522 | return 0; | |
523 | } | |
524 | ||
525 | static const char *const init_db_usage[] = { | |
5af8b61c | 526 | N_("git init [-q | --quiet] [--bare] [--template=<template-directory>]\n" |
d9054a19 ÆAB |
527 | " [--separate-git-dir <git-dir>] [--object-format=<format>]\n" |
528 | " [-b <branch-name> | --initial-branch=<branch-name>]\n" | |
5af8b61c | 529 | " [--shared[=<permissions>]] [<directory>]"), |
596f91ee MK |
530 | NULL |
531 | }; | |
d3af621b | 532 | |
4696cb93 ZW |
533 | /* |
534 | * If you want to, you can share the DB area with any number of branches. | |
535 | * That has advantages: you can save space by sharing all the SHA1 objects. | |
536 | * On the other hand, it might just make lookup slower and messier. You | |
537 | * be the judge. The default case is to have one DB per managed directory. | |
538 | */ | |
a633fca0 | 539 | int cmd_init_db(int argc, const char **argv, const char *prefix) |
e83c5163 | 540 | { |
cad88fdf | 541 | const char *git_dir; |
b57fb80a | 542 | const char *real_git_dir = NULL; |
83518360 | 543 | const char *work_tree; |
c3c8835f | 544 | const char *template_dir = NULL; |
f225aeb2 | 545 | unsigned int flags = 0; |
8b8f7189 | 546 | const char *object_format = NULL; |
32ba12da | 547 | const char *initial_branch = NULL; |
8b8f7189 | 548 | int hash_algo = GIT_HASH_UNKNOWN; |
596f91ee | 549 | const struct option init_db_options[] = { |
ce4a5e53 NTND |
550 | OPT_STRING(0, "template", &template_dir, N_("template-directory"), |
551 | N_("directory from which templates will be used")), | |
596f91ee | 552 | OPT_SET_INT(0, "bare", &is_bare_repository_cfg, |
ce4a5e53 | 553 | N_("create a bare repository"), 1), |
596f91ee | 554 | { OPTION_CALLBACK, 0, "shared", &init_shared_repository, |
ce4a5e53 NTND |
555 | N_("permissions"), |
556 | N_("specify that the git repository is to be shared amongst several users"), | |
596f91ee | 557 | PARSE_OPT_OPTARG | PARSE_OPT_NONEG, shared_callback, 0}, |
ce4a5e53 NTND |
558 | OPT_BIT('q', "quiet", &flags, N_("be quiet"), INIT_DB_QUIET), |
559 | OPT_STRING(0, "separate-git-dir", &real_git_dir, N_("gitdir"), | |
560 | N_("separate git dir from working tree")), | |
32ba12da JS |
561 | OPT_STRING('b', "initial-branch", &initial_branch, N_("name"), |
562 | N_("override the name of the initial branch")), | |
8b8f7189 | 563 | OPT_STRING(0, "object-format", &object_format, N_("hash"), |
564 | N_("specify the hash algorithm to use")), | |
596f91ee MK |
565 | OPT_END() |
566 | }; | |
567 | ||
0397ff24 JH |
568 | argc = parse_options(argc, argv, prefix, init_db_options, init_db_usage, 0); |
569 | ||
ccf236a2 | 570 | if (real_git_dir && is_bare_repository_cfg == 1) |
43ea635c | 571 | die(_("options '%s' and '%s' cannot be used together"), "--separate-git-dir", "--bare"); |
ccf236a2 | 572 | |
b57fb80a | 573 | if (real_git_dir && !is_absolute_path(real_git_dir)) |
ce83eadd | 574 | real_git_dir = real_pathdup(real_git_dir, 1); |
b57fb80a | 575 | |
04fe4d75 | 576 | if (template_dir && *template_dir && !is_absolute_path(template_dir)) { |
e1df7fe4 | 577 | template_dir = absolute_pathdup(template_dir); |
04fe4d75 AH |
578 | UNLEAK(template_dir); |
579 | } | |
e1df7fe4 | 580 | |
0397ff24 | 581 | if (argc == 1) { |
53d48885 NS |
582 | int mkdir_tried = 0; |
583 | retry: | |
0397ff24 | 584 | if (chdir(argv[0]) < 0) { |
53d48885 NS |
585 | if (!mkdir_tried) { |
586 | int saved; | |
587 | /* | |
588 | * At this point we haven't read any configuration, | |
589 | * and we know shared_repository should always be 0; | |
590 | * but just in case we play safe. | |
591 | */ | |
7875acb6 JK |
592 | saved = get_shared_repository(); |
593 | set_shared_repository(0); | |
0397ff24 | 594 | switch (safe_create_leading_directories_const(argv[0])) { |
f3565c0c MH |
595 | case SCLD_OK: |
596 | case SCLD_PERMS: | |
597 | break; | |
0be0521b | 598 | case SCLD_EXISTS: |
53d48885 NS |
599 | errno = EEXIST; |
600 | /* fallthru */ | |
53d48885 | 601 | default: |
f3565c0c | 602 | die_errno(_("cannot mkdir %s"), argv[0]); |
53d48885 NS |
603 | break; |
604 | } | |
7875acb6 | 605 | set_shared_repository(saved); |
0397ff24 | 606 | if (mkdir(argv[0], 0777) < 0) |
33e92e47 | 607 | die_errno(_("cannot mkdir %s"), argv[0]); |
53d48885 NS |
608 | mkdir_tried = 1; |
609 | goto retry; | |
610 | } | |
33e92e47 | 611 | die_errno(_("cannot chdir to %s"), argv[0]); |
53d48885 | 612 | } |
0397ff24 JH |
613 | } else if (0 < argc) { |
614 | usage(init_db_usage[0]); | |
d3af621b | 615 | } |
0397ff24 | 616 | if (is_bare_repository_cfg == 1) { |
4d3ab44d RS |
617 | char *cwd = xgetcwd(); |
618 | setenv(GIT_DIR_ENVIRONMENT, cwd, argc > 0); | |
619 | free(cwd); | |
d3af621b JH |
620 | } |
621 | ||
8b8f7189 | 622 | if (object_format) { |
623 | hash_algo = hash_algo_by_name(object_format); | |
624 | if (hash_algo == GIT_HASH_UNKNOWN) | |
625 | die(_("unknown hash algorithm '%s'"), object_format); | |
626 | } | |
627 | ||
5a688fe4 | 628 | if (init_shared_repository != -1) |
7875acb6 | 629 | set_shared_repository(init_shared_repository); |
5a688fe4 | 630 | |
6adcca3f JH |
631 | /* |
632 | * GIT_WORK_TREE makes sense only in conjunction with GIT_DIR | |
633 | * without --bare. Catch the error early. | |
634 | */ | |
e5b07c53 JK |
635 | git_dir = xstrdup_or_null(getenv(GIT_DIR_ENVIRONMENT)); |
636 | work_tree = xstrdup_or_null(getenv(GIT_WORK_TREE_ENVIRONMENT)); | |
83518360 | 637 | if ((!git_dir || is_bare_repository_cfg == 1) && work_tree) |
33e92e47 ÆAB |
638 | die(_("%s (or --work-tree=<directory>) not allowed without " |
639 | "specifying %s (or --git-dir=<directory>)"), | |
6adcca3f JH |
640 | GIT_WORK_TREE_ENVIRONMENT, |
641 | GIT_DIR_ENVIRONMENT); | |
642 | ||
cad88fdf LT |
643 | /* |
644 | * Set up the default .git directory contents | |
645 | */ | |
ef0a89a6 | 646 | if (!git_dir) |
cad88fdf | 647 | git_dir = DEFAULT_GIT_DIR_ENVIRONMENT; |
af6e277c | 648 | |
59d876cc ES |
649 | /* |
650 | * When --separate-git-dir is used inside a linked worktree, take | |
651 | * care to ensure that the common .git/ directory is relocated, not | |
652 | * the worktree-specific .git/worktrees/<id>/ directory. | |
653 | */ | |
654 | if (real_git_dir) { | |
655 | int err; | |
656 | const char *p; | |
657 | struct strbuf sb = STRBUF_INIT; | |
658 | ||
659 | p = read_gitfile_gently(git_dir, &err); | |
660 | if (p && get_common_dir(&sb, p)) { | |
661 | struct strbuf mainwt = STRBUF_INIT; | |
662 | ||
663 | strbuf_addbuf(&mainwt, &sb); | |
664 | strbuf_strip_suffix(&mainwt, "/.git"); | |
665 | if (chdir(mainwt.buf) < 0) | |
666 | die_errno(_("cannot chdir to %s"), mainwt.buf); | |
667 | strbuf_release(&mainwt); | |
668 | git_dir = strbuf_detach(&sb, NULL); | |
669 | } | |
670 | strbuf_release(&sb); | |
671 | } | |
672 | ||
f225aeb2 DB |
673 | if (is_bare_repository_cfg < 0) |
674 | is_bare_repository_cfg = guess_repository_type(git_dir); | |
675 | ||
676 | if (!is_bare_repository_cfg) { | |
b31d2022 NTND |
677 | const char *git_dir_parent = strrchr(git_dir, '/'); |
678 | if (git_dir_parent) { | |
679 | char *rel = xstrndup(git_dir, git_dir_parent - git_dir); | |
ce83eadd | 680 | git_work_tree_cfg = real_pathdup(rel, 1); |
b31d2022 | 681 | free(rel); |
f225aeb2 | 682 | } |
56b9f6e7 RS |
683 | if (!git_work_tree_cfg) |
684 | git_work_tree_cfg = xgetcwd(); | |
83518360 | 685 | if (work_tree) |
2d186c8b | 686 | set_git_work_tree(work_tree); |
83518360 NTND |
687 | else |
688 | set_git_work_tree(git_work_tree_cfg); | |
f225aeb2 | 689 | if (access(get_git_work_tree(), X_OK)) |
33e92e47 | 690 | die_errno (_("Cannot access work tree '%s'"), |
0721c314 | 691 | get_git_work_tree()); |
94df2506 | 692 | } |
83518360 | 693 | else { |
ccf236a2 ES |
694 | if (real_git_dir) |
695 | die(_("--separate-git-dir incompatible with bare repository")); | |
83518360 | 696 | if (work_tree) |
2d186c8b | 697 | set_git_work_tree(work_tree); |
83518360 | 698 | } |
af6e277c | 699 | |
0e5bba53 | 700 | UNLEAK(real_git_dir); |
e5b07c53 JK |
701 | UNLEAK(git_dir); |
702 | UNLEAK(work_tree); | |
0e5bba53 | 703 | |
33158701 | 704 | flags |= INIT_DB_EXIST_OK; |
32ba12da JS |
705 | return init_db(git_dir, real_git_dir, template_dir, hash_algo, |
706 | initial_branch, flags); | |
e83c5163 | 707 | } |