2005-04-07 22:16:10 +00:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-04-07 22:13:13 +00:00
|
|
|
#include "cache.h"
|
2006-05-19 10:03:57 +00:00
|
|
|
#include "builtin.h"
|
2005-04-07 22:13:13 +00:00
|
|
|
|
2005-08-06 19:50:14 +00:00
|
|
|
#ifndef DEFAULT_GIT_TEMPLATE_DIR
|
2007-06-11 09:10:47 +00:00
|
|
|
#define DEFAULT_GIT_TEMPLATE_DIR "/usr/share/git-core/templates"
|
2005-08-06 19:50:14 +00:00
|
|
|
#endif
|
|
|
|
|
2006-12-31 04:53:55 +00:00
|
|
|
#ifdef NO_TRUSTABLE_FILEMODE
|
|
|
|
#define TEST_FILEMODE 0
|
|
|
|
#else
|
|
|
|
#define TEST_FILEMODE 1
|
|
|
|
#endif
|
|
|
|
|
2005-12-22 22:19:37 +00:00
|
|
|
static void safe_create_dir(const char *dir, int share)
|
2005-04-20 04:48:15 +00:00
|
|
|
{
|
2005-07-06 08:21:46 +00:00
|
|
|
if (mkdir(dir, 0777) < 0) {
|
2005-04-20 04:48:15 +00:00
|
|
|
if (errno != EEXIST) {
|
|
|
|
perror(dir);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
2005-12-22 22:19:37 +00:00
|
|
|
else if (share && adjust_shared_perm(dir))
|
|
|
|
die("Could not make %s writable by group\n", dir);
|
2005-04-20 04:48:15 +00:00
|
|
|
}
|
|
|
|
|
2005-08-02 23:45:21 +00:00
|
|
|
static int copy_file(const char *dst, const char *src, int mode)
|
|
|
|
{
|
2005-11-05 19:07:22 +00:00
|
|
|
int fdi, fdo, status;
|
2005-08-02 23:45:21 +00:00
|
|
|
|
|
|
|
mode = (mode & 0111) ? 0777 : 0666;
|
|
|
|
if ((fdi = open(src, O_RDONLY)) < 0)
|
|
|
|
return fdi;
|
|
|
|
if ((fdo = open(dst, O_WRONLY | O_CREAT | O_EXCL, mode)) < 0) {
|
|
|
|
close(fdi);
|
|
|
|
return fdo;
|
|
|
|
}
|
2005-11-05 19:07:22 +00:00
|
|
|
status = copy_fd(fdi, fdo);
|
2007-06-24 19:20:41 +00:00
|
|
|
if (close(fdo) != 0)
|
|
|
|
return error("%s: write error: %s", dst, strerror(errno));
|
2005-12-22 22:19:37 +00:00
|
|
|
|
|
|
|
if (!status && adjust_shared_perm(dst))
|
|
|
|
return -1;
|
|
|
|
|
2005-11-05 19:07:22 +00:00
|
|
|
return status;
|
2005-08-02 23:45:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void copy_templates_1(char *path, int baselen,
|
|
|
|
char *template, int template_baselen,
|
|
|
|
DIR *dir)
|
|
|
|
{
|
|
|
|
struct dirent *de;
|
|
|
|
|
|
|
|
/* Note: if ".git/hooks" file exists in the repository being
|
|
|
|
* re-initialized, /etc/core-git/templates/hooks/update would
|
2007-01-12 21:01:46 +00:00
|
|
|
* cause git-init to fail here. I think this is sane but
|
2005-08-02 23:45:21 +00:00
|
|
|
* it means that the set of templates we ship by default, along
|
|
|
|
* with the way the namespace under .git/ is organized, should
|
|
|
|
* be really carefully chosen.
|
|
|
|
*/
|
2005-12-22 22:19:37 +00:00
|
|
|
safe_create_dir(path, 1);
|
2005-08-02 23:45:21 +00:00
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
|
|
struct stat st_git, st_template;
|
|
|
|
int namelen;
|
|
|
|
int exists = 0;
|
|
|
|
|
|
|
|
if (de->d_name[0] == '.')
|
|
|
|
continue;
|
|
|
|
namelen = strlen(de->d_name);
|
|
|
|
if ((PATH_MAX <= baselen + namelen) ||
|
|
|
|
(PATH_MAX <= template_baselen + namelen))
|
|
|
|
die("insanely long template name %s", de->d_name);
|
|
|
|
memcpy(path + baselen, de->d_name, namelen+1);
|
|
|
|
memcpy(template + template_baselen, de->d_name, namelen+1);
|
|
|
|
if (lstat(path, &st_git)) {
|
|
|
|
if (errno != ENOENT)
|
|
|
|
die("cannot stat %s", path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
exists = 1;
|
|
|
|
|
|
|
|
if (lstat(template, &st_template))
|
|
|
|
die("cannot stat template %s", template);
|
|
|
|
|
|
|
|
if (S_ISDIR(st_template.st_mode)) {
|
|
|
|
DIR *subdir = opendir(template);
|
|
|
|
int baselen_sub = baselen + namelen;
|
|
|
|
int template_baselen_sub = template_baselen + namelen;
|
|
|
|
if (!subdir)
|
|
|
|
die("cannot opendir %s", template);
|
|
|
|
path[baselen_sub++] =
|
|
|
|
template[template_baselen_sub++] = '/';
|
|
|
|
path[baselen_sub] =
|
|
|
|
template[template_baselen_sub] = 0;
|
|
|
|
copy_templates_1(path, baselen_sub,
|
|
|
|
template, template_baselen_sub,
|
|
|
|
subdir);
|
|
|
|
closedir(subdir);
|
|
|
|
}
|
|
|
|
else if (exists)
|
|
|
|
continue;
|
|
|
|
else if (S_ISLNK(st_template.st_mode)) {
|
|
|
|
char lnk[256];
|
|
|
|
int len;
|
|
|
|
len = readlink(template, lnk, sizeof(lnk));
|
|
|
|
if (len < 0)
|
|
|
|
die("cannot readlink %s", template);
|
|
|
|
if (sizeof(lnk) <= len)
|
|
|
|
die("insanely long symlink %s", template);
|
|
|
|
lnk[len] = 0;
|
|
|
|
if (symlink(lnk, path))
|
|
|
|
die("cannot symlink %s %s", lnk, path);
|
|
|
|
}
|
|
|
|
else if (S_ISREG(st_template.st_mode)) {
|
|
|
|
if (copy_file(path, template, st_template.st_mode))
|
|
|
|
die("cannot copy %s to %s", template, path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
error("ignoring template %s", template);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-19 10:03:57 +00:00
|
|
|
static void copy_templates(const char *git_dir, int len, const char *template_dir)
|
2005-08-02 23:45:21 +00:00
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
char template_path[PATH_MAX];
|
2005-08-06 19:50:14 +00:00
|
|
|
int template_len;
|
2005-08-02 23:45:21 +00:00
|
|
|
DIR *dir;
|
|
|
|
|
2006-12-19 08:18:09 +00:00
|
|
|
if (!template_dir) {
|
2006-12-19 09:28:15 +00:00
|
|
|
template_dir = getenv(TEMPLATE_DIR_ENVIRONMENT);
|
2006-12-19 08:18:09 +00:00
|
|
|
if (!template_dir)
|
|
|
|
template_dir = DEFAULT_GIT_TEMPLATE_DIR;
|
|
|
|
}
|
2005-08-02 23:45:21 +00:00
|
|
|
strcpy(template_path, template_dir);
|
|
|
|
template_len = strlen(template_path);
|
|
|
|
if (template_path[template_len-1] != '/') {
|
|
|
|
template_path[template_len++] = '/';
|
|
|
|
template_path[template_len] = 0;
|
|
|
|
}
|
|
|
|
dir = opendir(template_path);
|
2005-08-06 19:50:14 +00:00
|
|
|
if (!dir) {
|
|
|
|
fprintf(stderr, "warning: templates not found %s\n",
|
|
|
|
template_dir);
|
2005-08-02 23:45:21 +00:00
|
|
|
return;
|
2005-08-06 19:50:14 +00:00
|
|
|
}
|
|
|
|
|
2005-11-26 00:03:56 +00:00
|
|
|
/* Make sure that template is from the correct vintage */
|
|
|
|
strcpy(template_path + template_len, "config");
|
|
|
|
repository_format_version = 0;
|
|
|
|
git_config_from_file(check_repository_format_version,
|
|
|
|
template_path);
|
|
|
|
template_path[template_len] = 0;
|
|
|
|
|
|
|
|
if (repository_format_version &&
|
|
|
|
repository_format_version != GIT_REPO_VERSION) {
|
|
|
|
fprintf(stderr, "warning: not copying templates of "
|
|
|
|
"a wrong format version %d from '%s'\n",
|
|
|
|
repository_format_version,
|
|
|
|
template_dir);
|
|
|
|
closedir(dir);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-08-06 19:50:14 +00:00
|
|
|
memcpy(path, git_dir, len);
|
2005-09-20 00:19:50 +00:00
|
|
|
path[len] = 0;
|
2005-08-02 23:45:21 +00:00
|
|
|
copy_templates_1(path, len,
|
|
|
|
template_path, template_len,
|
|
|
|
dir);
|
|
|
|
closedir(dir);
|
|
|
|
}
|
|
|
|
|
2007-07-03 22:49:19 +00:00
|
|
|
/*
|
|
|
|
* Get the full path to the working tree specified in $GIT_WORK_TREE
|
|
|
|
* or NULL if no working tree is specified.
|
|
|
|
*/
|
|
|
|
static const char *get_work_tree(void)
|
|
|
|
{
|
|
|
|
const char *git_work_tree;
|
|
|
|
char cwd[PATH_MAX];
|
|
|
|
static char worktree[PATH_MAX];
|
|
|
|
|
|
|
|
git_work_tree = getenv(GIT_WORK_TREE_ENVIRONMENT);
|
|
|
|
if (!git_work_tree)
|
|
|
|
return NULL;
|
|
|
|
if (!getcwd(cwd, sizeof(cwd)))
|
|
|
|
die("Unable to read current working directory");
|
|
|
|
if (chdir(git_work_tree))
|
|
|
|
die("Cannot change directory to specified working tree '%s'",
|
|
|
|
git_work_tree);
|
|
|
|
if (git_work_tree[0] != '/') {
|
|
|
|
if (!getcwd(worktree, sizeof(worktree)))
|
|
|
|
die("Unable to read current working directory");
|
|
|
|
git_work_tree = worktree;
|
|
|
|
}
|
|
|
|
if (chdir(cwd))
|
|
|
|
die("Cannot come back to cwd");
|
|
|
|
return git_work_tree;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int create_default_files(const char *git_dir, const char *git_work_tree,
|
|
|
|
const char *template_path)
|
2005-05-30 17:20:44 +00:00
|
|
|
{
|
|
|
|
unsigned len = strlen(git_dir);
|
|
|
|
static char path[PATH_MAX];
|
2005-09-30 21:26:57 +00:00
|
|
|
unsigned char sha1[20];
|
2005-11-26 00:03:56 +00:00
|
|
|
struct stat st1;
|
|
|
|
char repo_version_string[10];
|
2006-12-15 05:44:58 +00:00
|
|
|
int reinit;
|
2006-12-31 04:53:55 +00:00
|
|
|
int filemode;
|
2005-05-30 17:20:44 +00:00
|
|
|
|
|
|
|
if (len > sizeof(path)-50)
|
|
|
|
die("insane git directory %s", git_dir);
|
|
|
|
memcpy(path, git_dir, len);
|
|
|
|
|
|
|
|
if (len && path[len-1] != '/')
|
|
|
|
path[len++] = '/';
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create .git/refs/{heads,tags}
|
|
|
|
*/
|
|
|
|
strcpy(path + len, "refs");
|
2005-12-22 22:19:37 +00:00
|
|
|
safe_create_dir(path, 1);
|
2005-05-30 17:20:44 +00:00
|
|
|
strcpy(path + len, "refs/heads");
|
2005-12-22 22:19:37 +00:00
|
|
|
safe_create_dir(path, 1);
|
2005-05-30 17:20:44 +00:00
|
|
|
strcpy(path + len, "refs/tags");
|
2005-12-22 22:19:37 +00:00
|
|
|
safe_create_dir(path, 1);
|
2005-05-30 17:20:44 +00:00
|
|
|
|
2005-11-26 00:03:56 +00:00
|
|
|
/* First copy the templates -- we might have the default
|
|
|
|
* config file there, in which case we would want to read
|
|
|
|
* from it after installing.
|
|
|
|
*/
|
|
|
|
path[len] = 0;
|
|
|
|
copy_templates(path, len, template_path);
|
|
|
|
|
|
|
|
git_config(git_default_config);
|
|
|
|
|
2006-06-10 05:07:23 +00:00
|
|
|
/*
|
|
|
|
* We would have created the above under user's umask -- under
|
|
|
|
* shared-repository settings, we would need to fix them up.
|
|
|
|
*/
|
|
|
|
if (shared_repository) {
|
|
|
|
path[len] = 0;
|
|
|
|
adjust_shared_perm(path);
|
|
|
|
strcpy(path + len, "refs");
|
|
|
|
adjust_shared_perm(path);
|
|
|
|
strcpy(path + len, "refs/heads");
|
|
|
|
adjust_shared_perm(path);
|
|
|
|
strcpy(path + len, "refs/tags");
|
|
|
|
adjust_shared_perm(path);
|
|
|
|
}
|
|
|
|
|
2005-05-30 17:20:44 +00:00
|
|
|
/*
|
|
|
|
* Create the default symlink from ".git/HEAD" to the "master"
|
2005-09-30 21:26:57 +00:00
|
|
|
* branch, if it does not exist yet.
|
2005-05-30 17:20:44 +00:00
|
|
|
*/
|
|
|
|
strcpy(path + len, "HEAD");
|
2006-12-15 05:44:58 +00:00
|
|
|
reinit = !read_ref("HEAD", sha1);
|
|
|
|
if (!reinit) {
|
2007-01-26 22:26:10 +00:00
|
|
|
if (create_symref("HEAD", "refs/heads/master", NULL) < 0)
|
2005-05-30 17:20:44 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
2005-10-25 23:43:03 +00:00
|
|
|
|
2005-11-26 00:03:56 +00:00
|
|
|
/* This forces creation of new config file */
|
|
|
|
sprintf(repo_version_string, "%d", GIT_REPO_VERSION);
|
|
|
|
git_config_set("core.repositoryformatversion", repo_version_string);
|
|
|
|
|
|
|
|
path[len] = 0;
|
2005-10-25 23:43:03 +00:00
|
|
|
strcpy(path + len, "config");
|
2005-11-26 00:03:56 +00:00
|
|
|
|
|
|
|
/* Check filemode trustability */
|
2006-12-31 04:53:55 +00:00
|
|
|
filemode = TEST_FILEMODE;
|
|
|
|
if (TEST_FILEMODE && !lstat(path, &st1)) {
|
2005-11-26 00:03:56 +00:00
|
|
|
struct stat st2;
|
2006-12-31 04:53:55 +00:00
|
|
|
filemode = (!chmod(path, st1.st_mode ^ S_IXUSR) &&
|
2005-11-26 00:03:56 +00:00
|
|
|
!lstat(path, &st2) &&
|
|
|
|
st1.st_mode != st2.st_mode);
|
2005-10-25 23:43:03 +00:00
|
|
|
}
|
2006-12-31 04:53:55 +00:00
|
|
|
git_config_set("core.filemode", filemode ? "true" : "false");
|
2006-12-15 05:44:58 +00:00
|
|
|
|
2007-07-03 22:49:19 +00:00
|
|
|
if (is_bare_repository() && !git_work_tree) {
|
2007-01-07 10:00:28 +00:00
|
|
|
git_config_set("core.bare", "true");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
git_config_set("core.bare", "false");
|
2007-01-23 15:51:18 +00:00
|
|
|
/* allow template config file to override the default */
|
|
|
|
if (log_all_ref_updates == -1)
|
|
|
|
git_config_set("core.logallrefupdates", "true");
|
2007-07-03 22:49:19 +00:00
|
|
|
if (git_work_tree)
|
|
|
|
git_config_set("core.worktree", git_work_tree);
|
2007-01-07 10:00:28 +00:00
|
|
|
}
|
2006-12-15 05:44:58 +00:00
|
|
|
return reinit;
|
2005-05-30 17:20:44 +00:00
|
|
|
}
|
|
|
|
|
2005-08-06 19:50:14 +00:00
|
|
|
static const char init_db_usage[] =
|
2007-06-07 12:50:29 +00:00
|
|
|
"git-init [-q | --quiet] [--template=<template-directory>] [--shared]";
|
2005-08-06 19:50:14 +00:00
|
|
|
|
2005-04-20 04:48:15 +00:00
|
|
|
/*
|
|
|
|
* If you want to, you can share the DB area with any number of branches.
|
|
|
|
* That has advantages: you can save space by sharing all the SHA1 objects.
|
|
|
|
* On the other hand, it might just make lookup slower and messier. You
|
|
|
|
* be the judge. The default case is to have one DB per managed directory.
|
|
|
|
*/
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_init_db(int argc, const char **argv, const char *prefix)
|
2005-04-07 22:13:13 +00:00
|
|
|
{
|
2005-05-30 17:20:44 +00:00
|
|
|
const char *git_dir;
|
2007-07-03 22:49:19 +00:00
|
|
|
const char *git_work_tree;
|
2005-05-10 00:57:56 +00:00
|
|
|
const char *sha1_dir;
|
2006-05-19 10:03:57 +00:00
|
|
|
const char *template_dir = NULL;
|
|
|
|
char *path;
|
2006-12-15 05:44:58 +00:00
|
|
|
int len, i, reinit;
|
2007-06-07 12:50:29 +00:00
|
|
|
int quiet = 0;
|
2005-04-07 22:13:13 +00:00
|
|
|
|
2005-08-06 19:50:14 +00:00
|
|
|
for (i = 1; i < argc; i++, argv++) {
|
2006-05-19 10:03:57 +00:00
|
|
|
const char *arg = argv[1];
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
if (!prefixcmp(arg, "--template="))
|
2005-08-06 19:50:14 +00:00
|
|
|
template_dir = arg+11;
|
2005-12-22 22:19:37 +00:00
|
|
|
else if (!strcmp(arg, "--shared"))
|
2006-06-10 06:09:49 +00:00
|
|
|
shared_repository = PERM_GROUP;
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 09:53:29 +00:00
|
|
|
else if (!prefixcmp(arg, "--shared="))
|
2006-06-10 06:09:49 +00:00
|
|
|
shared_repository = git_config_perm("arg", arg+9);
|
2007-06-07 12:50:29 +00:00
|
|
|
else if (!strcmp(arg, "-q") || !strcmp(arg, "--quiet"))
|
|
|
|
quiet = 1;
|
2005-08-06 19:50:14 +00:00
|
|
|
else
|
2006-08-03 15:48:41 +00:00
|
|
|
usage(init_db_usage);
|
2005-08-06 19:50:14 +00:00
|
|
|
}
|
|
|
|
|
2007-07-03 22:49:19 +00:00
|
|
|
git_work_tree = get_work_tree();
|
|
|
|
|
2005-05-30 17:20:44 +00:00
|
|
|
/*
|
|
|
|
* Set up the default .git directory contents
|
|
|
|
*/
|
2005-09-09 21:48:54 +00:00
|
|
|
git_dir = getenv(GIT_DIR_ENVIRONMENT);
|
2006-12-15 05:44:58 +00:00
|
|
|
if (!git_dir)
|
2005-05-30 17:20:44 +00:00
|
|
|
git_dir = DEFAULT_GIT_DIR_ENVIRONMENT;
|
2005-12-22 22:19:37 +00:00
|
|
|
safe_create_dir(git_dir, 0);
|
2005-11-26 00:03:56 +00:00
|
|
|
|
|
|
|
/* Check to see if the repository version is right.
|
|
|
|
* Note that a newly created repository does not have
|
|
|
|
* config file, so this will not fail. What we are catching
|
|
|
|
* is an attempt to reinitialize new repository with an old tool.
|
|
|
|
*/
|
|
|
|
check_repository_format();
|
|
|
|
|
2007-07-03 22:49:19 +00:00
|
|
|
reinit = create_default_files(git_dir, git_work_tree, template_dir);
|
2005-05-30 17:20:44 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* And set up the object store.
|
|
|
|
*/
|
|
|
|
sha1_dir = get_object_directory();
|
2005-04-07 22:13:13 +00:00
|
|
|
len = strlen(sha1_dir);
|
2005-04-26 19:00:58 +00:00
|
|
|
path = xmalloc(len + 40);
|
2005-04-07 22:13:13 +00:00
|
|
|
memcpy(path, sha1_dir, len);
|
2005-04-20 04:48:15 +00:00
|
|
|
|
2005-12-22 22:19:37 +00:00
|
|
|
safe_create_dir(sha1_dir, 1);
|
2005-06-28 01:26:11 +00:00
|
|
|
strcpy(path+len, "/pack");
|
2005-12-22 22:19:37 +00:00
|
|
|
safe_create_dir(path, 1);
|
2005-08-20 09:05:31 +00:00
|
|
|
strcpy(path+len, "/info");
|
2005-12-22 22:19:37 +00:00
|
|
|
safe_create_dir(path, 1);
|
|
|
|
|
2006-06-10 06:09:49 +00:00
|
|
|
if (shared_repository) {
|
|
|
|
char buf[10];
|
|
|
|
/* We do not spell "group" and such, so that
|
|
|
|
* the configuration can be read by older version
|
|
|
|
* of git.
|
|
|
|
*/
|
|
|
|
sprintf(buf, "%d", shared_repository);
|
|
|
|
git_config_set("core.sharedrepository", buf);
|
2006-09-20 23:07:54 +00:00
|
|
|
git_config_set("receive.denyNonFastforwards", "true");
|
2006-06-10 06:09:49 +00:00
|
|
|
}
|
2005-12-22 22:19:37 +00:00
|
|
|
|
2007-06-07 12:50:29 +00:00
|
|
|
if (!quiet)
|
|
|
|
printf("%s%s Git repository in %s/\n",
|
|
|
|
reinit ? "Reinitialized existing" : "Initialized empty",
|
|
|
|
shared_repository ? " shared" : "",
|
|
|
|
git_dir);
|
2006-12-15 05:44:58 +00:00
|
|
|
|
2005-04-07 22:13:13 +00:00
|
|
|
return 0;
|
|
|
|
}
|