repository.c 69.8 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6
 */
7 8 9

#include "repository.h"

10
#include <ctype.h>
11

12
#include "git2/object.h"
13
#include "git2/sys/repository.h"
14

15 16 17
#include "common.h"
#include "commit.h"
#include "tag.h"
18
#include "blob.h"
19
#include "fileops.h"
20
#include "sysdir.h"
21 22
#include "filebuf.h"
#include "index.h"
23
#include "config.h"
24
#include "refs.h"
25 26
#include "filter.h"
#include "odb.h"
27
#include "refdb.h"
28
#include "remote.h"
Edward Thomson committed
29
#include "merge.h"
30
#include "diff_driver.h"
31
#include "annotated_commit.h"
32
#include "submodule.h"
33
#include "worktree.h"
34 35

#include "strmap.h"
36

37 38 39 40
#ifdef GIT_WIN32
# include "win32/w32_util.h"
#endif

41 42
bool git_repository__fsync_gitdir = false;

43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
static const struct {
    git_repository_item_t parent;
    const char *name;
    bool directory;
} items[] = {
	{ GIT_REPOSITORY_ITEM_GITDIR, NULL, true },
	{ GIT_REPOSITORY_ITEM_WORKDIR, NULL, true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, NULL, true },
	{ GIT_REPOSITORY_ITEM_GITDIR, "index", false },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "objects", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "refs", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "packed-refs", false },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "remotes", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "config", false },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "info", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "hooks", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "logs", true },
	{ GIT_REPOSITORY_ITEM_GITDIR, "modules", true },
	{ GIT_REPOSITORY_ITEM_COMMONDIR, "worktrees", true }
};

64 65
static int check_repositoryformatversion(git_config *config);

66
#define GIT_COMMONDIR_FILE "commondir"
67
#define GIT_GITDIR_FILE "gitdir"
68

69
#define GIT_FILE_CONTENT_PREFIX "gitdir:"
70

71 72
#define GIT_BRANCH_MASTER "master"

73
#define GIT_REPO_VERSION 0
74

75 76 77 78 79 80 81 82 83 84
git_buf git_repository__reserved_names_win32[] = {
	{ DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },
	{ GIT_DIR_SHORTNAME, 0, CONST_STRLEN(GIT_DIR_SHORTNAME) }
};
size_t git_repository__reserved_names_win32_len = 2;

git_buf git_repository__reserved_names_posix[] = {
	{ DOT_GIT, 0, CONST_STRLEN(DOT_GIT) },
};
size_t git_repository__reserved_names_posix_len = 1;
85

86
static void set_odb(git_repository *repo, git_odb *odb)
87
{
88 89 90 91 92 93 94 95
	if (odb) {
		GIT_REFCOUNT_OWN(odb, repo);
		GIT_REFCOUNT_INC(odb);
	}

	if ((odb = git__swap(repo->_odb, odb)) != NULL) {
		GIT_REFCOUNT_OWN(odb, NULL);
		git_odb_free(odb);
96
	}
97
}
98

99
static void set_refdb(git_repository *repo, git_refdb *refdb)
100
{
101 102 103 104 105 106 107 108
	if (refdb) {
		GIT_REFCOUNT_OWN(refdb, repo);
		GIT_REFCOUNT_INC(refdb);
	}

	if ((refdb = git__swap(repo->_refdb, refdb)) != NULL) {
		GIT_REFCOUNT_OWN(refdb, NULL);
		git_refdb_free(refdb);
109 110 111
	}
}

112
static void set_config(git_repository *repo, git_config *config)
113
{
114 115 116 117 118 119 120 121
	if (config) {
		GIT_REFCOUNT_OWN(config, repo);
		GIT_REFCOUNT_INC(config);
	}

	if ((config = git__swap(repo->_config, config)) != NULL) {
		GIT_REFCOUNT_OWN(config, NULL);
		git_config_free(config);
122
	}
123 124

	git_repository__cvar_cache_clear(repo);
125 126
}

127
static void set_index(git_repository *repo, git_index *index)
128
{
129 130 131 132 133 134 135 136
	if (index) {
		GIT_REFCOUNT_OWN(index, repo);
		GIT_REFCOUNT_INC(index);
	}

	if ((index = git__swap(repo->_index, index)) != NULL) {
		GIT_REFCOUNT_OWN(index, NULL);
		git_index_free(index);
137
	}
138 139
}

140
void git_repository__cleanup(git_repository *repo)
141
{
142
	assert(repo);
143

144
	git_repository_submodule_cache_clear(repo);
145
	git_cache_clear(&repo->objects);
146
	git_attr_cache_flush(repo);
147

148 149 150 151
	set_config(repo, NULL);
	set_index(repo, NULL);
	set_odb(repo, NULL);
	set_refdb(repo, NULL);
152 153 154 155
}

void git_repository_free(git_repository *repo)
{
156 157
	size_t i;

158 159 160 161 162
	if (repo == NULL)
		return;

	git_repository__cleanup(repo);

163
	git_cache_dispose(&repo->objects);
164

165
	git_diff_driver_registry_free(repo->diff_drivers);
166
	repo->diff_drivers = NULL;
167

168
	for (i = 0; i < repo->reserved_names.size; i++)
169
		git_buf_dispose(git_array_get(repo->reserved_names, i));
Edward Thomson committed
170
	git_array_clear(repo->reserved_names);
171

172 173
	git__free(repo->gitlink);
	git__free(repo->gitdir);
174
	git__free(repo->commondir);
Russell Belfer committed
175
	git__free(repo->workdir);
Vicent Marti committed
176
	git__free(repo->namespace);
177 178
	git__free(repo->ident_name);
	git__free(repo->ident_email);
Russell Belfer committed
179

180
	git__memzero(repo, sizeof(*repo));
181
	git__free(repo);
182 183
}

184 185 186 187 188
/*
 * Git repository open methods
 *
 * Open a repository object from its path
 */
189
static bool valid_repository_path(git_buf *repository_path, git_buf *common_path)
190
{
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205
	/* Check if we have a separate commondir (e.g. we have a
	 * worktree) */
	if (git_path_contains_file(repository_path, GIT_COMMONDIR_FILE)) {
		git_buf common_link  = GIT_BUF_INIT;
		git_buf_joinpath(&common_link, repository_path->ptr, GIT_COMMONDIR_FILE);

		git_futils_readbuffer(&common_link, common_link.ptr);
		git_buf_rtrim(&common_link);

		if (git_path_is_relative(common_link.ptr)) {
			git_buf_joinpath(common_path, repository_path->ptr, common_link.ptr);
		} else {
			git_buf_swap(common_path, &common_link);
		}

206
		git_buf_dispose(&common_link);
207 208 209 210 211 212 213 214
	}
	else {
		git_buf_set(common_path, repository_path->ptr, repository_path->size);
	}

	/* Make sure the commondir path always has a trailing * slash */
	if (git_buf_rfind(common_path, '/') != (ssize_t)common_path->size - 1)
		git_buf_putc(common_path, '/');
215

216
	/* Ensure HEAD file exists */
217
	if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)
218
		return false;
219

220 221 222 223
	/* Check files in common dir */
	if (git_path_contains_dir(common_path, GIT_OBJECTS_DIR) == false)
		return false;
	if (git_path_contains_dir(common_path, GIT_REFS_DIR) == false)
224
		return false;
225

226
	return true;
227 228
}

229
static git_repository *repository_alloc(void)
230
{
231
	git_repository *repo = git__calloc(1, sizeof(git_repository));
232

233 234 235 236 237 238 239
	if (repo == NULL ||
		git_cache_init(&repo->objects) < 0)
		goto on_error;

	git_array_init_to_size(repo->reserved_names, 4);
	if (!repo->reserved_names.ptr)
		goto on_error;
240

241 242 243
	/* set all the entries in the cvar cache to `unset` */
	git_repository__cvar_cache_clear(repo);

244
	return repo;
245 246 247

on_error:
	if (repo)
248
		git_cache_dispose(&repo->objects);
249 250 251

	git__free(repo);
	return NULL;
252 253
}

254 255
int git_repository_new(git_repository **out)
{
256 257 258
	git_repository *repo;

	*out = repo = repository_alloc();
259
	GIT_ERROR_CHECK_ALLOC(repo);
260 261

	repo->is_bare = 1;
262
	repo->is_worktree = 0;
263

264 265 266
	return 0;
}

267
static int load_config_data(git_repository *repo, const git_config *config)
268
{
269
	int is_bare;
270

271 272 273 274
	int err = git_config_get_bool(&is_bare, config, "core.bare");
	if (err < 0 && err != GIT_ENOTFOUND)
		return err;

275
	/* Try to figure out if it's bare, default to non-bare if it's not set */
276 277
	if (err != GIT_ENOTFOUND)
		repo->is_bare = is_bare && !repo->is_worktree;
278
	else
279
		repo->is_bare = 0;
280

281
	return 0;
282
}
283

284
static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)
285
{
286
	int error;
287
	git_config_entry *ce;
288 289
	git_buf worktree = GIT_BUF_INIT;
	git_buf path = GIT_BUF_INIT;
290

291
	if (repo->is_bare)
292
		return 0;
293

294 295 296
	if ((error = git_config__lookup_entry(
			&ce, config, "core.worktree", false)) < 0)
		return error;
297

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
	if (repo->is_worktree) {
		char *gitlink = git_worktree__read_link(repo->gitdir, GIT_GITDIR_FILE);
		if (!gitlink) {
			error = -1;
			goto cleanup;
		}

		git_buf_attach(&worktree, gitlink, 0);

		if ((git_path_dirname_r(&worktree, worktree.ptr)) < 0 ||
		    git_path_to_dir(&worktree) < 0) {
			error = -1;
			goto cleanup;
		}

		repo->workdir = git_buf_detach(&worktree);
	}
	else if (ce && ce->value) {
316
		if ((error = git_path_prettify_dir(
317
				&worktree, ce->value, repo->gitdir)) < 0)
318
			goto cleanup;
319 320

		repo->workdir = git_buf_detach(&worktree);
321
	}
322 323
	else if (parent_path && git_path_isdir(parent_path->ptr))
		repo->workdir = git_buf_detach(parent_path);
324
	else {
325
		if (git_path_dirname_r(&worktree, repo->gitdir) < 0 ||
326 327 328 329
		    git_path_to_dir(&worktree) < 0) {
			error = -1;
			goto cleanup;
		}
330 331

		repo->workdir = git_buf_detach(&worktree);
332 333
	}

334
	GIT_ERROR_CHECK_ALLOC(repo->workdir);
335
cleanup:
336
	git_buf_dispose(&path);
337 338
	git_config_entry_free(ce);
	return error;
339 340
}

341 342 343 344 345 346 347 348
/*
 * This function returns furthest offset into path where a ceiling dir
 * is found, so we can stop processing the path at that point.
 *
 * Note: converting this to use git_bufs instead of GIT_PATH_MAX buffers on
 * the stack could remove directories name limits, but at the cost of doing
 * repeated malloc/frees inside the loop below, so let's not do it now.
 */
349
static size_t find_ceiling_dir_offset(
350 351 352 353 354 355
	const char *path,
	const char *ceiling_directories)
{
	char buf[GIT_PATH_MAX + 1];
	char buf2[GIT_PATH_MAX + 1];
	const char *ceil, *sep;
356
	size_t len, max_len = 0, min_len;
357 358 359

	assert(path);

360
	min_len = (size_t)(git_path_root(path) + 1);
361 362

	if (ceiling_directories == NULL || min_len == 0)
363
		return min_len;
364 365 366 367 368

	for (sep = ceil = ceiling_directories; *sep; ceil = sep + 1) {
		for (sep = ceil; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++);
		len = sep - ceil;

369
		if (len == 0 || len >= sizeof(buf) || git_path_root(ceil) == -1)
370 371 372 373 374 375 376 377 378 379 380 381 382
			continue;

		strncpy(buf, ceil, len);
		buf[len] = '\0';

		if (p_realpath(buf, buf2) == NULL)
			continue;

		len = strlen(buf2);
		if (len > 0 && buf2[len-1] == '/')
			buf[--len] = '\0';

		if (!strncmp(path, buf2, len) &&
383
			(path[len] == '/' || !path[len]) &&
384 385 386 387 388 389
			len > max_len)
		{
			max_len = len;
		}
	}

390
	return (max_len <= min_len ? min_len : max_len);
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409
}

