1 files changed, 405 insertions, 167 deletions

diff --git a/src/repository.c b/src/repository.c
index 6f1f4349..bf19d070 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -18,15 +18,14 @@
 #include "config.h"
 #include "refs.h"
 
-#define GIT_OBJECTS_INFO_DIR GIT_OBJECTS_DIR "info/"
-#define GIT_OBJECTS_PACK_DIR GIT_OBJECTS_DIR "pack/"
-
 #define GIT_FILE_CONTENT_PREFIX "gitdir:"
 
 #define GIT_BRANCH_MASTER "master"
 
 #define GIT_REPO_VERSION 0
 
+#define GIT_TEMPLATE_DIR "/usr/share/git-core/templates"
+
 static void drop_odb(git_repository *repo)
 {
 	if (repo->_odb != NULL) {
@@ -238,16 +237,17 @@ static int read_gitfile(git_buf *path_out, const char *file_path)
 
 	git_buf_rtrim(&file);
 
-	if (file.size <= prefix_len ||
-		memcmp(file.ptr, GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
+	if (git_buf_len(&file) <= prefix_len ||
+		memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
 	{
 		giterr_set(GITERR_REPOSITORY, "The `.git` file at '%s' is malformed", file_path);
 		error = -1;
 	}
 	else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
-		const char *gitlink = ((const char *)file.ptr) + prefix_len;
+		const char *gitlink = git_buf_cstr(&file) + prefix_len;
 		while (*gitlink && git__isspace(*gitlink)) gitlink++;
-		error = git_path_prettify_dir(path_out, gitlink, path_out->ptr);
+		error = git_path_prettify_dir(
+			path_out, gitlink, git_buf_cstr(path_out));
 	}
 
 	git_buf_free(&file);
@@ -359,9 +359,11 @@ int git_repository_open_ext(
 	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT;
 	git_repository *repo;
 
-	*repo_ptr = NULL;
+	if (repo_ptr)
+		*repo_ptr = NULL;
 
-	if ((error = find_repo(&path, &parent, start_path, flags, ceiling_dirs)) < 0)
+	error = find_repo(&path, &parent, start_path, flags, ceiling_dirs);
+	if (error < 0 || !repo_ptr)
 		return error;
 
 	repo = repository_alloc();
@@ -632,19 +634,35 @@ static int check_repositoryformatversion(git_config *config)
 	return 0;
 }
 
-static int repo_init_createhead(const char *git_dir)
+static int repo_init_create_head(const char *git_dir, const char *ref_name)
 {
 	git_buf ref_path = GIT_BUF_INIT;
 	git_filebuf ref = GIT_FILEBUF_INIT;
+	const char *fmt;
 
 	if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 ||
-		git_filebuf_open(&ref, ref_path.ptr, 0) < 0 ||
-		git_filebuf_printf(&ref, "ref: refs/heads/master\n") < 0 ||
+		git_filebuf_open(&ref, ref_path.ptr, 0) < 0)
+		goto fail;
+
+	if (!ref_name)
+		ref_name = GIT_BRANCH_MASTER;
+
+	if (git__prefixcmp(ref_name, "refs/") == 0)
+		fmt = "ref: %s\n";
+	else
+		fmt = "ref: refs/heads/%s\n";
+
+	if (git_filebuf_printf(&ref, fmt, ref_name) < 0 ||
 		git_filebuf_commit(&ref, GIT_REFS_FILE_MODE) < 0)
-		return -1;
+		goto fail;
 
 	git_buf_free(&ref_path);
 	return 0;
+
+fail:
+	git_buf_free(&ref_path);
+	git_filebuf_cleanup(&ref);
+	return -1;
 }
 
 static bool is_chmod_supported(const char *file_path)
@@ -665,6 +683,7 @@ static bool is_chmod_supported(const char *file_path)
 		return false;
 
 	_is_supported = (st1.st_mode != st2.st_mode);
+
 	return _is_supported;
 }
 
@@ -686,19 +705,45 @@ cleanup:
 	return _is_insensitive;
 }
 
-static int repo_init_config(const char *git_dir, bool is_bare, bool is_reinit)
+static bool are_symlinks_supported(const char *wd_path)
+{
+	git_buf path = GIT_BUF_INIT;
+	int fd;
+	struct stat st;
+	static int _symlinks_supported = -1;
+
+	if (_symlinks_supported > -1)
+		return _symlinks_supported;
+
+	if ((fd = git_futils_mktmp(&path, wd_path)) < 0 ||
+		p_close(fd) < 0 ||
+		p_unlink(path.ptr) < 0 ||
+		p_symlink("testing", path.ptr) < 0 ||
+		p_lstat(path.ptr, &st) < 0)
+		_symlinks_supported = false;
+	else
+		_symlinks_supported = (S_ISLNK(st.st_mode) != 0);
+
+	(void)p_unlink(path.ptr);
+	git_buf_free(&path);
+
+	return _symlinks_supported;
+}
+
+static int repo_init_config(
+	const char *repo_dir,
+	const char *work_dir,
+	git_repository_init_options *opts)
 {
+	int error = 0;
 	git_buf cfg_path = GIT_BUF_INIT;
 	git_config *config = NULL;
 
-#define SET_REPO_CONFIG(type, name, val) {\
-	if (git_config_set_##type(config, name, val) < 0) { \
-		git_buf_free(&cfg_path); \
-		git_config_free(config); \
-		return -1; } \
-}
+#define SET_REPO_CONFIG(TYPE, NAME, VAL) do {\
+	if ((error = git_config_set_##TYPE(config, NAME, VAL)) < 0) \
+		goto cleanup; } while (0)
 
-	if (git_buf_joinpath(&cfg_path, git_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
+	if (git_buf_joinpath(&cfg_path, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
 		return -1;
 
 	if (git_config_open_ondisk(&config, git_buf_cstr(&cfg_path)) < 0) {
@@ -706,58 +751,61 @@ static int repo_init_config(const char *git_dir, bool is_bare, bool is_reinit)
 		return -1;
 	}
 
-	if (is_reinit && check_repositoryformatversion(config) < 0) {
-		git_buf_free(&cfg_path);
-		git_config_free(config);
-		return -1;
-	}
+	if ((opts->flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0 &&
+		(error = check_repositoryformatversion(config)) < 0)
+		goto cleanup;
 
-	SET_REPO_CONFIG(bool, "core.bare", is_bare);
-	SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION);
-	SET_REPO_CONFIG(bool, "core.filemode", is_chmod_supported(git_buf_cstr(&cfg_path)));
-	
-	if (!is_bare)
+	SET_REPO_CONFIG(
+		bool, "core.bare", (opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);
+	SET_REPO_CONFIG(
+		int32, "core.repositoryformatversion", GIT_REPO_VERSION);
+	SET_REPO_CONFIG(
+		bool, "core.filemode", is_chmod_supported(git_buf_cstr(&cfg_path)));
+
+	if (!(opts->flags & GIT_REPOSITORY_INIT_BARE)) {
 		SET_REPO_CONFIG(bool, "core.logallrefupdates", true);
 
-	if (!is_reinit && is_filesystem_case_insensitive(git_dir))
-		SET_REPO_CONFIG(bool, "core.ignorecase", true);
-	/* TODO: what other defaults? */
+		if (!are_symlinks_supported(work_dir))
+			SET_REPO_CONFIG(bool, "core.symlinks", false);
 
-	git_buf_free(&cfg_path);
-	git_config_free(config);
-	return 0;
-}
-
-#define GIT_HOOKS_DIR "hooks/"
-#define GIT_HOOKS_DIR_MODE 0755
+		if (!(opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD)) {
+			SET_REPO_CONFIG(string, "core.worktree", work_dir);
+		}
+		else if ((opts->flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0) {
+			if ((error = git_config_delete(config, "core.worktree")) < 0)
+				goto cleanup;
+		}
+	} else {
+		if (!are_symlinks_supported(repo_dir))
+			SET_REPO_CONFIG(bool, "core.symlinks", false);
+	}
 
-#define GIT_HOOKS_README_FILE GIT_HOOKS_DIR "README.sample"
-#define GIT_HOOKS_README_MODE 0755
-#define GIT_HOOKS_README_CONTENT \
-"#!/bin/sh\n"\
-"#\n"\
-"# Place appropriately named executable hook scripts into this directory\n"\
-"# to intercept various actions that git takes.  See `git help hooks` for\n"\
-"# more information.\n"
+	if (!(opts->flags & GIT_REPOSITORY_INIT__IS_REINIT) &&
+		is_filesystem_case_insensitive(repo_dir))
+		SET_REPO_CONFIG(bool, "core.ignorecase", true);
 
-#define GIT_INFO_DIR "info/"
-#define GIT_INFO_DIR_MODE 0755
+	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
+		SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
+		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
+	}
+	else if (opts->mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
+		SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
+		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
+	}
 
-#define GIT_INFO_EXCLUDE_FILE GIT_INFO_DIR "exclude"
-#define GIT_INFO_EXCLUDE_MODE 0644
-#define GIT_INFO_EXCLUDE_CONTENT \
-"# File patterns to ignore; see `git help ignore` for more information.\n"\
-"# Lines that start with '#' are comments.\n"
+cleanup:
+	git_buf_free(&cfg_path);
+	git_config_free(config);
 
-#define GIT_DESC_FILE "description"
-#define GIT_DESC_MODE 0644
-#define GIT_DESC_CONTENT "Unnamed repository; edit this file 'description' to name the repository.\n"
+	return error;
+}
 
 static int repo_write_template(
 	const char *git_dir,
 	bool allow_overwrite,
 	const char *file,
 	mode_t mode,
+	bool hidden,
 	const char *content)
 {
 	git_buf path = GIT_BUF_INIT;
@@ -781,6 +829,15 @@ static int repo_write_template(
 	else if (errno != EEXIST)
 		error = fd;
 
+#ifdef GIT_WIN32
+	if (!error && hidden) {
+		if (p_hide_directory__w32(path.ptr) < 0)
+			error = -1;
+	}
+#else
+	GIT_UNUSED(hidden);
+#endif
+
 	git_buf_free(&path);
 
 	if (error)
@@ -790,86 +847,316 @@ static int repo_write_template(
 	return error;
 }
 
-static int repo_init_structure(const char *git_dir, int is_bare)
+static int repo_write_gitlink(
+	const char *in_dir, const char *to_repo)
 {
-	int i;
-	struct { const char *dir; mode_t mode; } dirs[] = {
-		{ GIT_OBJECTS_INFO_DIR, GIT_OBJECT_DIR_MODE }, /* '/objects/info/' */
-		{ GIT_OBJECTS_PACK_DIR, GIT_OBJECT_DIR_MODE }, /* '/objects/pack/' */
-		{ GIT_REFS_HEADS_DIR, GIT_REFS_DIR_MODE },     /* '/refs/heads/' */
-		{ GIT_REFS_TAGS_DIR, GIT_REFS_DIR_MODE },      /* '/refs/tags/' */
-		{ GIT_HOOKS_DIR, GIT_HOOKS_DIR_MODE },         /* '/hooks/' */
-		{ GIT_INFO_DIR, GIT_INFO_DIR_MODE },           /* '/info/' */
-		{ NULL, 0 }
-	};
-	struct { const char *file; mode_t mode; const char *content; } tmpl[] = {
-		{ GIT_DESC_FILE, GIT_DESC_MODE, GIT_DESC_CONTENT },
-		{ GIT_HOOKS_README_FILE, GIT_HOOKS_README_MODE, GIT_HOOKS_README_CONTENT },
-		{ GIT_INFO_EXCLUDE_FILE, GIT_INFO_EXCLUDE_MODE, GIT_INFO_EXCLUDE_CONTENT },
-		{ NULL, 0, NULL }
-	};
-
-	/* Make the base directory */
-	if (git_futils_mkdir_r(git_dir, NULL, is_bare ? GIT_BARE_DIR_MODE : GIT_DIR_MODE) < 0)
+	int error;
+	git_buf buf = GIT_BUF_INIT;
+	struct stat st;
+
+	git_path_dirname_r(&buf, to_repo);
+	git_path_to_dir(&buf);
+	if (git_buf_oom(&buf))
 		return -1;
 
-	/* Hides the ".git" directory */
-	if (!is_bare) {
+	/* don't write gitlink to natural workdir */
+	if (git__suffixcmp(to_repo, "/" DOT_GIT "/") == 0 &&
+		strcmp(in_dir, buf.ptr) == 0)
+	{
+		error = GIT_PASSTHROUGH;
+		goto cleanup;
+	}
+
+	if ((error = git_buf_joinpath(&buf, in_dir, DOT_GIT)) < 0)
+		goto cleanup;
+
+	if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) {
+		giterr_set(GITERR_REPOSITORY,
+			"Cannot overwrite gitlink file into path '%s'", in_dir);
+		error = GIT_EEXISTS;
+		goto cleanup;
+	}
+
+	git_buf_clear(&buf);
+
+	error = git_buf_printf(&buf, "%s %s", GIT_FILE_CONTENT_PREFIX, to_repo);
+
+	if (!error)
+		error = repo_write_template(in_dir, true, DOT_GIT, 0644, true, buf.ptr);
+
+cleanup:
+	git_buf_free(&buf);
+	return error;
+}
+
+static mode_t pick_dir_mode(git_repository_init_options *opts)
+{
+	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_UMASK)
+		return 0755;
+	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_GROUP)
+		return (0775 | S_ISGID);
+	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_ALL)
+		return (0777 | S_ISGID);
+	return opts->mode;
+}
+
+#include "repo_template.h"
+
+static int repo_init_structure(
+	const char *repo_dir,
+	const char *work_dir,
+	git_repository_init_options *opts)
+{
+	int error = 0;
+	repo_template_item *tpl;
+	bool external_tpl =
+		((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
+	mode_t dmode = pick_dir_mode(opts);
+
+	/* Hide the ".git" directory */
+	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0) {
 #ifdef GIT_WIN32
-		if (p_hide_directory__w32(git_dir) < 0) {
+		if (p_hide_directory__w32(repo_dir) < 0) {
 			giterr_set(GITERR_REPOSITORY,
 				"Failed to mark Git repository folder as hidden");
 			return -1;
 		}
 #endif
 	}
-
-	/* Make subdirectories as needed */
-	for (i = 0; dirs[i].dir != NULL; ++i) {
-		if (git_futils_mkdir_r(dirs[i].dir, git_dir, dirs[i].mode) < 0)
+	/* Create .git gitlink if appropriate */
+	else if ((opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0) {
+		if (repo_write_gitlink(work_dir, repo_dir) < 0)
 			return -1;
 	}
 
-	/* Make template files as needed */
-	for (i = 0; tmpl[i].file != NULL; ++i) {
-		if (repo_write_template(
-				git_dir, false, tmpl[i].file, tmpl[i].mode, tmpl[i].content) < 0)
+	/* Copy external template if requested */
+	if (external_tpl) {
+		git_config *cfg;
+		const char *tdir;
+
+		if (opts->template_path)
+			tdir = opts->template_path;
+		else if ((error = git_config_open_default(&cfg)) < 0)
+			return error;
+		else {
+			error = git_config_get_string(&tdir, cfg, "init.templatedir");
+
+			git_config_free(cfg);
+
+			if (error && error != GIT_ENOTFOUND)
+				return error;
+
+			giterr_clear();
+			tdir = GIT_TEMPLATE_DIR;
+		}
+
+		error = git_futils_cp_r(tdir, repo_dir,
+			GIT_CPDIR_COPY_SYMLINKS | GIT_CPDIR_CHMOD, dmode);
+
+		if (error < 0) {
+			if (strcmp(tdir, GIT_TEMPLATE_DIR) != 0)
+				return error;
+
+			/* if template was default, ignore error and use internal */
+			giterr_clear();
+			external_tpl = false;
+		}
+	}
+
+	/* Copy internal template
+	 * - always ensure existence of dirs
+	 * - only create files if no external template was specified
+	 */
+	for (tpl = repo_template; !error && tpl->path; ++tpl) {
+		if (!tpl->content)
+			error = git_futils_mkdir(
+				tpl->path, repo_dir, dmode, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD);
+		else if (!external_tpl) {
+			const char *content = tpl->content;
+
+			if (opts->description && strcmp(tpl->path, GIT_DESC_FILE) == 0)
+				content = opts->description;
+
+			error = repo_write_template(
+				repo_dir, false, tpl->path, tpl->mode, false, content);
+		}
+	}
+
+	return error;
+}
+
+static int repo_init_directories(
+	git_buf *repo_path,
+	git_buf *wd_path,
+	const char *given_repo,
+	git_repository_init_options *opts)
+{
+	int error = 0;
+	bool add_dotgit, has_dotgit, natural_wd;
+	mode_t dirmode;
+
+	/* set up repo path */
+
+	add_dotgit =
+		(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
+		(opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
+		git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
+		git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
+
+	if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
+		return -1;
+
+	has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
+	if (has_dotgit)
+		opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;
+
+	/* set up workdir path */
+
+	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0) {
+		if (opts->workdir_path) {
+			if (git_path_join_unrooted(
+					wd_path, opts->workdir_path, repo_path->ptr, NULL) < 0)
+				return -1;
+		} else if (has_dotgit) {
+			if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
+				return -1;
+		} else {
+			giterr_set(GITERR_REPOSITORY, "Cannot pick working directory"
+				" for non-bare repository that isn't a '.git' directory");
+			return -1;
+		}
+
+		if (git_path_to_dir(wd_path) < 0)
 			return -1;
+	} else {
+		git_buf_clear(wd_path);
 	}
 
-	return 0;
+	natural_wd =
+		has_dotgit &&
+		wd_path->size > 0 &&
+		wd_path->size + strlen(GIT_DIR) == repo_path->size &&
+		memcmp(repo_path->ptr, wd_path->ptr, wd_path->size) == 0;
+	if (natural_wd)
+		opts->flags |= GIT_REPOSITORY_INIT__NATURAL_WD;
+
+	/* create directories as needed / requested */
+
+	dirmode = pick_dir_mode(opts);
+
+	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 && has_dotgit) {
+		git_buf p = GIT_BUF_INIT;
+		if ((error = git_path_dirname_r(&p, repo_path->ptr)) >= 0)
+			error = git_futils_mkdir(p.ptr, NULL, dirmode, 0);
+		git_buf_free(&p);
+	}
+
+	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
+		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0 ||
+		has_dotgit)
+	{
+		uint32_t mkflag = GIT_MKDIR_CHMOD;
+		if ((opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0)
+			mkflag |= GIT_MKDIR_PATH;
+		error = git_futils_mkdir(repo_path->ptr, NULL, dirmode, mkflag);
+	}
+
+	if (wd_path->size > 0 &&
+		!natural_wd &&
+		((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
+		 (opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0))
+		error = git_futils_mkdir(wd_path->ptr, NULL, dirmode & ~S_ISGID,
+			(opts->flags & GIT_REPOSITORY_INIT_MKPATH) ? GIT_MKDIR_PATH : 0);
+
+	/* prettify both directories now that they are created */
+
+	if (!error) {
+		error = git_path_prettify_dir(repo_path, repo_path->ptr, NULL);
+
+		if (!error && wd_path->size > 0)
+			error = git_path_prettify_dir(wd_path, wd_path->ptr, NULL);
+	}
+
+	return error;
 }
 
-int git_repository_init(git_repository **repo_out, const char *path, unsigned is_bare)
+static int repo_init_create_origin(git_repository *repo, const char *url)
 {
-	git_buf repository_path = GIT_BUF_INIT;
-	bool is_reinit;
-	int result = -1;
+	int error;
+	git_remote *remote;
 
-	assert(repo_out && path);
+	if (!(error = git_remote_add(&remote, repo, "origin", url))) {
+		error = git_remote_save(remote);
+		git_remote_free(remote);
+	}
 
-	if (git_buf_joinpath(&repository_path, path, is_bare ? "" : GIT_DIR) < 0)
-		goto cleanup;
+	return error;
+}
 
-	is_reinit = git_path_isdir(repository_path.ptr) && valid_repository_path(&repository_path);
+int git_repository_init(
+	git_repository **repo_out, const char *path, unsigned is_bare)
+{
+	git_repository_init_options opts;
 
-	if (is_reinit) {
-		/* TODO: reinitialize the templates */
+	memset(&opts, 0, sizeof(opts));
+	opts.flags = GIT_REPOSITORY_INIT_MKPATH; /* don't love this default */
+	if (is_bare)
+		opts.flags |= GIT_REPOSITORY_INIT_BARE;
 
-		if (repo_init_config(repository_path.ptr, is_bare, is_reinit) < 0)
-			goto cleanup;
+	return git_repository_init_ext(repo_out, path, &opts);
+}
 
-	} else if (repo_init_structure(repository_path.ptr, is_bare) < 0 ||
-		repo_init_config(repository_path.ptr, is_bare, is_reinit) < 0 || 
-		repo_init_createhead(repository_path.ptr) < 0) {
+int git_repository_init_ext(
+	git_repository **repo_out,
+	const char *given_repo,
+	git_repository_init_options *opts)
+{
+	int error;
+	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT;
+
+	assert(repo_out && given_repo && opts);
+
+	error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
+	if (error < 0)
 		goto cleanup;
+
+	if (valid_repository_path(&repo_path)) {
+
+		if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
+			giterr_set(GITERR_REPOSITORY,
+				"Attempt to reinitialize '%s'", given_repo);
+			error = GIT_EEXISTS;
+			goto cleanup;
+		}
+
+		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;
+
+		error = repo_init_config(
+			git_buf_cstr(&repo_path), git_buf_cstr(&wd_path), opts);
+
+		/* TODO: reinitialize the templates */
+	}
+	else {
+		if (!(error = repo_init_structure(
+				git_buf_cstr(&repo_path), git_buf_cstr(&wd_path), opts)) &&
+			!(error = repo_init_config(
+				git_buf_cstr(&repo_path), git_buf_cstr(&wd_path), opts)))
+			error = repo_init_create_head(
+				git_buf_cstr(&repo_path), opts->initial_head);
 	}
+	if (error < 0)
+		goto cleanup;
+
+	error = git_repository_open(repo_out, git_buf_cstr(&repo_path));
 
-	result = git_repository_open(repo_out, repository_path.ptr);
+	if (!error && opts->origin_url)
+		error = repo_init_create_origin(*repo_out, opts->origin_url);
 
 cleanup:
-	git_buf_free(&repository_path);
-	return result;
+	git_buf_free(&repo_path);
+	git_buf_free(&wd_path);
+
+	return error;
 }
 
 int git_repository_head_detached(git_repository *repo)
@@ -965,43 +1252,6 @@ const char *git_repository_workdir(git_repository *repo)
 	return repo->workdir;
 }
 
-static int write_gitlink(
-	const char *in_dir, const char *to_repo)
-{
-	int error;
-	git_buf buf = GIT_BUF_INIT;
-	struct stat st;
-
-	if (git_path_dirname_r(&buf, to_repo) < 0 ||
-		git_path_to_dir(&buf) < 0)
-		return -1;
-
-	/* don't write gitlink to natural workdir */
-	if (git__suffixcmp(to_repo, "/" DOT_GIT "/") == 0 &&
-		strcmp(in_dir, buf.ptr) == 0)
-		return GIT_PASSTHROUGH;
-
-	if (git_buf_joinpath(&buf, in_dir, DOT_GIT) < 0)
-		return -1;
-
-	if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) {
-		giterr_set(GITERR_REPOSITORY,
-			"Cannot overwrite gitlink file into path '%s'", in_dir);
-		return GIT_EEXISTS;
-	}
-
-	git_buf_clear(&buf);
-
-	if (git_buf_printf(&buf, "%s %s", GIT_FILE_CONTENT_PREFIX, to_repo) < 0)
-		return -1;
-
-	error = repo_write_template(in_dir, true, DOT_GIT, 0644, buf.ptr);
-
-	git_buf_free(&buf);
-
-	return error;
-}
-
 int git_repository_set_workdir(
 	git_repository *repo, const char *workdir, int update_gitlink)
 {
@@ -1022,7 +1272,7 @@ int git_repository_set_workdir(
 		if (git_repository_config__weakptr(&config, repo) < 0)
 			return -1;
 
-		error = write_gitlink(path.ptr, git_repository_path(repo));
+		error = repo_write_gitlink(path.ptr, git_repository_path(repo));
 
 		/* passthrough error means gitlink is unnecessary */
 		if (error == GIT_PASSTHROUGH)
@@ -1078,39 +1328,27 @@ int git_repository_message(char *buffer, size_t len, git_repository *repo)
 {
 	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
 	struct stat st;
-	ssize_t size;
 	int error;
 
 	if (git_buf_joinpath(&path, repo->path_repository, MERGE_MSG_FILE) < 0)
 		return -1;
 
-	error = p_stat(git_buf_cstr(&path), &st);
-	if (error < 0) {
+	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
 		if (errno == ENOENT)
 			error = GIT_ENOTFOUND;
-
-		git_buf_free(&path);
-		return error;
 	}
-
-	if (buffer == NULL) {
-		git_buf_free(&path);
-		return (int)st.st_size;
+	else if (buffer != NULL) {
+		error = git_futils_readbuffer(&buf, git_buf_cstr(&path));
+		git_buf_copy_cstr(buffer, len, &buf);
 	}
 
-	if (git_futils_readbuffer(&buf, git_buf_cstr(&path)) < 0)
-		goto on_error;
-
-	memcpy(buffer, git_buf_cstr(&buf), len);
-	size = git_buf_len(&buf);
-
 	git_buf_free(&path);
 	git_buf_free(&buf);
-	return size;
 
-on_error:
-	git_buf_free(&path);
-	return -1;
+	if (!error)
+		error = (int)st.st_size + 1; /* add 1 for NUL byte */
+
+	return error;
 }
 
 int git_repository_message_remove(git_repository *repo)