[thirdparty/git.git] / init-db.c

/*
 * GIT - The information manager from hell
 *
 * Copyright (C) Linus Torvalds, 2005
 */
#include "cache.h"

#ifndef DEFAULT_GIT_TEMPLATE_DIR
#define DEFAULT_GIT_TEMPLATE_DIR "/usr/share/git-core/templates/"
#endif

static void safe_create_dir(const char *dir)
{
	if (mkdir(dir, 0777) < 0) {
		if (errno != EEXIST) {
			perror(dir);
			exit(1);
		}
	}
}

static int copy_file(const char *dst, const char *src, int mode)
{
	int fdi, fdo;

	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;
	}
	while (1) {
		char buf[BUFSIZ];
		ssize_t leni, leno, ofs;
		leni = read(fdi, buf, sizeof(buf));
		if (leni < 0) {
		error_return:
			close(fdo);
			close(fdi);
			return -1;
		}
		if (!leni)
			break;
		ofs = 0;
		do {
			leno = write(fdo, buf+ofs, leni);
			if (leno < 0)
				goto error_return;
			leni -= leno;
			ofs += leno;
		} while (0 < leni);
	}
	close(fdo);
	close(fdi);
	return 0;
}

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
	 * cause git-init-db to fail here.  I think this is sane but
	 * 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.
	 */
	safe_create_dir(path);
	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);
	}
}

static void copy_templates(const char *git_dir, int len, char *template_dir)
{
	char path[PATH_MAX];
	char template_path[PATH_MAX];
	int template_len;
	DIR *dir;

	if (!template_dir)
		template_dir = DEFAULT_GIT_TEMPLATE_DIR;
	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);
	if (!dir) {
		fprintf(stderr, "warning: templates not found %s\n",
			template_dir);
		return;
	}

	memcpy(path, git_dir, len);
	path[len] = 0;
	copy_templates_1(path, len,
			 template_path, template_len,
			 dir);
	closedir(dir);
}

static void create_default_files(const char *git_dir,
				 char *template_path)
{
	unsigned len = strlen(git_dir);
	static char path[PATH_MAX];
	unsigned char sha1[20];

	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");
	safe_create_dir(path);
	strcpy(path + len, "refs/heads");
	safe_create_dir(path);
	strcpy(path + len, "refs/tags");
	safe_create_dir(path);

	/*
	 * Create the default symlink from ".git/HEAD" to the "master"
	 * branch, if it does not exist yet.
	 */
	strcpy(path + len, "HEAD");
	if (read_ref(path, sha1) < 0) {
		if (create_symref(path, "refs/heads/master") < 0)
			exit(1);
	}
	path[len] = 0;
	copy_templates(path, len, template_path);
}

static const char init_db_usage[] =
"git-init-db [--template=<template-directory>]";

/*
 * 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.
 */
int main(int argc, char **argv)
{
	const char *git_dir;
	const char *sha1_dir;
	char *path, *template_dir = NULL;
	int len, i;

	for (i = 1; i < argc; i++, argv++) {
		char *arg = argv[1];
		if (arg[0] != '-')
			break;
		else if (!strncmp(arg, "--template=", 11))
			template_dir = arg+11;
		else
			die(init_db_usage);
	}

	/*
	 * Set up the default .git directory contents
	 */
	git_dir = getenv(GIT_DIR_ENVIRONMENT);
	if (!git_dir) {
		git_dir = DEFAULT_GIT_DIR_ENVIRONMENT;
		fprintf(stderr, "defaulting to local storage area\n");
	}
	safe_create_dir(git_dir);
	create_default_files(git_dir, template_dir);

	/*
	 * And set up the object store.
	 */
	sha1_dir = get_object_directory();
	len = strlen(sha1_dir);
	path = xmalloc(len + 40);
	memcpy(path, sha1_dir, len);

	safe_create_dir(sha1_dir);
	for (i = 0; i < 256; i++) {
		sprintf(path+len, "/%02x", i);
		safe_create_dir(path);
	}
	strcpy(path+len, "/pack");
	safe_create_dir(path);
	strcpy(path+len, "/info");
	safe_create_dir(path);
	return 0;
}
Commit	Line	Data
8bc9a0c7 LT	1	/*
	2	* GIT - The information manager from hell
	3	*
	4	* Copyright (C) Linus Torvalds, 2005
	5	*/
e83c5163 LT	6	#include "cache.h"
e83c5163 LT	7
d3af621b JH	8	#ifndef DEFAULT_GIT_TEMPLATE_DIR
	9	#define DEFAULT_GIT_TEMPLATE_DIR "/usr/share/git-core/templates/"
	10	#endif
	11