/*
 * Read the contents of `file_path` and set `path_out` to the repo dir that
 * it points to.  Before calling, set `path_out` to the base directory that
 * should be used if the contents of `file_path` are a relative path.
 */
static int read_gitfile(git_buf *path_out, const char *file_path)
{
	int     error = 0;
	git_buf file = GIT_BUF_INIT;
	size_t  prefix_len = strlen(GIT_FILE_CONTENT_PREFIX);

	assert(path_out && file_path);

	if (git_futils_readbuffer(&file, file_path) < 0)
		return -1;

	git_buf_rtrim(&file);
410 411
	/* apparently on Windows, some people use backslashes in paths */
	git_path_mkposix(file.ptr);
412

413 414
	if (git_buf_len(&file) <= prefix_len ||
		memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
415
	{
416
		git_error_set(GIT_ERROR_REPOSITORY,
417
			"the `.git` file at '%s' is malformed", file_path);
418 419 420
		error = -1;
	}
	else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
421
		const char *gitlink = git_buf_cstr(&file) + prefix_len;
422
		while (*gitlink && git__isspace(*gitlink)) gitlink++;
423

424 425
		error = git_path_prettify_dir(
			path_out, gitlink, git_buf_cstr(path_out));
426 427
	}

428
	git_buf_dispose(&file);
429 430 431 432
	return error;
}

static int find_repo(
433 434 435 436
	git_buf *gitdir_path,
	git_buf *workdir_path,
	git_buf *gitlink_path,
	git_buf *commondir_path,
437 438 439
	const char *start_path,
	uint32_t flags,
	const char *ceiling_dirs)
440
{
441 442
	int error;
	git_buf path = GIT_BUF_INIT;
443
	git_buf repo_link = GIT_BUF_INIT;
444
	git_buf common_link = GIT_BUF_INIT;
445 446
	struct stat st;
	dev_t initial_device = 0;
447 448
	int min_iterations;
	bool in_dot_git;
449
	size_t ceiling_offset = 0;
450

451
	git_buf_clear(gitdir_path);
452

453 454
	error = git_path_prettify(&path, start_path, NULL);
	if (error < 0)
455 456
		return error;

457 458
	/* in_dot_git toggles each loop:
	 * /a/b/c/.git, /a/b/c, /a/b/.git, /a/b, /a/.git, /a
459 460 461
	 * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT, we
	 * assume we started with /a/b/c.git and don't append .git the first
	 * time through.
462 463
	 * min_iterations indicates the number of iterations left before going
	 * further counts as a search. */
464
	if (flags & (GIT_REPOSITORY_OPEN_BARE | GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
465 466 467 468 469 470
		in_dot_git = true;
		min_iterations = 1;
	} else {
		in_dot_git = false;
		min_iterations = 2;
	}
471

472
	for (;;) {
473
		if (!(flags & GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
474 475 476
			if (!in_dot_git) {
				error = git_buf_joinpath(&path, path.ptr, DOT_GIT);
				if (error < 0)
477
					break;
478
			}
479 480
			in_dot_git = !in_dot_git;
		}
481 482 483 484 485 486

		if (p_stat(path.ptr, &st) == 0) {
			/* check that we have not crossed device boundaries */
			if (initial_device == 0)
				initial_device = st.st_dev;
			else if (st.st_dev != initial_device &&
487
				 !(flags & GIT_REPOSITORY_OPEN_CROSS_FS))
488 489 490
				break;

			if (S_ISDIR(st.st_mode)) {
491
				if (valid_repository_path(&path, &common_link)) {
492
					git_path_to_dir(&path);
493
					git_buf_set(gitdir_path, path.ptr, path.size);
494

495 496
					if (gitlink_path)
						git_buf_attach(gitlink_path,
497
							git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0);
498 499
					if (commondir_path)
						git_buf_swap(&common_link, commondir_path);
500

501 502 503
					break;
				}
			}
504
			else if (S_ISREG(st.st_mode) && git__suffixcmp(path.ptr, "/" DOT_GIT) == 0) {
505 506
				error = read_gitfile(&repo_link, path.ptr);
				if (error < 0)
507
					break;
508
				if (valid_repository_path(&repo_link, &common_link)) {
509
					git_buf_swap(gitdir_path, &repo_link);
510

511 512 513 514
					if (gitlink_path)
						error = git_buf_put(gitlink_path, path.ptr, path.size);
					if (commondir_path)
						git_buf_swap(&common_link, commondir_path);
515
				}
516
				break;
517 518 519
			}
		}

520 521 522
		/* Move up one directory. If we're in_dot_git, we'll search the
		 * parent itself next. If we're !in_dot_git, we'll search .git
		 * in the parent directory next (added at the top of the loop). */
523 524 525 526 527
		if (git_path_dirname_r(&path, path.ptr) < 0) {
			error = -1;
			break;
		}

528 529 530 531
		/* Once we've checked the directory (and .git if applicable),
		 * find the ceiling for a search. */
		if (min_iterations && (--min_iterations == 0))
			ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);
532 533 534 535 536 537

		/* Check if we should stop searching here. */
		if (min_iterations == 0
		    && (path.ptr[ceiling_offset] == 0
			|| (flags & GIT_REPOSITORY_OPEN_NO_SEARCH)))
			break;
538 539
	}

540 541 542
	if (!error && workdir_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
		if (!git_buf_len(gitdir_path))
			git_buf_clear(workdir_path);
543
		else {
544 545
			git_path_dirname_r(workdir_path, path.ptr);
			git_path_to_dir(workdir_path);
546
		}
547
		if (git_buf_oom(workdir_path))
548 549 550
			return -1;
	}

551 552
	/* If we didn't find the repository, and we don't have any other error
	 * to report, report that. */
553
	if (!git_buf_len(gitdir_path) && !error) {
554
		git_error_set(GIT_ERROR_REPOSITORY,
555
			"could not find repository from '%s'", start_path);
556
		error = GIT_ENOTFOUND;
557
	}
558

559 560 561
	git_buf_dispose(&path);
	git_buf_dispose(&repo_link);
	git_buf_dispose(&common_link);
562 563 564
	return error;
}

565 566 567 568 569
int git_repository_open_bare(
	git_repository **repo_ptr,
	const char *bare_path)
{
	int error;
570
	git_buf path = GIT_BUF_INIT, common_path = GIT_BUF_INIT;
571 572 573 574 575
	git_repository *repo = NULL;

	if ((error = git_path_prettify_dir(&path, bare_path, NULL)) < 0)
		return error;

576
	if (!valid_repository_path(&path, &common_path)) {
577 578
		git_buf_dispose(&path);
		git_buf_dispose(&common_path);
579
		git_error_set(GIT_ERROR_REPOSITORY, "path is not a repository: %s", bare_path);
580 581 582 583
		return GIT_ENOTFOUND;
	}

	repo = repository_alloc();
584
	GIT_ERROR_CHECK_ALLOC(repo);
585

586
	repo->gitdir = git_buf_detach(&path);
587
	GIT_ERROR_CHECK_ALLOC(repo->gitdir);
588
	repo->commondir = git_buf_detach(&common_path);
589
	GIT_ERROR_CHECK_ALLOC(repo->commondir);
590 591 592

	/* of course we're bare! */
	repo->is_bare = 1;
593
	repo->is_worktree = 0;
594 595 596 597 598 599
	repo->workdir = NULL;

	*repo_ptr = repo;
	return 0;
}

600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
static int _git_repository_open_ext_from_env(
	git_repository **out,
	const char *start_path)
{
	git_repository *repo = NULL;
	git_index *index = NULL;
	git_odb *odb = NULL;
	git_buf dir_buf = GIT_BUF_INIT;
	git_buf ceiling_dirs_buf = GIT_BUF_INIT;
	git_buf across_fs_buf = GIT_BUF_INIT;
	git_buf index_file_buf = GIT_BUF_INIT;
	git_buf namespace_buf = GIT_BUF_INIT;
	git_buf object_dir_buf = GIT_BUF_INIT;
	git_buf alts_buf = GIT_BUF_INIT;
	git_buf work_tree_buf = GIT_BUF_INIT;
	git_buf common_dir_buf = GIT_BUF_INIT;
	const char *ceiling_dirs = NULL;
	unsigned flags = 0;
	int error;

	if (!start_path) {
		error = git__getenv(&dir_buf, "GIT_DIR");
		if (error == GIT_ENOTFOUND) {
623
			git_error_clear();
624 625 626 627 628 629 630 631 632 633 634 635
			start_path = ".";
		} else if (error < 0)
			goto error;
		else {
			start_path = git_buf_cstr(&dir_buf);
			flags |= GIT_REPOSITORY_OPEN_NO_SEARCH;
			flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT;
		}
	}

	error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES");
	if (error == GIT_ENOTFOUND)
636
		git_error_clear();
637 638 639 640 641 642 643
	else if (error < 0)
		goto error;
	else
		ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);

	error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM");
	if (error == GIT_ENOTFOUND)
644
		git_error_clear();
645 646 647 648 649 650 651 652 653 654 655 656 657
	else if (error < 0)
		goto error;
	else {
		int across_fs = 0;
		error = git_config_parse_bool(&across_fs, git_buf_cstr(&across_fs_buf));
		if (error < 0)
			goto error;
		if (across_fs)
			flags |= GIT_REPOSITORY_OPEN_CROSS_FS;
	}

	error = git__getenv(&index_file_buf, "GIT_INDEX_FILE");
	if (error == GIT_ENOTFOUND)
658
		git_error_clear();
659 660 661 662 663 664 665 666 667 668
	else if (error < 0)
		goto error;
	else {
		error = git_index_open(&index, git_buf_cstr(&index_file_buf));
		if (error < 0)
			goto error;
	}

	error = git__getenv(&namespace_buf, "GIT_NAMESPACE");
	if (error == GIT_ENOTFOUND)
669
		git_error_clear();
670 671 672 673 674
	else if (error < 0)
		goto error;

	error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");
	if (error == GIT_ENOTFOUND)
675
		git_error_clear();
676 677 678 679 680 681 682 683 684 685
	else if (error < 0)
		goto error;
	else {
		error = git_odb_open(&odb, git_buf_cstr(&object_dir_buf));
		if (error < 0)
			goto error;
	}

	error = git__getenv(&work_tree_buf, "GIT_WORK_TREE");
	if (error == GIT_ENOTFOUND)
686
		git_error_clear();
687 688 689
	else if (error < 0)
		goto error;
	else {
690
		git_error_set(GIT_ERROR_INVALID, "GIT_WORK_TREE unimplemented");
691 692 693 694 695 696
		error = GIT_ERROR;
		goto error;
	}

	error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");
	if (error == GIT_ENOTFOUND)
697
		git_error_clear();
698 699 700
	else if (error < 0)
		goto error;
	else {
701
		git_error_set(GIT_ERROR_INVALID, "GIT_COMMON_DIR unimplemented");
702 703 704 705 706 707 708 709 710 711 712 713
		error = GIT_ERROR;
		goto error;
	}

	error = git_repository_open_ext(&repo, start_path, flags, ceiling_dirs);
	if (error < 0)
		goto error;

	if (odb)
		git_repository_set_odb(repo, odb);

	error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES");
714
	if (error == GIT_ENOTFOUND) {
715
		git_error_clear();
716 717
		error = 0;
	} else if (error < 0)
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
		goto error;
        else {
		const char *end;
		char *alt, *sep;
		if (!odb) {
			error = git_repository_odb(&odb, repo);
			if (error < 0)
				goto error;
		}

		end = git_buf_cstr(&alts_buf) + git_buf_len(&alts_buf);
		for (sep = alt = alts_buf.ptr; sep != end; alt = sep+1) {
			for (sep = alt; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++)
				;
			if (*sep)
				*sep = '\0';
			error = git_odb_add_disk_alternate(odb, alt);
			if (error < 0)
				goto error;
		}
	}

740 741 742 743 744
	if (git_buf_len(&namespace_buf)) {
		error = git_repository_set_namespace(repo, git_buf_cstr(&namespace_buf));
		if (error < 0)
			goto error;
	}
745 746 747 748 749 750 751 752 753 754 755 756

	git_repository_set_index(repo, index);

	if (out) {
		*out = repo;
		goto success;
	}
error:
	git_repository_free(repo);
success:
	git_odb_free(odb);
	git_index_free(index);
757 758 759 760 761 762 763 764 765
	git_buf_dispose(&common_dir_buf);
	git_buf_dispose(&work_tree_buf);
	git_buf_dispose(&alts_buf);
	git_buf_dispose(&object_dir_buf);
	git_buf_dispose(&namespace_buf);
	git_buf_dispose(&index_file_buf);
	git_buf_dispose(&across_fs_buf);
	git_buf_dispose(&ceiling_dirs_buf);
	git_buf_dispose(&dir_buf);
766 767 768
	return error;
}

