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