e99d59ff	12	static void safe_create_dir(const char *dir)
cb126d8d	13	{
f312de01	14	if (mkdir(dir, 0777) < 0) {
cb126d8d ZW	15	if (errno != EEXIST) {
	16	perror(dir);
	17	exit(1);
	18	}
	19	}
	20	}
	21
8d5afef0 JH	22	static int copy_file(const char dst, const char src, int mode)
	23	{
	24	int fdi, fdo;
	25
	26	mode = (mode & 0111) ? 0777 : 0666;
	27	if ((fdi = open(src, O_RDONLY)) < 0)
	28	return fdi;
	29	if ((fdo = open(dst, O_WRONLY \| O_CREAT \| O_EXCL, mode)) < 0) {
	30	close(fdi);
	31	return fdo;
	32	}
	33	while (1) {
	34	char buf[BUFSIZ];
	35	ssize_t leni, leno, ofs;
	36	leni = read(fdi, buf, sizeof(buf));
	37	if (leni < 0) {
	38	error_return:
	39	close(fdo);
	40	close(fdi);
	41	return -1;
	42	}
	43	if (!leni)
	44	break;
	45	ofs = 0;
	46	do {
	47	leno = write(fdo, buf+ofs, leni);
	48	if (leno < 0)
	49	goto error_return;
	50	leni -= leno;
	51	ofs += leno;
	52	} while (0 < leni);
	53	}
	54	close(fdo);
	55	close(fdi);
	56	return 0;
	57	}
	58
	59	static void copy_templates_1(char *path, int baselen,
	60	char *template, int template_baselen,
	61	DIR *dir)
	62	{
	63	struct dirent *de;
	64
	65	/* Note: if ".git/hooks" file exists in the repository being
	66	* re-initialized, /etc/core-git/templates/hooks/update would
	67	* cause git-init-db to fail here. I think this is sane but
	68	* it means that the set of templates we ship by default, along
	69	* with the way the namespace under .git/ is organized, should
	70	* be really carefully chosen.
	71	*/
	72	safe_create_dir(path);
	73	while ((de = readdir(dir)) != NULL) {
	74	struct stat st_git, st_template;
	75	int namelen;
	76	int exists = 0;
	77
	78	if (de->d_name[0] == '.')
	79	continue;
	80	namelen = strlen(de->d_name);
	81	if ((PATH_MAX <= baselen + namelen) \|\|
	82	(PATH_MAX <= template_baselen + namelen))
	83	die("insanely long template name %s", de->d_name);
	84	memcpy(path + baselen, de->d_name, namelen+1);
	85	memcpy(template + template_baselen, de->d_name, namelen+1);
86	if (lstat(path, &st_git)) {
87	if (errno != ENOENT)
88	die("cannot stat %s", path);
89	}
90	else
91	exists = 1;
92
93	if (lstat(template, &st_template))
94	die("cannot stat template %s", template);
95
96	if (S_ISDIR(st_template.st_mode)) {
97	DIR *subdir = opendir(template);
98	int baselen_sub = baselen + namelen;
99	int template_baselen_sub = template_baselen + namelen;
100	if (!subdir)
101	die("cannot opendir %s", template);
102	path[baselen_sub++] =
103	template[template_baselen_sub++] = '/';
104	path[baselen_sub] =
105	template[template_baselen_sub] = 0;
106	copy_templates_1(path, baselen_sub,
107	template, template_baselen_sub,
108	subdir);
109	closedir(subdir);
110	}
111	else if (exists)
112	continue;
113	else if (S_ISLNK(st_template.st_mode)) {
114	char lnk[256];
115	int len;
116	len = readlink(template, lnk, sizeof(lnk));
117	if (len < 0)
118	die("cannot readlink %s", template);
119	if (sizeof(lnk) <= len)
120	die("insanely long symlink %s", template);
121	lnk[len] = 0;
122	if (symlink(lnk, path))
123	die("cannot symlink %s %s", lnk, path);
124	}
125	else if (S_ISREG(st_template.st_mode)) {
126	if (copy_file(path, template, st_template.st_mode))
127	die("cannot copy %s to %s", template, path);
128	}
129	else
130	error("ignoring template %s", template);
131	}
132	}
133
d3af621b	134	static void copy_templates(const char git_dir, int len, char template_dir)
8d5afef0 JH	135	{
	136	char path[PATH_MAX];
	137	char template_path[PATH_MAX];
d3af621b	138	int template_len;
8d5afef0 JH	139	DIR *dir;
8d5afef0 JH	140
8d5afef0	141	if (!template_dir)
d3af621b	142	template_dir = DEFAULT_GIT_TEMPLATE_DIR;
8d5afef0 JH	143	strcpy(template_path, template_dir);
	144	template_len = strlen(template_path);
	145	if (template_path[template_len-1] != '/') {
	146	template_path[template_len++] = '/';
	147	template_path[template_len] = 0;
	148	}
8d5afef0	149	dir = opendir(template_path);
d3af621b JH	150	if (!dir) {
	151	fprintf(stderr, "warning: templates not found %s\n",
	152	template_dir);
8d5afef0	153	return;
d3af621b JH	154	}
	155
	156	memcpy(path, git_dir, len);
1f961c19	157	path[len] = 0;
8d5afef0 JH	158	copy_templates_1(path, len,
	159	template_path, template_len,
	160	dir);
	161	closedir(dir);
	162	}
	163