769 770 771 772 773
static int repo_is_worktree(unsigned *out, const git_repository *repo)
{
	git_buf gitdir_link = GIT_BUF_INIT;
	int error;

774 775 776 777 778 779 780
	/* Worktrees cannot have the same commondir and gitdir */
	if (repo->commondir && repo->gitdir
	    && !strcmp(repo->commondir, repo->gitdir)) {
		*out = 0;
		return 0;
	}

781 782 783 784 785 786 787
	if ((error = git_buf_joinpath(&gitdir_link, repo->gitdir, "gitdir")) < 0)
		return -1;

	/* A 'gitdir' file inside a git directory is currently
	 * only used when the repository is a working tree. */
	*out = !!git_path_exists(gitdir_link.ptr);

788
	git_buf_dispose(&gitdir_link);
789 790 791
	return error;
}

792 793 794
int git_repository_open_ext(
	git_repository **repo_ptr,
	const char *start_path,
795
	unsigned int flags,
796 797 798
	const char *ceiling_dirs)
{
	int error;
799
	unsigned is_worktree;
800 801
	git_buf gitdir = GIT_BUF_INIT, workdir = GIT_BUF_INIT,
		gitlink = GIT_BUF_INIT, commondir = GIT_BUF_INIT;
802
	git_repository *repo;
803
	git_config *config = NULL;
804

805 806 807
	if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)
		return _git_repository_open_ext_from_env(repo_ptr, start_path);

808 809
	if (repo_ptr)
		*repo_ptr = NULL;
810

811
	error = find_repo(
812
		&gitdir, &workdir, &gitlink, &commondir, start_path, flags, ceiling_dirs);
813

814
	if (error < 0 || !repo_ptr)
815 816
		return error;

817
	repo = repository_alloc();
818
	GIT_ERROR_CHECK_ALLOC(repo);
819

820
	repo->gitdir = git_buf_detach(&gitdir);
821
	GIT_ERROR_CHECK_ALLOC(repo->gitdir);
822

823 824
	if (gitlink.size) {
		repo->gitlink = git_buf_detach(&gitlink);
825
		GIT_ERROR_CHECK_ALLOC(repo->gitlink);
826
	}
827 828
	if (commondir.size) {
		repo->commondir = git_buf_detach(&commondir);
829
		GIT_ERROR_CHECK_ALLOC(repo->commondir);
830
	}
831

832
	if ((error = repo_is_worktree(&is_worktree, repo)) < 0)
833
		goto cleanup;
834
	repo->is_worktree = is_worktree;
835

836 837 838 839 840 841 842 843 844 845 846 847
	/*
	 * We'd like to have the config, but git doesn't particularly
	 * care if it's not there, so we need to deal with that.
	 */

	error = git_repository_config_snapshot(&config, repo);
	if (error < 0 && error != GIT_ENOTFOUND)
		goto cleanup;

	if (config && (error = check_repositoryformatversion(config)) < 0)
		goto cleanup;

848 849
	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
		repo->is_bare = 1;
850 851
	else {

852 853
		if (config &&
		    ((error = load_config_data(repo, config)) < 0 ||
854
		     (error = load_workdir(repo, config, &workdir)) < 0))
855
			goto cleanup;
856
	}
857

858
cleanup:
859 860
	git_buf_dispose(&gitdir);
	git_buf_dispose(&workdir);
861 862 863 864 865 866
	git_config_free(config);

	if (error < 0)
		git_repository_free(repo);
	else
		*repo_ptr = repo;
867 868

	return error;
869
}
870

871 872 873 874 875 876
int git_repository_open(git_repository **repo_out, const char *path)
{
	return git_repository_open_ext(
		repo_out, path, GIT_REPOSITORY_OPEN_NO_SEARCH, NULL);
}

877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *wt)
{
	git_buf path = GIT_BUF_INIT;
	git_repository *repo = NULL;
	int len, err;

	assert(repo_out && wt);

	*repo_out = NULL;
	len = strlen(wt->gitlink_path);

	if (len <= 4 || strcasecmp(wt->gitlink_path + len - 4, ".git")) {
		err = -1;
		goto out;
	}

	if ((err = git_buf_set(&path, wt->gitlink_path, len - 4)) < 0)
		goto out;

	if ((err = git_repository_open(&repo, path.ptr)) < 0)
		goto out;

	*repo_out = repo;

out:
902
	git_buf_dispose(&path);
903 904 905 906

	return err;
}

907 908 909 910 911
int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
{
	git_repository *repo;

	repo = repository_alloc();
912
	GIT_ERROR_CHECK_ALLOC(repo);
913 914 915 916 917 918 919

	git_repository_set_odb(repo, odb);
	*repo_out = repo;

	return 0;
}

920
int git_repository_discover(
921
	git_buf *out,
922 923 924 925 926 927
	const char *start_path,
	int across_fs,
	const char *ceiling_dirs)
{
	uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;

928
	assert(start_path);
929

930
	git_buf_sanitize(out);
931

932
	return find_repo(out, NULL, NULL, NULL, start_path, flags, ceiling_dirs);
933 934
}

935
static int load_config(
936 937 938
	git_config **out,
	git_repository *repo,
	const char *global_config_path,
Sven Strickroth committed
939
	const char *xdg_config_path,
940 941
	const char *system_config_path,
	const char *programdata_path)
942
{
943
	int error;
944
	git_buf config_path = GIT_BUF_INIT;
945
	git_config *cfg = NULL;
946

947
	assert(out);
948

949 950
	if ((error = git_config_new(&cfg)) < 0)
		return error;
951

952 953 954
	if (repo) {
		if ((error = git_repository_item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0)
			error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0);
955

956 957
		if (error && error != GIT_ENOTFOUND)
			goto on_error;
958

959 960
		git_buf_dispose(&config_path);
	}
961

962 963
	if (global_config_path != NULL &&
		(error = git_config_add_file_ondisk(
964
			cfg, global_config_path, GIT_CONFIG_LEVEL_GLOBAL, repo, 0)) < 0 &&
965 966
		error != GIT_ENOTFOUND)
		goto on_error;
967

968 969
	if (xdg_config_path != NULL &&
		(error = git_config_add_file_ondisk(
970
			cfg, xdg_config_path, GIT_CONFIG_LEVEL_XDG, repo, 0)) < 0 &&
971 972
		error != GIT_ENOTFOUND)
		goto on_error;
973

974 975
	if (system_config_path != NULL &&
		(error = git_config_add_file_ondisk(
976
			cfg, system_config_path, GIT_CONFIG_LEVEL_SYSTEM, repo, 0)) < 0 &&
977 978
		error != GIT_ENOTFOUND)
		goto on_error;
979

980 981
	if (programdata_path != NULL &&
		(error = git_config_add_file_ondisk(
982
			cfg, programdata_path, GIT_CONFIG_LEVEL_PROGRAMDATA, repo, 0)) < 0 &&
983 984 985
		error != GIT_ENOTFOUND)
		goto on_error;

986
	git_error_clear(); /* clear any lingering ENOTFOUND errors */
987

988
	*out = cfg;
989
	return 0;
990

991
on_error:
992
	git_buf_dispose(&config_path);
993 994
	git_config_free(cfg);
	*out = NULL;
995
	return error;
996 997
}

Russell Belfer committed
998
static const char *path_unless_empty(git_buf *buf)
999
{
Russell Belfer committed
1000 1001
	return git_buf_len(buf) > 0 ? git_buf_cstr(buf) : NULL;
}
1002

Russell Belfer committed
1003 1004 1005
int git_repository_config__weakptr(git_config **out, git_repository *repo)
{
	int error = 0;
1006

Russell Belfer committed
1007 1008 1009 1010
	if (repo->_config == NULL) {
		git_buf global_buf = GIT_BUF_INIT;
		git_buf xdg_buf = GIT_BUF_INIT;
		git_buf system_buf = GIT_BUF_INIT;
1011
		git_buf programdata_buf = GIT_BUF_INIT;
Russell Belfer committed
1012 1013
		git_config *config;

1014 1015 1016
		git_config_find_global(&global_buf);
		git_config_find_xdg(&xdg_buf);
		git_config_find_system(&system_buf);
1017
		git_config_find_programdata(&programdata_buf);
Russell Belfer committed
1018

1019 1020 1021 1022
		/* If there is no global file, open a backend for it anyway */
		if (git_buf_len(&global_buf) == 0)
			git_config__global_location(&global_buf);

Russell Belfer committed
1023 1024 1025 1026
		error = load_config(
			&config, repo,
			path_unless_empty(&global_buf),
			path_unless_empty(&xdg_buf),
1027 1028
			path_unless_empty(&system_buf),
			path_unless_empty(&programdata_buf));
Russell Belfer committed
1029 1030 1031
		if (!error) {
			GIT_REFCOUNT_OWN(config, repo);

1032
			config = git__compare_and_swap(&repo->_config, NULL, config);
Russell Belfer committed
1033 1034 1035 1036 1037
			if (config != NULL) {
				GIT_REFCOUNT_OWN(config, NULL);
				git_config_free(config);
			}
		}
1038

1039 1040 1041 1042
		git_buf_dispose(&global_buf);
		git_buf_dispose(&xdg_buf);
		git_buf_dispose(&system_buf);
		git_buf_dispose(&programdata_buf);
1043
	}
1044

1045
	*out = repo->_config;
Russell Belfer committed
1046
	return error;
1047 1048
}

1049
int git_repository_config(git_config **out, git_repository *repo)
1050
{
1051 1052
	if (git_repository_config__weakptr(out, repo) < 0)
		return -1;
1053

1054 1055
	GIT_REFCOUNT_INC(*out);
	return 0;
1056 1057
}

1058 1059
int git_repository_config_snapshot(git_config **out, git_repository *repo)
{
1060
	int error;
1061 1062
	git_config *weak;

1063 1064
	if ((error = git_repository_config__weakptr(&weak, repo)) < 0)
		return error;
1065 1066 1067 1068

	return git_config_snapshot(out, weak);
}

1069 1070 1071
void git_repository_set_config(git_repository *repo, git_config *config)
{
	assert(repo && config);
1072
	set_config(repo, config);
1073 1074 1075 1076
}