d3af621b JH	164	static void create_default_files(const char *git_dir,
d3af621b JH	165	char *template_path)
cad88fdf LT	166	{
	167	unsigned len = strlen(git_dir);
	168	static char path[PATH_MAX];
8098a178	169	unsigned char sha1[20];
cad88fdf LT	170
	171	if (len > sizeof(path)-50)
	172	die("insane git directory %s", git_dir);
	173	memcpy(path, git_dir, len);
	174
	175	if (len && path[len-1] != '/')
	176	path[len++] = '/';
	177
	178	/*
	179	* Create .git/refs/{heads,tags}
	180	*/
	181	strcpy(path + len, "refs");
	182	safe_create_dir(path);
	183	strcpy(path + len, "refs/heads");
	184	safe_create_dir(path);
	185	strcpy(path + len, "refs/tags");
	186	safe_create_dir(path);
	187
	188	/*
	189	* Create the default symlink from ".git/HEAD" to the "master"
8098a178	190	* branch, if it does not exist yet.
cad88fdf LT	191	*/
cad88fdf LT	192	strcpy(path + len, "HEAD");
8098a178 JH	193	if (read_ref(path, sha1) < 0) {
8098a178 JH	194	if (create_symref(path, "refs/heads/master") < 0)
cad88fdf	195	exit(1);
cad88fdf	196	}
8098a178	197	path[len] = 0;
d3af621b	198	copy_templates(path, len, template_path);
cad88fdf LT	199	}
cad88fdf LT	200
d3af621b JH	201	static const char init_db_usage[] =
	202	"git-init-db [--template=<template-directory>]";
	203
4696cb93 ZW	204	/*
	205	* If you want to, you can share the DB area with any number of branches.
	206	* That has advantages: you can save space by sharing all the SHA1 objects.
	207	* On the other hand, it might just make lookup slower and messier. You
	208	* be the judge. The default case is to have one DB per managed directory.
	209	*/
e83c5163 LT	210	int main(int argc, char **argv)
e83c5163 LT	211	{
cad88fdf	212	const char *git_dir;
d19938ab	213	const char *sha1_dir;
d3af621b	214	char path, template_dir = NULL;
19b2860c	215	int len, i;
e83c5163	216
d3af621b JH	217	for (i = 1; i < argc; i++, argv++) {
	218	char *arg = argv[1];
	219	if (arg[0] != '-')
	220	break;
	221	else if (!strncmp(arg, "--template=", 11))
	222	template_dir = arg+11;
	223	else
	224	die(init_db_usage);
	225	}
	226
cad88fdf LT	227	/*
	228	* Set up the default .git directory contents
	229	*/
a9ab586a	230	git_dir = getenv(GIT_DIR_ENVIRONMENT);
cad88fdf LT	231	if (!git_dir) {
cad88fdf LT	232	git_dir = DEFAULT_GIT_DIR_ENVIRONMENT;
addb315d	233	fprintf(stderr, "defaulting to local storage area\n");
e83c5163	234	}
cad88fdf	235	safe_create_dir(git_dir);
d3af621b	236	create_default_files(git_dir, template_dir);
cad88fdf LT	237
	238	/*
	239	* And set up the object store.
	240	*/
	241	sha1_dir = get_object_directory();
e83c5163	242	len = strlen(sha1_dir);
812666c8	243	path = xmalloc(len + 40);
e83c5163	244	memcpy(path, sha1_dir, len);
cb126d8d ZW	245
cb126d8d ZW	246	safe_create_dir(sha1_dir);
e83c5163 LT	247	for (i = 0; i < 256; i++) {
e83c5163 LT	248	sprintf(path+len, "/%02x", i);
cb126d8d	249	safe_create_dir(path);
e83c5163	250	}
f49fb35d LT	251	strcpy(path+len, "/pack");
f49fb35d LT	252	safe_create_dir(path);
d57306c7 JH	253	strcpy(path+len, "/info");
d57306c7 JH	254	safe_create_dir(path);
e83c5163 LT	255	return 0;
e83c5163 LT	256	}