int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
{
Russell Belfer committed
1077 1078
	int error = 0;

1079 1080 1081
	assert(repo && out);

	if (repo->_odb == NULL) {
1082
		git_buf odb_path = GIT_BUF_INIT;
Russell Belfer committed
1083
		git_odb *odb;
1084

1085
		if ((error = git_repository_item_path(&odb_path, repo,
1086 1087
				GIT_REPOSITORY_ITEM_OBJECTS)) < 0 ||
			(error = git_odb_new(&odb)) < 0)
1088
			return error;
1089

1090
		GIT_REFCOUNT_OWN(odb, repo);
1091

1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
		if ((error = git_odb__set_caps(odb, GIT_ODB_CAP_FROM_OWNER)) < 0 ||
			(error = git_odb__add_default_backends(odb, odb_path.ptr, 0, 0)) < 0) {
			git_odb_free(odb);
			return error;
		}

		odb = git__compare_and_swap(&repo->_odb, NULL, odb);
		if (odb != NULL) {
			GIT_REFCOUNT_OWN(odb, NULL);
			git_odb_free(odb);
Russell Belfer committed
1102
		}
1103

1104
		git_buf_dispose(&odb_path);
1105
	}
1106

1107
	*out = repo->_odb;
Russell Belfer committed
1108
	return error;
1109 1110
}

1111
int git_repository_odb(git_odb **out, git_repository *repo)
1112
{
1113 1114
	if (git_repository_odb__weakptr(out, repo) < 0)
		return -1;
Vicent Marti committed
1115

1116 1117
	GIT_REFCOUNT_INC(*out);
	return 0;
1118
}
1119

1120 1121 1122
void git_repository_set_odb(git_repository *repo, git_odb *odb)
{
	assert(repo && odb);
1123
	set_odb(repo, odb);
1124 1125
}

1126 1127
int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo)
{
Russell Belfer committed
1128 1129
	int error = 0;

1130 1131 1132
	assert(out && repo);

	if (repo->_refdb == NULL) {
Russell Belfer committed
1133
		git_refdb *refdb;
1134

Russell Belfer committed
1135 1136 1137
		error = git_refdb_open(&refdb, repo);
		if (!error) {
			GIT_REFCOUNT_OWN(refdb, repo);
1138

1139
			refdb = git__compare_and_swap(&repo->_refdb, NULL, refdb);
Russell Belfer committed
1140 1141 1142 1143 1144
			if (refdb != NULL) {
				GIT_REFCOUNT_OWN(refdb, NULL);
				git_refdb_free(refdb);
			}
		}
1145 1146 1147
	}

	*out = repo->_refdb;
Russell Belfer committed
1148
	return error;
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
}

int git_repository_refdb(git_refdb **out, git_repository *repo)
{
	if (git_repository_refdb__weakptr(out, repo) < 0)
		return -1;

	GIT_REFCOUNT_INC(*out);
	return 0;
}

void git_repository_set_refdb(git_repository *repo, git_refdb *refdb)
{
Russell Belfer committed
1162
	assert(repo && refdb);
1163
	set_refdb(repo, refdb);
1164 1165
}

1166 1167
int git_repository_index__weakptr(git_index **out, git_repository *repo)
{
Russell Belfer committed
1168 1169
	int error = 0;

1170 1171 1172
	assert(out && repo);

	if (repo->_index == NULL) {
1173
		git_buf index_path = GIT_BUF_INIT;
Russell Belfer committed
1174
		git_index *index;
1175

1176
		if ((error = git_buf_joinpath(&index_path, repo->gitdir, GIT_INDEX_FILE)) < 0)
1177
			return error;
1178

Russell Belfer committed
1179 1180 1181
		error = git_index_open(&index, index_path.ptr);
		if (!error) {
			GIT_REFCOUNT_OWN(index, repo);
1182

1183
			index = git__compare_and_swap(&repo->_index, NULL, index);
Russell Belfer committed
1184 1185 1186 1187
			if (index != NULL) {
				GIT_REFCOUNT_OWN(index, NULL);
				git_index_free(index);
			}
1188

1189 1190
			error = git_index_set_caps(repo->_index,
			                           GIT_INDEX_CAPABILITY_FROM_OWNER);
Russell Belfer committed
1191
		}
1192

1193
		git_buf_dispose(&index_path);
1194 1195 1196
	}

	*out = repo->_index;
Russell Belfer committed
1197
	return error;
1198
}
Vicent Marti committed
1199

1200 1201
int git_repository_index(git_index **out, git_repository *repo)
{
1202 1203
	if (git_repository_index__weakptr(out, repo) < 0)
		return -1;
1204

1205 1206
	GIT_REFCOUNT_INC(*out);
	return 0;
1207 1208
}

1209 1210
void git_repository_set_index(git_repository *repo, git_index *index)
{
1211
	assert(repo);
1212
	set_index(repo, index);
1213 1214
}

Vicent Marti committed
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
int git_repository_set_namespace(git_repository *repo, const char *namespace)
{
	git__free(repo->namespace);

	if (namespace == NULL) {
		repo->namespace = NULL;
		return 0;
	}

	return (repo->namespace = git__strdup(namespace)) ? 0 : -1;
}

const char *git_repository_get_namespace(git_repository *repo)
{
	return repo->namespace;
}

1232 1233
#ifdef GIT_WIN32
static int reserved_names_add8dot3(git_repository *repo, const char *path)
1234
{
1235 1236
	char *name = git_win32_path_8dot3_name(path);
	const char *def = GIT_DIR_SHORTNAME;
1237
	const char *def_dot_git = DOT_GIT;
1238
	size_t name_len, def_len = CONST_STRLEN(GIT_DIR_SHORTNAME);
1239
	size_t def_dot_git_len = CONST_STRLEN(DOT_GIT);
1240
	git_buf *buf;
1241

1242 1243 1244 1245 1246
	if (!name)
		return 0;

	name_len = strlen(name);

1247
	if ((name_len == def_len && memcmp(name, def, def_len) == 0) ||
1248
		(name_len == def_dot_git_len && memcmp(name, def_dot_git, def_dot_git_len) == 0)) {
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
		git__free(name);
		return 0;
	}

	if ((buf = git_array_alloc(repo->reserved_names)) == NULL)
		return -1;

	git_buf_attach(buf, name, name_len);
	return true;
}

bool git_repository__reserved_names(
	git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs)
{
	GIT_UNUSED(include_ntfs);

	if (repo->reserved_names.size == 0) {
		git_buf *buf;
		size_t i;

		/* Add the static defaults */
		for (i = 0; i < git_repository__reserved_names_win32_len; i++) {
			if ((buf = git_array_alloc(repo->reserved_names)) == NULL)
				goto on_error;

			buf->ptr = git_repository__reserved_names_win32[i].ptr;
			buf->size = git_repository__reserved_names_win32[i].size;
		}

1278 1279 1280 1281 1282 1283
		/* Try to add any repo-specific reserved names - the gitlink file
		 * within a submodule or the repository (if the repository directory
		 * is beneath the workdir).  These are typically `.git`, but should
		 * be protected in case they are not.  Note, repo and workdir paths
		 * are always prettified to end in `/`, so a prefixcmp is safe.
		 */
1284
		if (!repo->is_bare) {
1285 1286
			int (*prefixcmp)(const char *, const char *);
			int error, ignorecase;
1287

1288 1289 1290 1291 1292
			error = git_repository__cvar(
				&ignorecase, repo, GIT_CVAR_IGNORECASE);
			prefixcmp = (error || ignorecase) ? git__prefixcmp_icase :
				git__prefixcmp;

1293 1294
			if (repo->gitlink &&
				reserved_names_add8dot3(repo, repo->gitlink) < 0)
1295 1296
				goto on_error;

1297 1298 1299
			if (repo->gitdir &&
				prefixcmp(repo->gitdir, repo->workdir) == 0 &&
				reserved_names_add8dot3(repo, repo->gitdir) < 0)
1300
				goto on_error;
1301 1302 1303
		}
	}

1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
	*out = repo->reserved_names.ptr;
	*outlen = repo->reserved_names.size;

	return true;

	/* Always give good defaults, even on OOM */
on_error:
	*out = git_repository__reserved_names_win32;
	*outlen = git_repository__reserved_names_win32_len;

	return false;
1315
}
1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332
#else
bool git_repository__reserved_names(
	git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs)
{
	GIT_UNUSED(repo);

	if (include_ntfs) {
		*out = git_repository__reserved_names_win32;
		*outlen = git_repository__reserved_names_win32_len;
	} else {
		*out = git_repository__reserved_names_posix;
		*outlen = git_repository__reserved_names_posix_len;
	}

	return true;
}
#endif
1333

1334
static int check_repositoryformatversion(git_config *config)
1335
{
1336
	int version, error;
1337

1338 1339 1340 1341 1342 1343
	error = git_config_get_int32(&version, config, "core.repositoryformatversion");
	/* git ignores this if the config variable isn't there */
	if (error == GIT_ENOTFOUND)
		return 0;

	if (error < 0)
1344
		return -1;
1345

1346
	if (GIT_REPO_VERSION < version) {
1347
		git_error_set(GIT_ERROR_REPOSITORY,
1348
			"unsupported repository version %d. Only versions up to %d are supported.",
1349
			version, GIT_REPO_VERSION);
1350 1351
		return -1;
	}
1352

1353
	return 0;
1354 1355
}

1356
int git_repository_create_head(const char *git_dir, const char *ref_name)
1357
{
1358
	git_buf ref_path = GIT_BUF_INIT;
1359
	git_filebuf ref = GIT_FILEBUF_INIT;
1360
	const char *fmt;
1361

1362
	if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 ||
1363
		git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE) < 0)
1364 1365 1366 1367 1368
		goto fail;

	if (!ref_name)
		ref_name = GIT_BRANCH_MASTER;

1369
	if (git__prefixcmp(ref_name, GIT_REFS_DIR) == 0)
1370 1371
		fmt = "ref: %s\n";
	else
1372
		fmt = "ref: " GIT_REFS_HEADS_DIR "%s\n";
1373 1374

	if (git_filebuf_printf(&ref, fmt, ref_name) < 0 ||
1375
		git_filebuf_commit(&ref) < 0)
1376
		goto fail;
1377

1378
	git_buf_dispose(&ref_path);
1379
	return 0;
1380 1381

fail:
1382
	git_buf_dispose(&ref_path);
1383 1384
	git_filebuf_cleanup(&ref);
	return -1;
1385 1386
}

1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
static bool is_chmod_supported(const char *file_path)
{
	struct stat st1, st2;

	if (p_stat(file_path, &st1) < 0)
		return false;

	if (p_chmod(file_path, st1.st_mode ^ S_IXUSR) < 0)
		return false;

	if (p_stat(file_path, &st2) < 0)
		return false;

1400
	return (st1.st_mode != st2.st_mode);
1401 1402
}

1403 1404 1405
static bool is_filesystem_case_insensitive(const char *gitdir_path)
{
	git_buf path = GIT_BUF_INIT;
1406
	int is_insensitive = -1;
1407

1408 1409
	if (!git_buf_joinpath(&path, gitdir_path, "CoNfIg"))
		is_insensitive = git_path_exists(git_buf_cstr(&path));
1410

1411
	git_buf_dispose(&path);
1412
	return is_insensitive;
1413 1414
}

1415 1416
static bool are_symlinks_supported(const char *wd_path)
{
1417
	git_config *config = NULL;
1418 1419 1420 1421
	git_buf global_buf = GIT_BUF_INIT;
	git_buf xdg_buf = GIT_BUF_INIT;
	git_buf system_buf = GIT_BUF_INIT;
	git_buf programdata_buf = GIT_BUF_INIT;
1422 1423 1424
	git_buf path = GIT_BUF_INIT;
	int fd;
	struct stat st;
1425
	int symlinks = 0;
1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449

	/*
	 * To emulate Git for Windows, symlinks on Windows must be explicitly
	 * opted-in.  We examine the system configuration for a core.symlinks
	 * set to true.  If found, we then examine the filesystem to see if
	 * symlinks are _actually_ supported by the current user.  If that is
	 * _not_ set, then we do not test or enable symlink support.
	 */
#ifdef GIT_WIN32
	git_config_find_global(&global_buf);
	git_config_find_xdg(&xdg_buf);
	git_config_find_system(&system_buf);
	git_config_find_programdata(&programdata_buf);

	if (load_config(&config, NULL,
	    path_unless_empty(&global_buf),
	    path_unless_empty(&xdg_buf),
	    path_unless_empty(&system_buf),
	    path_unless_empty(&programdata_buf)) < 0)
		goto done;

	if (git_config_get_bool(&symlinks, config, "core.symlinks") < 0 || !symlinks)
		goto done;
#endif
1450

1451
	if ((fd = git_futils_mktmp(&path, wd_path, 0666)) < 0 ||
1452 1453 1454 1455 1456 1457 1458
	    p_close(fd) < 0 ||
	    p_unlink(path.ptr) < 0 ||
	    p_symlink("testing", path.ptr) < 0 ||
	    p_lstat(path.ptr, &st) < 0)
		goto done;

	symlinks = (S_ISLNK(st.st_mode) != 0);
1459 1460 1461

	(void)p_unlink(path.ptr);

1462
done:
1463 1464 1465 1466
	git_buf_dispose(&global_buf);
	git_buf_dispose(&xdg_buf);
	git_buf_dispose(&system_buf);
	git_buf_dispose(&programdata_buf);
1467 1468
	git_buf_dispose(&path);
	git_config_free(config);
1469
	return symlinks != 0;
1470 1471
}

1472 1473 1474 1475 1476
static int create_empty_file(const char *path, mode_t mode)
{
	int fd;

	if ((fd = p_creat(path, mode)) < 0) {
1477
		git_error_set(GIT_ERROR_OS, "error while creating '%s'", path);
1478 1479 1480 1481
		return -1;
	}

	if (p_close(fd) < 0) {
1482
		git_error_set(GIT_ERROR_OS, "error while closing '%s'", path);
1483 1484 1485 1486 1487 1488
		return -1;
	}

	return 0;
}

1489 1490 1491 1492 1493
static int repo_local_config(
	git_config **out,
	git_buf *config_dir,
	git_repository *repo,
	const char *repo_dir)
1494
{
1495
	int error = 0;
1496 1497
	git_config *parent;
	const char *cfg_path;
1498

1499
	if (git_buf_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
1500
		return -1;
1501
	cfg_path = git_buf_cstr(config_dir);
1502

1503
	/* make LOCAL config if missing */
1504 1505
	if (!git_path_isfile(cfg_path) &&
		(error = create_empty_file(cfg_path, GIT_CONFIG_FILE_MODE)) < 0)
1506
		return error;
1507

1508 1509 1510 1511 1512 1513 1514 1515 1516
	/* if no repo, just open that file directly */
	if (!repo)
		return git_config_open_ondisk(out, cfg_path);

	/* otherwise, open parent config and get that level */
	if ((error = git_repository_config__weakptr(&parent, repo)) < 0)
		return error;

	if (git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL) < 0) {
1517
		git_error_clear();
1518 1519

		if (!(error = git_config_add_file_ondisk(
1520
				parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, repo, false)))
1521
			error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
1522
	}
1523

1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
	git_config_free(parent);

	return error;
}

static int repo_init_fs_configs(
	git_config *cfg,
	const char *cfg_path,
	const char *repo_dir,
	const char *work_dir,
	bool update_ignorecase)
{
	int error = 0;

	if (!work_dir)
		work_dir = repo_dir;

	if ((error = git_config_set_bool(
			cfg, "core.filemode", is_chmod_supported(cfg_path))) < 0)
		return error;

	if (!are_symlinks_supported(work_dir)) {
		if ((error = git_config_set_bool(cfg, "core.symlinks", false)) < 0)
			return error;
	} else if (git_config_delete_entry(cfg, "core.symlinks") < 0)
1549
		git_error_clear();
1550

1551 1552 1553 1554 1555
	if (update_ignorecase) {
		if (is_filesystem_case_insensitive(repo_dir)) {
			if ((error = git_config_set_bool(cfg, "core.ignorecase", true)) < 0)
				return error;
		} else if (git_config_delete_entry(cfg, "core.ignorecase") < 0)
1556
			git_error_clear();
1557
	}
1558

1559
#ifdef GIT_USE_ICONV
1560 1561
	if ((error = git_config_set_bool(
			cfg, "core.precomposeunicode",
1562
			git_path_does_fs_decompose_unicode(work_dir))) < 0)
1563
		return error;
1564
	/* on non-iconv platforms, don't even set core.precomposeunicode */
1565 1566
#endif

1567 1568
	return 0;
}
1569

1570 1571 1572 1573 1574 1575 1576
static int repo_init_config(
	const char *repo_dir,
	const char *work_dir,
	uint32_t flags,
	uint32_t mode)
{
	int error = 0;
1577
	git_buf cfg_path = GIT_BUF_INIT, worktree_path = GIT_BUF_INIT;
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597
	git_config *config = NULL;
	bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0);
	bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0);

	if ((error = repo_local_config(&config, &cfg_path, NULL, repo_dir)) < 0)
		goto cleanup;

	if (is_reinit && (error = check_repositoryformatversion(config)) < 0)
		goto cleanup;

#define SET_REPO_CONFIG(TYPE, NAME, VAL) do { \
	if ((error = git_config_set_##TYPE(config, NAME, VAL)) < 0) \
		goto cleanup; } while (0)

	SET_REPO_CONFIG(bool, "core.bare", is_bare);
	SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION);

	if ((error = repo_init_fs_configs(
			config, cfg_path.ptr, repo_dir, work_dir, !is_reinit)) < 0)
		goto cleanup;
1598

1599 1600
	if (!is_bare) {
		SET_REPO_CONFIG(bool, "core.logallrefupdates", true);
1601

1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
		if (!(flags & GIT_REPOSITORY_INIT__NATURAL_WD)) {
			if ((error = git_buf_sets(&worktree_path, work_dir)) < 0)
				goto cleanup;

			if ((flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK))
				if ((error = git_path_make_relative(&worktree_path, repo_dir)) < 0)
					goto cleanup;

			SET_REPO_CONFIG(string, "core.worktree", worktree_path.ptr);
		} else if (is_reinit) {
Ben Straub committed
1612
			if (git_config_delete_entry(config, "core.worktree") < 0)
1613
				git_error_clear();
1614 1615 1616
		}
	}

1617
	if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
1618 1619
		SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
1620
	}
1621
	else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
1622 1623 1624
		SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
	}
1625

1626
cleanup:
1627 1628
	git_buf_dispose(&cfg_path);
	git_buf_dispose(&worktree_path);
1629
	git_config_free(config);
1630

1631
	return error;
1632
}
1633

1634
static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
1635
{
1636 1637
	git_repository *smrepo = NULL;
	GIT_UNUSED(n); GIT_UNUSED(p);
1638

1639
	if (git_submodule_open(&smrepo, sm) < 0 ||
1640
		git_repository_reinit_filesystem(smrepo, true) < 0)
1641
		git_error_clear();
1642
	git_repository_free(smrepo);
1643

1644 1645
	return 0;
}
1646

1647
int git_repository_reinit_filesystem(git_repository *repo, int recurse)
1648 1649 1650 1651 1652
{
	int error = 0;
	git_buf path = GIT_BUF_INIT;
	git_config *config = NULL;
	const char *repo_dir = git_repository_path(repo);
1653

1654 1655 1656
	if (!(error = repo_local_config(&config, &path, repo, repo_dir)))
		error = repo_init_fs_configs(
			config, path.ptr, repo_dir, git_repository_workdir(repo), true);
1657

1658
	git_config_free(config);
1659
	git_buf_dispose(&path);
1660 1661 1662

	git_repository__cvar_cache_clear(repo);

1663
	if (!repo->is_bare && recurse)
1664
		(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
1665

1666 1667 1668
	return error;
}

1669
static int repo_write_template(
1670 1671 1672 1673
	const char *git_dir,
	bool allow_overwrite,
	const char *file,
	mode_t mode,
1674
	bool hidden,
1675
	const char *content)
1676 1677
{
	git_buf path = GIT_BUF_INIT;
1678
	int fd, error = 0, flags;
1679 1680 1681 1682

	if (git_buf_joinpath(&path, git_dir, file) < 0)
		return -1;

1683 1684 1685 1686 1687 1688
	if (allow_overwrite)
		flags = O_WRONLY | O_CREAT | O_TRUNC;
	else
		flags = O_WRONLY | O_CREAT | O_EXCL;

	fd = p_open(git_buf_cstr(&path), flags, mode);
1689

1690 1691
	if (fd >= 0) {
		error = p_write(fd, content, strlen(content));
1692

1693 1694 1695 1696
		p_close(fd);
	}
	else if (errno != EEXIST)
		error = fd;
1697

1698 1699
#ifdef GIT_WIN32
	if (!error && hidden) {
1700
		if (git_win32__set_hidden(path.ptr, true) < 0)
1701 1702 1703 1704 1705 1706
			error = -1;
	}
#else
	GIT_UNUSED(hidden);
#endif

1707
	git_buf_dispose(&path);
1708 1709

	if (error)
1710
		git_error_set(GIT_ERROR_OS,
1711
			"failed to initialize repository with template '%s'", file);
1712 1713

	return error;
1714 1715
}

1716
static int repo_write_gitlink(
1717
	const char *in_dir, const char *to_repo, bool use_relative_path)
1718
{
1719 1720
	int error;
	git_buf buf = GIT_BUF_INIT;
1721
	git_buf path_to_repo = GIT_BUF_INIT;
1722 1723 1724 1725 1726
	struct stat st;

	git_path_dirname_r(&buf, to_repo);
	git_path_to_dir(&buf);
	if (git_buf_oom(&buf))
1727
		return -1;
1728

1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
	/* 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)) {
1741
		git_error_set(GIT_ERROR_REPOSITORY,
1742
			"cannot overwrite gitlink file into path '%s'", in_dir);
1743 1744 1745 1746 1747 1748
		error = GIT_EEXISTS;
		goto cleanup;
	}

	git_buf_clear(&buf);

1749 1750 1751 1752 1753 1754 1755
	error = git_buf_sets(&path_to_repo, to_repo);

	if (!error && use_relative_path)
		error = git_path_make_relative(&path_to_repo, in_dir);

	if (!error)
		error = git_buf_join(&buf, ' ', GIT_FILE_CONTENT_PREFIX, path_to_repo.ptr);
1756 1757

	if (!error)
1758
		error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
1759 1760

cleanup:
1761 1762
	git_buf_dispose(&buf);
	git_buf_dispose(&path_to_repo);
1763 1764 1765
	return error;
}

1766 1767 1768
static mode_t pick_dir_mode(git_repository_init_options *opts)
{
	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_UMASK)
1769
		return 0777;
1770 1771 1772 1773 1774 1775 1776
	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;
}

1777 1778 1779 1780 1781 1782 1783
#include "repo_template.h"

static int repo_init_structure(
	const char *repo_dir,
	const char *work_dir,
	git_repository_init_options *opts)
{
1784
	int error = 0;
1785
	repo_template_item *tpl;
1786 1787 1788
	bool external_tpl =
		((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
	mode_t dmode = pick_dir_mode(opts);
1789
	bool chmod = opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK;
1790 1791

	/* Hide the ".git" directory */
1792
#ifdef GIT_WIN32
1793
	if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
1794
		if (git_win32__set_hidden(repo_dir, true) < 0) {
1795
			git_error_set(GIT_ERROR_OS,
1796
				"failed to mark Git repository folder as hidden");
1797 1798
			return -1;
		}
1799
	}
1800 1801 1802 1803 1804 1805
#endif

	/* Create the .git gitlink if appropriate */
	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
		(opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0)
	{
1806
		if (repo_write_gitlink(work_dir, repo_dir, opts->flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK) < 0)
1807
			return -1;
1808
	}
1809

1810 1811
	/* Copy external template if requested */
	if (external_tpl) {
Linquize committed
1812 1813 1814
		git_config *cfg = NULL;
		const char *tdir = NULL;
		bool default_template = false;
1815 1816
		git_buf template_buf = GIT_BUF_INIT;

1817 1818
		if (opts->template_path)
			tdir = opts->template_path;
Linquize committed
1819
		else if ((error = git_config_open_default(&cfg)) >= 0) {
1820 1821
			if (!git_config_get_path(&template_buf, cfg, "init.templatedir"))
				tdir = template_buf.ptr;
1822
			git_error_clear();
Linquize committed
1823 1824 1825
		}

		if (!tdir) {
1826
			if (!(error = git_sysdir_find_template_dir(&template_buf)))
1827
				tdir = template_buf.ptr;
Linquize committed
1828
			default_template = true;
1829
		}
1830

1831 1832 1833 1834 1835 1836 1837
		/*
		 * If tdir was the empty string, treat it like tdir was a path to an
		 * empty directory (so, don't do any copying). This is the behavior
		 * that git(1) exhibits, although it doesn't seem to be officially
		 * documented.
		 */
		if (tdir && git__strcmp(tdir, "") != 0) {
1838 1839 1840
			uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS |
				GIT_CPDIR_SIMPLE_TO_MODE |
				GIT_CPDIR_COPY_DOTFILES;
1841 1842 1843
			if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
					cpflags |= GIT_CPDIR_CHMOD_DIRS;
			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
1844
		}
1845

1846
		git_buf_dispose(&template_buf);
Linquize committed
1847
		git_config_free(cfg);
1848

1849
		if (error < 0) {
Linquize committed
1850
			if (!default_template)
1851 1852 1853
				return error;

			/* if template was default, ignore error and use internal */
1854
			git_error_clear();
1855
			external_tpl = false;
1856
			error = 0;
1857 1858 1859 1860 1861 1862 1863 1864
		}
	}

	/* 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) {
1865
		if (!tpl->content) {
1866 1867 1868 1869
			uint32_t mkdir_flags = GIT_MKDIR_PATH;
			if (chmod)
				mkdir_flags |= GIT_MKDIR_CHMOD;

1870 1871
			error = git_futils_mkdir_relative(
				tpl->path, repo_dir, dmode, mkdir_flags, NULL);
1872
		}
1873
		else if (!external_tpl) {
1874 1875 1876 1877 1878
			const char *content = tpl->content;

			if (opts->description && strcmp(tpl->path, GIT_DESC_FILE) == 0)
				content = opts->description;

1879 1880
			error = repo_write_template(
				repo_dir, false, tpl->path, tpl->mode, false, content);
1881
		}
1882 1883
	}

1884
	return error;
1885 1886
}

1887 1888
static int mkdir_parent(git_buf *buf, uint32_t mode, bool skip2)
{
1889 1890 1891
	/* When making parent directories during repository initialization
	 * don't try to set gid or grant world write access
	 */
1892
	return git_futils_mkdir(
1893
		buf->ptr, mode & ~(S_ISGID | 0002),
1894 1895 1896 1897
		GIT_MKDIR_PATH | GIT_MKDIR_VERIFY_DIR |
		(skip2 ? GIT_MKDIR_SKIP_LAST2 : GIT_MKDIR_SKIP_LAST));
}

1898 1899 1900 1901 1902
static int repo_init_directories(
	git_buf *repo_path,
	git_buf *wd_path,
	const char *given_repo,
	git_repository_init_options *opts)
1903
{
1904
	int error = 0;
1905
	bool is_bare, add_dotgit, has_dotgit, natural_wd;
1906
	mode_t dirmode;
1907

1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
	/* There are three possible rules for what we are allowed to create:
	 * - MKPATH means anything we need
	 * - MKDIR means just the .git directory and its parent and the workdir
	 * - Neither means only the .git directory can be created
	 *
	 * There are 5 "segments" of path that we might need to deal with:
	 * 1. The .git directory
	 * 2. The parent of the .git directory
	 * 3. Everything above the parent of the .git directory
	 * 4. The working directory (often the same as #2)
	 * 5. Everything above the working directory (often the same as #3)
	 *
	 * For all directories created, we start with the init_mode value for
	 * permissions and then strip off bits in some cases:
	 *
	 * For MKPATH, we create #3 (and #5) paths without S_ISGID or S_IWOTH
	 * For MKPATH and MKDIR, we create #2 (and #4) without S_ISGID
	 * For all rules, we create #1 using the untouched init_mode
	 */

1928
	/* set up repo path */
1929

1930 1931
	is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);

1932 1933
	add_dotgit =
		(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
1934
		!is_bare &&
1935 1936
		git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
		git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
1937

1938 1939
	if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
		return -1;
1940

1941 1942 1943 1944 1945 1946
	has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
	if (has_dotgit)
		opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;

	/* set up workdir path */

1947
	if (!is_bare) {
1948
		if (opts->workdir_path) {
1949 1950 1951
			if (git_path_join_unrooted(
					wd_path, opts->workdir_path, repo_path->ptr, NULL) < 0)
				return -1;
1952 1953 1954 1955
		} else if (has_dotgit) {
			if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
				return -1;
		} else {
1956
			git_error_set(GIT_ERROR_REPOSITORY, "cannot pick working directory"
1957 1958 1959
				" for non-bare repository that isn't a '.git' directory");
			return -1;
		}
1960

1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976
		if (git_path_to_dir(wd_path) < 0)
			return -1;
	} else {
		git_buf_clear(wd_path);
	}

	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 */

1977
	dirmode = pick_dir_mode(opts);
1978

1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996
	if ((opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0) {
		/* create path #5 */
		if (wd_path->size > 0 &&
			(error = mkdir_parent(wd_path, dirmode, false)) < 0)
			return error;

		/* create path #3 (if not the same as #5) */
		if (!natural_wd &&
			(error = mkdir_parent(repo_path, dirmode, has_dotgit)) < 0)
			return error;
	}

	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0)
	{
		/* create path #4 */
		if (wd_path->size > 0 &&
			(error = git_futils_mkdir(
1997
				wd_path->ptr, dirmode & ~S_ISGID,
1998 1999 2000 2001 2002 2003
				GIT_MKDIR_VERIFY_DIR)) < 0)
			return error;

		/* create path #2 (if not the same as #4) */
		if (!natural_wd &&
			(error = git_futils_mkdir(
2004
				repo_path->ptr, dirmode & ~S_ISGID,
2005 2006
				GIT_MKDIR_VERIFY_DIR | GIT_MKDIR_SKIP_LAST)) < 0)
			return error;
2007 2008
	}

2009 2010 2011 2012
	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0 ||
		has_dotgit)
	{
2013
		/* create path #1 */
2014
		error = git_futils_mkdir(repo_path->ptr, dirmode,
2015
			GIT_MKDIR_VERIFY_DIR | ((dirmode & S_ISGID) ? GIT_MKDIR_CHMOD : 0));
2016
	}
2017

2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
	/* 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;
}

static int repo_init_create_origin(git_repository *repo, const char *url)
{
	int error;
	git_remote *remote;

Ben Straub committed
2035
	if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
2036 2037 2038 2039 2040 2041 2042 2043 2044
		git_remote_free(remote);
	}

	return error;
}

int git_repository_init(
	git_repository **repo_out, const char *path, unsigned is_bare)
{
2045
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
2046 2047 2048 2049 2050 2051 2052 2053 2054

	opts.flags = GIT_REPOSITORY_INIT_MKPATH; /* don't love this default */
	if (is_bare)
		opts.flags |= GIT_REPOSITORY_INIT_BARE;

	return git_repository_init_ext(repo_out, path, &opts);
}

int git_repository_init_ext(
2055
	git_repository **out,
2056 2057 2058 2059
	const char *given_repo,
	git_repository_init_options *opts)
{
	int error;
2060 2061
	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT,
		common_path = GIT_BUF_INIT;
2062
	const char *wd;
2063

2064
	assert(out && given_repo && opts);
2065

2066
	GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
2067

2068 2069
	error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
	if (error < 0)
2070
		goto cleanup;
2071

2072
	wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_buf_cstr(&wd_path);
2073
	if (valid_repository_path(&repo_path, &common_path)) {
2074 2075

		if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
2076
			git_error_set(GIT_ERROR_REPOSITORY,
2077
				"attempt to reinitialize '%s'", given_repo);
2078 2079 2080 2081 2082 2083
			error = GIT_EEXISTS;
			goto cleanup;
		}

		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;

2084
		error = repo_init_config(
2085
			repo_path.ptr, wd, opts->flags, opts->mode);
2086 2087 2088 2089 2090

		/* TODO: reinitialize the templates */
	}
	else {
		if (!(error = repo_init_structure(
2091
				repo_path.ptr, wd, opts)) &&
2092
			!(error = repo_init_config(
2093
				repo_path.ptr, wd, opts->flags, opts->mode)))
2094
			error = git_repository_create_head(
2095
				repo_path.ptr, opts->initial_head);
2096
	}
2097 2098 2099
	if (error < 0)
		goto cleanup;

2100
	error = git_repository_open(out, repo_path.ptr);
2101

2102
	if (!error && opts->origin_url)
2103
		error = repo_init_create_origin(*out, opts->origin_url);
2104 2105

cleanup:
2106 2107 2108
	git_buf_dispose(&common_path);
	git_buf_dispose(&repo_path);
	git_buf_dispose(&wd_path);
2109 2110

	return error;
2111
}
2112

2113
int git_repository_head_detached(git_repository *repo)
2114 2115
{
	git_reference *ref;
2116
	git_odb *odb = NULL;
2117
	int exists;
2118

2119 2120
	if (git_repository_odb__weakptr(&odb, repo) < 0)
		return -1;
2121

2122 2123
	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
		return -1;
2124

2125
	if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
2126
		git_reference_free(ref);
2127
		return 0;
2128
	}
2129

2130
	exists = git_odb_exists(odb, git_reference_target(ref));
2131 2132

	git_reference_free(ref);
2133
	return exists;
2134 2135
}

2136 2137 2138 2139 2140 2141
static int get_worktree_file_path(git_buf *out, git_repository *repo, const char *worktree, const char *file)
{
	git_buf_clear(out);
	return git_buf_printf(out, "%s/worktrees/%s/%s", repo->commondir, worktree, file);
}

2142 2143
int git_repository_head_detached_for_worktree(git_repository *repo, const char *name)
{
2144 2145
	git_reference *ref = NULL;
	int error;
2146 2147 2148

	assert(repo && name);

2149 2150
	if ((error = git_repository_head_for_worktree(&ref, repo, name)) < 0)
		goto out;
2151

2152
	error = (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC);
2153 2154
out:
	git_reference_free(ref);
2155

2156
	return error;
2157 2158
}

2159
int git_repository_head(git_reference **head_out, git_repository *repo)
2160
{
2161
	git_reference *head;
2162 2163
	int error;

2164 2165
	assert(head_out);

2166 2167 2168
	if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
		return error;

2169
	if (git_reference_type(head) == GIT_REFERENCE_DIRECT) {
2170 2171 2172 2173
		*head_out = head;
		return 0;
	}

2174
	error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
2175
	git_reference_free(head);
2176

2177
	return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
2178 2179
}

2180 2181
int git_repository_head_for_worktree(git_reference **out, git_repository *repo, const char *name)
{
2182 2183 2184
	git_buf path = GIT_BUF_INIT;
	git_reference *head = NULL;
	int error;
2185 2186 2187 2188 2189

	assert(out && repo && name);

	*out = NULL;

2190 2191
	if ((error = get_worktree_file_path(&path, repo, name, GIT_HEAD_FILE)) < 0 ||
	    (error = git_reference__read_head(&head, repo, path.ptr)) < 0)
2192 2193
		goto out;

2194
	if (git_reference_type(head) != GIT_REFERENCE_DIRECT) {
2195
		git_reference *resolved;
2196

2197 2198 2199
		error = git_reference_lookup_resolved(&resolved, repo, git_reference_symbolic_target(head), -1);
		git_reference_free(head);
		head = resolved;
2200 2201
	}

2202
	*out = head;
2203 2204

out:
2205 2206
	if (error)
		git_reference_free(head);
2207

2208
	git_buf_dispose(&path);
2209

2210
	return error;
2211 2212
}

2213 2214 2215
int git_repository_foreach_head(git_repository *repo,
				git_repository_foreach_head_cb cb,
				int flags, void *payload)
2216 2217 2218
{
	git_strarray worktrees = GIT_VECTOR_INIT;
	git_buf path = GIT_BUF_INIT;
2219
	int error = 0;
2220 2221 2222
	size_t i;


2223 2224 2225 2226 2227
	if (!(flags & GIT_REPOSITORY_FOREACH_HEAD_SKIP_REPO)) {
		/* Gather HEAD of main repository */
		if ((error = git_buf_joinpath(&path, repo->commondir, GIT_HEAD_FILE)) < 0 ||
		    (error = cb(repo, path.ptr, payload) != 0))
			goto out;
2228 2229
	}

2230 2231 2232
	if (!(flags & GIT_REPOSITORY_FOREACH_HEAD_SKIP_WORKTREES)) {
		if ((error = git_worktree_list(&worktrees, repo)) < 0) {
			error = 0;
2233
			goto out;
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243
		}

		/* Gather HEADs of all worktrees */
		for (i = 0; i < worktrees.count; i++) {
			if (get_worktree_file_path(&path, repo, worktrees.strings[i], GIT_HEAD_FILE) < 0)
				continue;

			if ((error = cb(repo, path.ptr, payload)) != 0)
				goto out;
		}
2244 2245 2246
	}

out:
2247
	git_buf_dispose(&path);
2248 2249 2250 2251
	git_strarray_free(&worktrees);
	return error;
}

2252
int git_repository_head_unborn(git_repository *repo)
2253
{
2254
	git_reference *ref = NULL;
2255 2256 2257
	int error;

	error = git_repository_head(&ref, repo);
2258
	git_reference_free(ref);
2259

2260
	if (error == GIT_EUNBORNBRANCH) {
2261
		git_error_clear();
2262
		return 1;
2263
	}
2264

2265 2266 2267 2268
	if (error < 0)
		return -1;

	return 0;
2269
}
2270

2271
static int at_least_one_cb(const char *refname, void *payload)
2272
{
2273 2274
	GIT_UNUSED(refname);
	GIT_UNUSED(payload);
2275
	return GIT_PASSTHROUGH;
2276
}
2277

2278 2279
static int repo_contains_no_reference(git_repository *repo)
{
2280
	int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
2281

2282
	if (error == GIT_PASSTHROUGH)
2283
		return 0;
2284

2285 2286
	if (!error)
		return 1;
2287

2288
	return error;
2289
}
2290

2291 2292 2293
int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL;
2294
	int is_empty = 0;
2295

2296
	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0)
2297 2298
		return -1;

2299
	if (git_reference_type(head) == GIT_REFERENCE_SYMBOLIC)
2300 2301 2302 2303
		is_empty =
			(strcmp(git_reference_symbolic_target(head),
					GIT_REFS_HEADS_DIR "master") == 0) &&
			repo_contains_no_reference(repo);
2304 2305

	git_reference_free(head);
2306 2307

	return is_empty;
2308 2309
}

2310
int git_repository_item_path(git_buf *out, const git_repository *repo, git_repository_item_t item)
2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
{
	const char *parent;

	switch (items[item].parent) {
		case GIT_REPOSITORY_ITEM_GITDIR:
			parent = git_repository_path(repo);
			break;
		case GIT_REPOSITORY_ITEM_WORKDIR:
			parent = git_repository_workdir(repo);
			break;
		case GIT_REPOSITORY_ITEM_COMMONDIR:
			parent = git_repository_commondir(repo);
			break;
		default:
2325
			git_error_set(GIT_ERROR_INVALID, "invalid item directory");
2326 2327 2328 2329
			return -1;
	}

	if (parent == NULL) {
2330
		git_error_set(GIT_ERROR_INVALID, "path cannot exist in repository");
2331
		return GIT_ENOTFOUND;
2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349
	}

	if (git_buf_sets(out, parent) < 0)
		return -1;

	if (items[item].name) {
		if (git_buf_joinpath(out, parent, items[item].name) < 0)
			return -1;
	}

	if (items[item].directory) {
		if (git_path_to_dir(out) < 0)
			return -1;
	}

	return 0;
}

2350
const char *git_repository_path(const git_repository *repo)
2351 2352
{
	assert(repo);
2353
	return repo->gitdir;
2354
}
2355

2356
const char *git_repository_workdir(const git_repository *repo)
2357 2358
{
	assert(repo);
2359

2360 2361
	if (repo->is_bare)
		return NULL;
2362

2363 2364
	return repo->workdir;
}
2365

2366
const char *git_repository_commondir(const git_repository *repo)
2367 2368 2369 2370 2371
{
	assert(repo);
	return repo->commondir;
}

2372 2373
int git_repository_set_workdir(
	git_repository *repo, const char *workdir, int update_gitlink)
2374
{
2375
	int error = 0;
2376 2377
	git_buf path = GIT_BUF_INIT;

2378
	assert(repo && workdir);
2379

2380 2381
	if (git_path_prettify_dir(&path, workdir, NULL) < 0)
		return -1;
2382

2383 2384
	if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
		return 0;
2385

2386 2387 2388 2389 2390 2391
	if (update_gitlink) {
		git_config *config;

		if (git_repository_config__weakptr(&config, repo) < 0)
			return -1;

2392
		error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);
2393 2394 2395

		/* passthrough error means gitlink is unnecessary */
		if (error == GIT_PASSTHROUGH)
Ben Straub committed
2396
			error = git_config_delete_entry(config, "core.worktree");
2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
		else if (!error)
			error = git_config_set_string(config, "core.worktree", path.ptr);

		if (!error)
			error = git_config_set_bool(config, "core.bare", false);
	}

	if (!error) {
		char *old_workdir = repo->workdir;

		repo->workdir = git_buf_detach(&path);
		repo->is_bare = 0;

		git__free(old_workdir);
	}

	return error;
2414
}
2415

2416
int git_repository_is_bare(const git_repository *repo)
2417 2418 2419 2420
{
	assert(repo);
	return repo->is_bare;
}
2421

2422
int git_repository_is_worktree(const git_repository *repo)
2423 2424 2425 2426 2427
{
	assert(repo);
	return repo->is_worktree;
}

2428 2429 2430 2431 2432 2433 2434 2435 2436 2437
int git_repository_set_bare(git_repository *repo)
{
	int error;
	git_config *config;

	assert(repo);

	if (repo->is_bare)
		return 0;

2438 2439 2440
	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
		return error;

2441
	if ((error = git_config_set_bool(config, "core.bare", true)) < 0)
2442
		return error;
2443

2444 2445
	if ((error = git_config__update_entry(config, "core.worktree", NULL, true, true)) < 0)
		return error;
2446 2447 2448 2449 2450

	git__free(repo->workdir);
	repo->workdir = NULL;
	repo->is_bare = 1;

2451
	return 0;
2452 2453
}

2454 2455
int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
2456 2457 2458
	git_reference *head;
	git_object *obj;
	int error;
2459

2460 2461
	if ((error = git_repository_head(&head, repo)) < 0)
		return error;
2462

2463
	if ((error = git_reference_peel(&obj, head, GIT_OBJECT_TREE)) < 0)
2464
		goto cleanup;
2465 2466

	*tree = (git_tree *)obj;
2467 2468 2469 2470

cleanup:
	git_reference_free(head);
	return error;
2471
}
2472

2473 2474 2475 2476 2477 2478 2479 2480 2481
int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head)
{
	git_filebuf file = GIT_FILEBUF_INIT;
	git_buf file_path = GIT_BUF_INIT;
	char orig_head_str[GIT_OID_HEXSZ];
	int error = 0;

	git_oid_fmt(orig_head_str, orig_head);

2482
	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 &&
2483 2484 2485 2486 2487 2488 2489
		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_MERGE_FILE_MODE)) == 0 &&
		(error = git_filebuf_printf(&file, "%.*s\n", GIT_OID_HEXSZ, orig_head_str)) == 0)
		error = git_filebuf_commit(&file);

	if (error < 0)
		git_filebuf_cleanup(&file);

2490
	git_buf_dispose(&file_path);
2491 2492 2493 2494

	return error;
}

2495
int git_repository_message(git_buf *out, git_repository *repo)
2496
{
2497
	git_buf path = GIT_BUF_INIT;
Vicent Marti committed
2498 2499
	struct stat st;
	int error;
2500

2501
	git_buf_sanitize(out);
2502

2503
	if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
2504
		return -1;
2505

2506
	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
2507 2508
		if (errno == ENOENT)
			error = GIT_ENOTFOUND;
2509
		git_error_set(GIT_ERROR_OS, "could not access message file");
2510 2511
	} else {
		error = git_futils_readbuffer(out, git_buf_cstr(&path));
Vicent Marti committed
2512
	}
2513

2514
	git_buf_dispose(&path);
2515 2516

	return error;
2517 2518 2519 2520
}

int git_repository_message_remove(git_repository *repo)
{
Vicent Marti committed
2521 2522
	git_buf path = GIT_BUF_INIT;
	int error;
2523

2524
	if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
2525
		return -1;
2526 2527

	error = p_unlink(git_buf_cstr(&path));
2528
	git_buf_dispose(&path);
2529 2530 2531

	return error;
}
2532 2533

int git_repository_hashfile(
Linquize committed
2534 2535 2536
	git_oid *out,
	git_repository *repo,
	const char *path,
2537
	git_object_t type,
Linquize committed
2538
	const char *as_path)
2539 2540
{
	int error;
2541
	git_filter_list *fl = NULL;
2542
	git_file fd = -1;
2543 2544 2545
	git_off_t len;
	git_buf full_path = GIT_BUF_INIT;

2546 2547 2548 2549 2550 2551
	assert(out && path && repo); /* as_path can be NULL */

	/* At some point, it would be nice if repo could be NULL to just
	 * apply filter rules defined in system and global files, but for
	 * now that is not possible because git_filters_load() needs it.
	 */
2552 2553

	error = git_path_join_unrooted(
2554
		&full_path, path, git_repository_workdir(repo), NULL);
2555 2556 2557 2558 2559 2560 2561 2562
	if (error < 0)
		return error;

	if (!as_path)
		as_path = path;

	/* passing empty string for "as_path" indicated --no-filters */
	if (strlen(as_path) > 0) {
Russell Belfer committed
2563
		error = git_filter_list_load(
2564
			&fl, repo, NULL, as_path,
2565
			GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581
		if (error < 0)
			return error;
	} else {
		error = 0;
	}

	/* at this point, error is a count of the number of loaded filters */

	fd = git_futils_open_ro(full_path.ptr);
	if (fd < 0) {
		error = fd;
		goto cleanup;
	}

	len = git_futils_filesize(fd);
	if (len < 0) {
2582
		error = (int)len;
2583 2584 2585 2586
		goto cleanup;
	}

	if (!git__is_sizet(len)) {
2587
		git_error_set(GIT_ERROR_OS, "file size overflow for 32-bit systems");
2588 2589 2590 2591
		error = -1;
		goto cleanup;
	}

2592
	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
2593 2594

cleanup:
2595 2596
	if (fd >= 0)
		p_close(fd);
2597
	git_filter_list_free(fl);
2598
	git_buf_dispose(&full_path);
2599 2600 2601 2602

	return error;
}

2603
static int checkout_message(git_buf *out, git_reference *old, const char *new)
2604
{
2605 2606
	git_buf_puts(out, "checkout: moving from ");

2607
	if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC)
2608 2609 2610 2611 2612 2613
		git_buf_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
	else
		git_buf_puts(out, git_oid_tostr_s(git_reference_target(old)));

	git_buf_puts(out, " to ");

2614 2615 2616
	if (git_reference__is_branch(new) ||
		git_reference__is_tag(new) ||
		git_reference__is_remote(new))
2617 2618 2619 2620 2621 2622 2623 2624
		git_buf_puts(out, git_reference__shorthand(new));
	else
		git_buf_puts(out, new);

	if (git_buf_oom(out))
		return -1;

	return 0;
2625 2626
}

2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638
static int detach(git_repository *repo, const git_oid *id, const char *new)
{
	int error;
	git_buf log_message = GIT_BUF_INIT;
	git_object *object = NULL, *peeled = NULL;
	git_reference *new_head = NULL, *current = NULL;

	assert(repo && id);

	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
		return error;

2639
	if ((error = git_object_lookup(&object, repo, id, GIT_OBJECT_ANY)) < 0)
2640 2641
		goto cleanup;

2642
	if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0)
2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
		goto cleanup;

	if (new == NULL)
		new = git_oid_tostr_s(git_object_id(peeled));

	if ((error = checkout_message(&log_message, current, new)) < 0)
		goto cleanup;

	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, git_buf_cstr(&log_message));

cleanup:
2654
	git_buf_dispose(&log_message);
2655 2656 2657 2658 2659 2660 2661
	git_object_free(object);
	git_object_free(peeled);
	git_reference_free(current);
	git_reference_free(new_head);
	return error;
}

2662 2663
int git_repository_set_head(
	git_repository* repo,
2664
	const char* refname)
2665
{
2666 2667
	git_reference *ref = NULL, *current = NULL, *new_head = NULL;
	git_buf log_message = GIT_BUF_INIT;
2668 2669 2670 2671
	int error;

	assert(repo && refname);

2672 2673 2674 2675 2676 2677
	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
		return error;

	if ((error = checkout_message(&log_message, current, refname)) < 0)
		goto cleanup;

2678 2679
	error = git_reference_lookup(&ref, repo, refname);
	if (error < 0 && error != GIT_ENOTFOUND)
2680
		goto cleanup;
2681

2682
	if (ref && current->type == GIT_REFERENCE_SYMBOLIC && git__strcmp(current->target.symbolic, ref->name) &&
2683
	    git_reference_is_branch(ref) && git_branch_is_checked_out(ref)) {
2684
		git_error_set(GIT_ERROR_REPOSITORY, "cannot set HEAD to reference '%s' as it is the current HEAD "
2685
			"of a linked repository.", git_reference_name(ref));
2686 2687 2688 2689
		error = -1;
		goto cleanup;
	}

2690
	if (!error) {
2691 2692
		if (git_reference_is_branch(ref)) {
			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
2693
					git_reference_name(ref), true, git_buf_cstr(&log_message));
2694
		} else {
2695
			error = detach(repo, git_reference_target(ref),
2696
				git_reference_is_tag(ref) || git_reference_is_remote(ref) ? refname : NULL);
2697
		}
2698
	} else if (git_reference__is_branch(refname)) {
2699
		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
2700
				true, git_buf_cstr(&log_message));
2701
	}
2702

2703
cleanup:
2704
	git_buf_dispose(&log_message);
2705
	git_reference_free(current);
2706 2707 2708 2709 2710
	git_reference_free(ref);
	git_reference_free(new_head);
	return error;
}

2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723
int git_repository_set_head_detached(
	git_repository* repo,
	const git_oid* commitish)
{
	return detach(repo, commitish, NULL);
}

int git_repository_set_head_detached_from_annotated(
	git_repository *repo,
	const git_annotated_commit *commitish)
{
	assert(repo && commitish);

2724
	return detach(repo, git_annotated_commit_id(commitish), commitish->description);
2725 2726
}

2727
int git_repository_detach_head(git_repository* repo)
2728
{
2729
	git_reference *old_head = NULL,	*new_head = NULL, *current = NULL;
2730
	git_object *object = NULL;
2731
	git_buf log_message = GIT_BUF_INIT;
2732
	int error;
2733 2734 2735

	assert(repo);

2736
	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
2737
		return error;
2738

2739 2740 2741
	if ((error = git_repository_head(&old_head, repo)) < 0)
		goto cleanup;

2742
	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0)
2743 2744
		goto cleanup;

2745 2746 2747
	if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
		goto cleanup;

2748
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
2749
			1, git_buf_cstr(&log_message));
2750 2751

cleanup:
2752
	git_buf_dispose(&log_message);
2753 2754 2755
	git_object_free(object);
	git_reference_free(old_head);
	git_reference_free(new_head);
2756
	git_reference_free(current);
2757 2758
	return error;
}
Edward Thomson committed
2759

2760 2761 2762 2763
/**
 * Loosely ported from git.git
 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
 */
Edward Thomson committed
2764 2765 2766 2767 2768 2769 2770
int git_repository_state(git_repository *repo)
{
	git_buf repo_path = GIT_BUF_INIT;
	int state = GIT_REPOSITORY_STATE_NONE;

	assert(repo);

2771
	if (git_buf_puts(&repo_path, repo->gitdir) < 0)
Edward Thomson committed
2772 2773
		return -1;

2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784
	if (git_path_contains_file(&repo_path, GIT_REBASE_MERGE_INTERACTIVE_FILE))
		state = GIT_REPOSITORY_STATE_REBASE_INTERACTIVE;
	else if (git_path_contains_dir(&repo_path, GIT_REBASE_MERGE_DIR))
		state = GIT_REPOSITORY_STATE_REBASE_MERGE;
	else if (git_path_contains_file(&repo_path, GIT_REBASE_APPLY_REBASING_FILE))
		state = GIT_REPOSITORY_STATE_REBASE;
	else if (git_path_contains_file(&repo_path, GIT_REBASE_APPLY_APPLYING_FILE))
		state = GIT_REPOSITORY_STATE_APPLY_MAILBOX;
	else if (git_path_contains_dir(&repo_path, GIT_REBASE_APPLY_DIR))
		state = GIT_REPOSITORY_STATE_APPLY_MAILBOX_OR_REBASE;
	else if (git_path_contains_file(&repo_path, GIT_MERGE_HEAD_FILE))
Edward Thomson committed
2785
		state = GIT_REPOSITORY_STATE_MERGE;
2786
	else if (git_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE)) {
Edward Thomson committed
2787
		state = GIT_REPOSITORY_STATE_REVERT;
2788 2789 2790 2791
		if (git_path_contains_file(&repo_path, GIT_SEQUENCER_TODO_FILE)) {
			state = GIT_REPOSITORY_STATE_REVERT_SEQUENCE;
		}
	} else if (git_path_contains_file(&repo_path, GIT_CHERRYPICK_HEAD_FILE)) {
2792
		state = GIT_REPOSITORY_STATE_CHERRYPICK;
2793 2794 2795 2796
		if (git_path_contains_file(&repo_path, GIT_SEQUENCER_TODO_FILE)) {
			state = GIT_REPOSITORY_STATE_CHERRYPICK_SEQUENCE;
		}
	} else if (git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
2797
		state = GIT_REPOSITORY_STATE_BISECT;
Edward Thomson committed
2798

2799
	git_buf_dispose(&repo_path);
Edward Thomson committed
2800 2801
	return state;
}
Ben Straub committed
2802

2803 2804
int git_repository__cleanup_files(
	git_repository *repo, const char *files[], size_t files_len)
2805
{
2806
	git_buf buf = GIT_BUF_INIT;
2807
	size_t i;
2808
	int error;
2809

2810 2811
	for (error = 0, i = 0; !error && i < files_len; ++i) {
		const char *path;
2812

2813
		if (git_buf_joinpath(&buf, repo->gitdir, files[i]) < 0)
2814
			return -1;
2815

2816 2817 2818 2819 2820 2821 2822 2823
		path = git_buf_cstr(&buf);

		if (git_path_isfile(path)) {
			error = p_unlink(path);
		} else if (git_path_isdir(path)) {
			error = git_futils_rmdir_r(path, NULL,
				GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS);
		}
2824

2825 2826
		git_buf_clear(&buf);
	}
2827

2828
	git_buf_dispose(&buf);
2829 2830 2831 2832 2833 2834 2835 2836
	return error;
}

static const char *state_files[] = {
	GIT_MERGE_HEAD_FILE,
	GIT_MERGE_MODE_FILE,
	GIT_MERGE_MSG_FILE,
	GIT_REVERT_HEAD_FILE,
2837
	GIT_CHERRYPICK_HEAD_FILE,
2838 2839 2840
	GIT_BISECT_LOG_FILE,
	GIT_REBASE_MERGE_DIR,
	GIT_REBASE_APPLY_DIR,
2841
	GIT_SEQUENCER_DIR,
2842 2843 2844 2845 2846 2847 2848 2849 2850
};

int git_repository_state_cleanup(git_repository *repo)
{
	assert(repo);

	return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
}

Ben Straub committed
2851 2852 2853 2854
int git_repository_is_shallow(git_repository *repo)
{
	git_buf path = GIT_BUF_INIT;
	struct stat st;
Ben Straub committed
2855
	int error;
Ben Straub committed
2856

2857
	if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0)
2858 2859
		return error;

Ben Straub committed
2860
	error = git_path_lstat(path.ptr, &st);
2861
	git_buf_dispose(&path);
Ben Straub committed
2862

2863
	if (error == GIT_ENOTFOUND) {
2864
		git_error_clear();
Ben Straub committed
2865
		return 0;
2866 2867
	}

Ben Straub committed
2868 2869 2870
	if (error < 0)
		return error;
	return st.st_size == 0 ? 0 : 1;
Ben Straub committed
2871
}
2872

2873 2874
int git_repository_init_init_options(
	git_repository_init_options *opts, unsigned int version)
2875
{
2876 2877 2878 2879
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_repository_init_options,
		GIT_REPOSITORY_INIT_OPTIONS_INIT);
	return 0;
2880
}
2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895

int git_repository_ident(const char **name, const char **email, const git_repository *repo)
{
	*name = repo->ident_name;
	*email = repo->ident_email;

	return 0;
}

int git_repository_set_ident(git_repository *repo, const char *name, const char *email)
{
	char *tmp_name = NULL, *tmp_email = NULL;

	if (name) {
		tmp_name = git__strdup(name);
2896
		GIT_ERROR_CHECK_ALLOC(tmp_name);
2897 2898 2899 2900
	}

	if (email) {
		tmp_email = git__strdup(email);
2901
		GIT_ERROR_CHECK_ALLOC(tmp_email);
2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
	}

	tmp_name = git__swap(repo->ident_name, tmp_name);
	tmp_email = git__swap(repo->ident_email, tmp_email);

	git__free(tmp_name);
	git__free(tmp_email);

	return 0;
}
2912 2913 2914 2915 2916 2917 2918

int git_repository_submodule_cache_all(git_repository *repo)
{
	int error;

	assert(repo);

2919
	if ((error = git_strmap_new(&repo->submodule_cache)))
2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939
		return error;

	error = git_submodule__map(repo, repo->submodule_cache);
	return error;
}

int git_repository_submodule_cache_clear(git_repository *repo)
{
	git_submodule *sm;
	assert(repo);
	if (repo->submodule_cache == NULL) {
		return 0;
	}
	git_strmap_foreach_value(repo->submodule_cache, sm, {
		git_submodule_free(sm);
	});
	git_strmap_free(repo->submodule_cache);
	repo->submodule_cache = 0;
	return 0;
}