repository.c 69.3 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 163
	if (repo == NULL)
		return;

	git_repository__cleanup(repo);

	git_cache_free(&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 248 249 250 251

on_error:
	if (repo)
		git_cache_free(&repo->objects);

	git__free(repo);
	return NULL;
252 253
}

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

	*out = repo = repository_alloc();
	GITERR_CHECK_ALLOC(repo);

	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
	}

	GITERR_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
		giterr_set(GITERR_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
		giterr_set(GITERR_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
		giterr_set(GITERR_REPOSITORY, "path is not a repository: %s", bare_path);
580 581 582 583 584 585
		return GIT_ENOTFOUND;
	}

	repo = repository_alloc();
	GITERR_CHECK_ALLOC(repo);

586 587
	repo->gitdir = git_buf_detach(&path);
	GITERR_CHECK_ALLOC(repo->gitdir);
588 589
	repo->commondir = git_buf_detach(&common_path);
	GITERR_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 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
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) {
			giterr_clear();
			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)
		giterr_clear();
	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)
		giterr_clear();
	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)
		giterr_clear();
	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)
		giterr_clear();
	else if (error < 0)
		goto error;

	error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");
	if (error == GIT_ENOTFOUND)
		giterr_clear();
	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)
		giterr_clear();
	else if (error < 0)
		goto error;
	else {
		giterr_set(GITERR_INVALID, "GIT_WORK_TREE unimplemented");
		error = GIT_ERROR;
		goto error;
	}

	error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");
	if (error == GIT_ENOTFOUND)
		giterr_clear();
	else if (error < 0)
		goto error;
	else {
		giterr_set(GITERR_INVALID, "GIT_COMMON_DIR unimplemented");
		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
		giterr_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
	GITERR_CHECK_ALLOC(repo);
819

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

823 824
	if (gitlink.size) {
		repo->gitlink = git_buf_detach(&gitlink);
825
		GITERR_CHECK_ALLOC(repo->gitlink);
826
	}
827 828
	if (commondir.size) {
		repo->commondir = git_buf_detach(&commondir);
829 830
		GITERR_CHECK_ALLOC(repo->commondir);
	}
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 912 913 914 915 916 917 918 919
int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
{
	git_repository *repo;

	repo = repository_alloc();
	GITERR_CHECK_ALLOC(repo);

	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 987
	giterr_clear(); /* clear any lingering ENOTFOUND errors */

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

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

1192
		git_buf_dispose(&index_path);
1193 1194 1195
	}

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

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

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

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

Vicent Marti committed
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
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;
}

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

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

	name_len = strlen(name);

1246
	if ((name_len == def_len && memcmp(name, def, def_len) == 0) ||
1247
		(name_len == def_dot_git_len && memcmp(name, def_dot_git, def_dot_git_len) == 0)) {
1248 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
		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;
		}

1277 1278 1279 1280 1281 1282
		/* 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.
		 */
1283
		if (!repo->is_bare) {
1284 1285
			int (*prefixcmp)(const char *, const char *);
			int error, ignorecase;
1286

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

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

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

1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
	*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;
1314
}
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331
#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
1332

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

1337 1338 1339 1340 1341 1342
	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)
1343
		return -1;
1344

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

1352
	return 0;
1353 1354
}

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

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

	if (!ref_name)
		ref_name = GIT_BRANCH_MASTER;

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

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

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

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

1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398
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;

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

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

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

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

1414 1415
static bool are_symlinks_supported(const char *wd_path)
{
1416
	git_config *config = NULL;
1417 1418 1419
	git_buf path = GIT_BUF_INIT;
	int fd;
	struct stat st;
1420
	int symlinks = 0;
1421 1422 1423 1424 1425 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_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;

	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 1463 1464
done:
	git_buf_dispose(&path);
	git_config_free(config);
1465
	return symlinks != 0;
1466 1467
}

1468 1469 1470 1471 1472
static int create_empty_file(const char *path, mode_t mode)
{
	int fd;

	if ((fd = p_creat(path, mode)) < 0) {
1473
		giterr_set(GITERR_OS, "error while creating '%s'", path);
1474 1475 1476 1477
		return -1;
	}

	if (p_close(fd) < 0) {
1478
		giterr_set(GITERR_OS, "error while closing '%s'", path);
1479 1480 1481 1482 1483 1484
		return -1;
	}

	return 0;
}

1485 1486 1487 1488 1489
static int repo_local_config(
	git_config **out,
	git_buf *config_dir,
	git_repository *repo,
	const char *repo_dir)
1490
{
1491
	int error = 0;
1492 1493
	git_config *parent;
	const char *cfg_path;
1494

1495
	if (git_buf_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
1496
		return -1;
1497
	cfg_path = git_buf_cstr(config_dir);
1498

1499
	/* make LOCAL config if missing */
1500 1501
	if (!git_path_isfile(cfg_path) &&
		(error = create_empty_file(cfg_path, GIT_CONFIG_FILE_MODE)) < 0)
1502
		return error;
1503

1504 1505 1506 1507 1508 1509 1510 1511 1512
	/* 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) {
1513 1514 1515
		giterr_clear();

		if (!(error = git_config_add_file_ondisk(
1516
				parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, repo, false)))
1517
			error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
1518
	}
1519

1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
	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)
		giterr_clear();
1546

1547 1548 1549 1550 1551 1552 1553
	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)
			giterr_clear();
	}
1554

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

1563 1564
	return 0;
}
1565

1566 1567 1568 1569 1570 1571 1572
static int repo_init_config(
	const char *repo_dir,
	const char *work_dir,
	uint32_t flags,
	uint32_t mode)
{
	int error = 0;
1573
	git_buf cfg_path = GIT_BUF_INIT, worktree_path = GIT_BUF_INIT;
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
	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;
1594

1595 1596
	if (!is_bare) {
		SET_REPO_CONFIG(bool, "core.logallrefupdates", true);
1597

1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
		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
1608
			if (git_config_delete_entry(config, "core.worktree") < 0)
1609
				giterr_clear();
1610 1611 1612
		}
	}

1613
	if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
1614 1615
		SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
1616
	}
1617
	else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
1618 1619 1620
		SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
	}
1621

1622
cleanup:
1623 1624
	git_buf_dispose(&cfg_path);
	git_buf_dispose(&worktree_path);
1625
	git_config_free(config);
1626

1627
	return error;
1628
}
1629

1630
static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
1631
{
1632 1633
	git_repository *smrepo = NULL;
	GIT_UNUSED(n); GIT_UNUSED(p);
1634

1635
	if (git_submodule_open(&smrepo, sm) < 0 ||
1636
		git_repository_reinit_filesystem(smrepo, true) < 0)
1637 1638
		giterr_clear();
	git_repository_free(smrepo);
1639

1640 1641
	return 0;
}
1642

1643
int git_repository_reinit_filesystem(git_repository *repo, int recurse)
1644 1645 1646 1647 1648
{
	int error = 0;
	git_buf path = GIT_BUF_INIT;
	git_config *config = NULL;
	const char *repo_dir = git_repository_path(repo);
1649

1650 1651 1652
	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);
1653

1654
	git_config_free(config);
1655
	git_buf_dispose(&path);
1656 1657 1658

	git_repository__cvar_cache_clear(repo);

1659
	if (!repo->is_bare && recurse)
1660
		(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
1661

1662 1663 1664
	return error;
}

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

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

1679 1680 1681 1682 1683 1684
	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);
1685

1686 1687
	if (fd >= 0) {
		error = p_write(fd, content, strlen(content));
1688

1689 1690 1691 1692
		p_close(fd);
	}
	else if (errno != EEXIST)
		error = fd;
1693

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

1703
	git_buf_dispose(&path);
1704 1705 1706

	if (error)
		giterr_set(GITERR_OS,
1707
			"failed to initialize repository with template '%s'", file);
1708 1709

	return error;
1710 1711
}

1712
static int repo_write_gitlink(
1713
	const char *in_dir, const char *to_repo, bool use_relative_path)
1714
{
1715 1716
	int error;
	git_buf buf = GIT_BUF_INIT;
1717
	git_buf path_to_repo = GIT_BUF_INIT;
1718 1719 1720 1721 1722
	struct stat st;

	git_path_dirname_r(&buf, to_repo);
	git_path_to_dir(&buf);
	if (git_buf_oom(&buf))
1723
		return -1;
1724

1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737
	/* 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,
1738
			"cannot overwrite gitlink file into path '%s'", in_dir);
1739 1740 1741 1742 1743 1744
		error = GIT_EEXISTS;
		goto cleanup;
	}

	git_buf_clear(&buf);

1745 1746 1747 1748 1749 1750 1751
	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);
1752 1753

	if (!error)
1754
		error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
1755 1756

cleanup:
1757 1758
	git_buf_dispose(&buf);
	git_buf_dispose(&path_to_repo);
1759 1760 1761
	return error;
}

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

1773 1774 1775 1776 1777 1778 1779
#include "repo_template.h"

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

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

	/* Create the .git gitlink if appropriate */
	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
		(opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0)
	{
1802
		if (repo_write_gitlink(work_dir, repo_dir, opts->flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK) < 0)
1803
			return -1;
1804
	}
1805

1806 1807
	/* Copy external template if requested */
	if (external_tpl) {
Linquize committed
1808 1809 1810
		git_config *cfg = NULL;
		const char *tdir = NULL;
		bool default_template = false;
1811 1812
		git_buf template_buf = GIT_BUF_INIT;

1813 1814
		if (opts->template_path)
			tdir = opts->template_path;
Linquize committed
1815
		else if ((error = git_config_open_default(&cfg)) >= 0) {
1816 1817
			if (!git_config_get_path(&template_buf, cfg, "init.templatedir"))
				tdir = template_buf.ptr;
1818
			giterr_clear();
Linquize committed
1819 1820 1821
		}

		if (!tdir) {
1822
			if (!(error = git_sysdir_find_template_dir(&template_buf)))
1823
				tdir = template_buf.ptr;
Linquize committed
1824
			default_template = true;
1825
		}
1826

1827 1828 1829 1830 1831 1832 1833
		/*
		 * 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) {
1834 1835 1836
			uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS |
				GIT_CPDIR_SIMPLE_TO_MODE |
				GIT_CPDIR_COPY_DOTFILES;
1837 1838 1839
			if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
					cpflags |= GIT_CPDIR_CHMOD_DIRS;
			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
1840
		}
1841

1842
		git_buf_dispose(&template_buf);
Linquize committed
1843
		git_config_free(cfg);
1844

1845
		if (error < 0) {
Linquize committed
1846
			if (!default_template)
1847 1848 1849 1850 1851
				return error;

			/* if template was default, ignore error and use internal */
			giterr_clear();
			external_tpl = false;
1852
			error = 0;
1853 1854 1855 1856 1857 1858 1859 1860
		}
	}

	/* 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) {
1861
		if (!tpl->content) {
1862 1863 1864 1865
			uint32_t mkdir_flags = GIT_MKDIR_PATH;
			if (chmod)
				mkdir_flags |= GIT_MKDIR_CHMOD;

1866 1867
			error = git_futils_mkdir_relative(
				tpl->path, repo_dir, dmode, mkdir_flags, NULL);
1868
		}
1869
		else if (!external_tpl) {
1870 1871 1872 1873 1874
			const char *content = tpl->content;

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

1875 1876
			error = repo_write_template(
				repo_dir, false, tpl->path, tpl->mode, false, content);
1877
		}
1878 1879
	}

1880
	return error;
1881 1882
}

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

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

1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
	/* 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
	 */

1924
	/* set up repo path */
1925

1926 1927
	is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);

1928 1929
	add_dotgit =
		(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
1930
		!is_bare &&
1931 1932
		git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
		git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
1933

1934 1935
	if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
		return -1;
1936

1937 1938 1939 1940 1941 1942
	has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
	if (has_dotgit)
		opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;

	/* set up workdir path */

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

1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972
		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 */

1973
	dirmode = pick_dir_mode(opts);
1974

1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
	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(
1993
				wd_path->ptr, dirmode & ~S_ISGID,
1994 1995 1996 1997 1998 1999
				GIT_MKDIR_VERIFY_DIR)) < 0)
			return error;

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

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

2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
	/* 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
2031
	if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
2032 2033 2034 2035 2036 2037 2038 2039 2040
		git_remote_free(remote);
	}

	return error;
}

int git_repository_init(
	git_repository **repo_out, const char *path, unsigned is_bare)
{
2041
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
2042 2043 2044 2045 2046 2047 2048 2049 2050

	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(
2051
	git_repository **out,
2052 2053 2054 2055
	const char *given_repo,
	git_repository_init_options *opts)
{
	int error;
2056 2057
	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT,
		common_path = GIT_BUF_INIT;
2058
	const char *wd;
2059

2060
	assert(out && given_repo && opts);
2061

Ben Straub committed
2062
	GITERR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
2063

2064 2065
	error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
	if (error < 0)
2066
		goto cleanup;
2067

2068
	wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_buf_cstr(&wd_path);
2069
	if (valid_repository_path(&repo_path, &common_path)) {
2070 2071 2072

		if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
			giterr_set(GITERR_REPOSITORY,
2073
				"attempt to reinitialize '%s'", given_repo);
2074 2075 2076 2077 2078 2079
			error = GIT_EEXISTS;
			goto cleanup;
		}

		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;

2080
		error = repo_init_config(
2081
			repo_path.ptr, wd, opts->flags, opts->mode);
2082 2083 2084 2085 2086

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

2096
	error = git_repository_open(out, repo_path.ptr);
2097

2098
	if (!error && opts->origin_url)
2099
		error = repo_init_create_origin(*out, opts->origin_url);
2100 2101

cleanup:
2102 2103 2104
	git_buf_dispose(&common_path);
	git_buf_dispose(&repo_path);
	git_buf_dispose(&wd_path);
2105 2106

	return error;
2107
}
2108

2109
int git_repository_head_detached(git_repository *repo)
2110 2111
{
	git_reference *ref;
2112
	git_odb *odb = NULL;
2113
	int exists;
2114

2115 2116
	if (git_repository_odb__weakptr(&odb, repo) < 0)
		return -1;
2117

2118 2119
	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
		return -1;
2120

2121 2122
	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
		git_reference_free(ref);
2123
		return 0;
2124
	}
2125

2126
	exists = git_odb_exists(odb, git_reference_target(ref));
2127 2128

	git_reference_free(ref);
2129
	return exists;
2130 2131
}

2132 2133 2134 2135 2136 2137
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);
}

2138 2139
int git_repository_head_detached_for_worktree(git_repository *repo, const char *name)
{
2140 2141
	git_reference *ref = NULL;
	int error;
2142 2143 2144

	assert(repo && name);

2145 2146
	if ((error = git_repository_head_for_worktree(&ref, repo, name)) < 0)
		goto out;
2147

2148 2149 2150
	error = (git_reference_type(ref) != GIT_REF_SYMBOLIC);
out:
	git_reference_free(ref);
2151

2152
	return error;
2153 2154
}

2155
int git_repository_head(git_reference **head_out, git_repository *repo)
2156
{
2157
	git_reference *head;
2158 2159
	int error;

2160 2161 2162 2163 2164 2165 2166 2167
	if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
		return error;

	if (git_reference_type(head) == GIT_REF_OID) {
		*head_out = head;
		return 0;
	}

2168
	error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
2169
	git_reference_free(head);
2170

2171
	return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
2172 2173
}

2174 2175
int git_repository_head_for_worktree(git_reference **out, git_repository *repo, const char *name)
{
2176 2177 2178
	git_buf path = GIT_BUF_INIT;
	git_reference *head = NULL;
	int error;
2179 2180 2181 2182 2183

	assert(out && repo && name);

	*out = NULL;

2184 2185
	if ((error = get_worktree_file_path(&path, repo, name, GIT_HEAD_FILE)) < 0 ||
	    (error = git_reference__read_head(&head, repo, path.ptr)) < 0)
2186 2187
		goto out;

2188 2189
	if (git_reference_type(head) != GIT_REF_OID) {
		git_reference *resolved;
2190

2191 2192 2193
		error = git_reference_lookup_resolved(&resolved, repo, git_reference_symbolic_target(head), -1);
		git_reference_free(head);
		head = resolved;
2194 2195
	}

2196
	*out = head;
2197 2198

out:
2199 2200
	if (error)
		git_reference_free(head);
2201

2202
	git_buf_dispose(&path);
2203

2204
	return error;
2205 2206
}

2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233
int git_repository_foreach_head(git_repository *repo, git_repository_foreach_head_cb cb, void *payload)
{
	git_strarray worktrees = GIT_VECTOR_INIT;
	git_buf path = GIT_BUF_INIT;
	int error;
	size_t i;

	/* Execute callback for HEAD of commondir */
	if ((error = git_buf_joinpath(&path, repo->commondir, GIT_HEAD_FILE)) < 0 ||
	    (error = cb(repo, path.ptr, payload) != 0))
		goto out;

	if ((error = git_worktree_list(&worktrees, repo)) < 0) {
		error = 0;
		goto out;
	}

	/* Execute callback for all worktree HEADs */
	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;
	}

out:
2234
	git_buf_dispose(&path);
2235 2236 2237 2238
	git_strarray_free(&worktrees);
	return error;
}

2239
int git_repository_head_unborn(git_repository *repo)
2240
{
2241
	git_reference *ref = NULL;
2242 2243 2244
	int error;

	error = git_repository_head(&ref, repo);
2245
	git_reference_free(ref);
2246

2247 2248
	if (error == GIT_EUNBORNBRANCH) {
		giterr_clear();
2249
		return 1;
2250
	}
2251

2252 2253 2254 2255
	if (error < 0)
		return -1;

	return 0;
2256
}
2257

2258
static int at_least_one_cb(const char *refname, void *payload)
2259
{
2260 2261
	GIT_UNUSED(refname);
	GIT_UNUSED(payload);
2262
	return GIT_PASSTHROUGH;
2263
}
2264

2265 2266
static int repo_contains_no_reference(git_repository *repo)
{
2267
	int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
2268

2269
	if (error == GIT_PASSTHROUGH)
2270
		return 0;
2271

2272 2273
	if (!error)
		return 1;
2274

2275
	return error;
2276
}
2277

2278 2279 2280
int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL;
2281
	int is_empty = 0;
2282

2283
	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0)
2284 2285
		return -1;

2286 2287 2288 2289 2290
	if (git_reference_type(head) == GIT_REF_SYMBOLIC)
		is_empty =
			(strcmp(git_reference_symbolic_target(head),
					GIT_REFS_HEADS_DIR "master") == 0) &&
			repo_contains_no_reference(repo);
2291 2292

	git_reference_free(head);
2293 2294

	return is_empty;
2295 2296
}

2297
int git_repository_item_path(git_buf *out, const git_repository *repo, git_repository_item_t item)
2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311
{
	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:
2312
			giterr_set(GITERR_INVALID, "invalid item directory");
2313 2314 2315 2316
			return -1;
	}

	if (parent == NULL) {
2317
		giterr_set(GITERR_INVALID, "path cannot exist in repository");
2318
		return GIT_ENOTFOUND;
2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
	}

	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;
}

2337
const char *git_repository_path(const git_repository *repo)
2338 2339
{
	assert(repo);
2340
	return repo->gitdir;
2341
}
2342

2343
const char *git_repository_workdir(const git_repository *repo)
2344 2345
{
	assert(repo);
2346

2347 2348
	if (repo->is_bare)
		return NULL;
2349

2350 2351
	return repo->workdir;
}
2352

2353
const char *git_repository_commondir(const git_repository *repo)
2354 2355 2356 2357 2358
{
	assert(repo);
	return repo->commondir;
}

2359 2360
int git_repository_set_workdir(
	git_repository *repo, const char *workdir, int update_gitlink)
2361
{
2362
	int error = 0;
2363 2364
	git_buf path = GIT_BUF_INIT;

2365
	assert(repo && workdir);
2366

2367 2368
	if (git_path_prettify_dir(&path, workdir, NULL) < 0)
		return -1;
2369

2370 2371
	if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
		return 0;
2372

2373 2374 2375 2376 2377 2378
	if (update_gitlink) {
		git_config *config;

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

2379
		error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);
2380 2381 2382

		/* passthrough error means gitlink is unnecessary */
		if (error == GIT_PASSTHROUGH)
Ben Straub committed
2383
			error = git_config_delete_entry(config, "core.worktree");
2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400
		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;
2401
}
2402

2403
int git_repository_is_bare(const git_repository *repo)
2404 2405 2406 2407
{
	assert(repo);
	return repo->is_bare;
}
2408

2409
int git_repository_is_worktree(const git_repository *repo)
2410 2411 2412 2413 2414
{
	assert(repo);
	return repo->is_worktree;
}

2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
int git_repository_set_bare(git_repository *repo)
{
	int error;
	git_config *config;

	assert(repo);

	if (repo->is_bare)
		return 0;

2425 2426 2427
	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
		return error;

2428
	if ((error = git_config_set_bool(config, "core.bare", true)) < 0)
2429
		return error;
2430

2431 2432
	if ((error = git_config__update_entry(config, "core.worktree", NULL, true, true)) < 0)
		return error;
2433 2434 2435 2436 2437

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

2438
	return 0;
2439 2440
}

2441 2442
int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
2443 2444 2445
	git_reference *head;
	git_object *obj;
	int error;
2446

2447 2448
	if ((error = git_repository_head(&head, repo)) < 0)
		return error;
2449

2450 2451
	if ((error = git_reference_peel(&obj, head, GIT_OBJ_TREE)) < 0)
		goto cleanup;
2452 2453

	*tree = (git_tree *)obj;
2454 2455 2456 2457

cleanup:
	git_reference_free(head);
	return error;
2458
}
2459

2460 2461 2462 2463 2464 2465 2466 2467 2468
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);

2469
	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 &&
2470 2471 2472 2473 2474 2475 2476
		(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);

2477
	git_buf_dispose(&file_path);
2478 2479 2480 2481

	return error;
}

2482
int git_repository_message(git_buf *out, git_repository *repo)
2483
{
2484
	git_buf path = GIT_BUF_INIT;
Vicent Marti committed
2485 2486
	struct stat st;
	int error;
2487

2488
	git_buf_sanitize(out);
2489

2490
	if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
2491
		return -1;
2492

2493
	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
2494 2495
		if (errno == ENOENT)
			error = GIT_ENOTFOUND;
2496
		giterr_set(GITERR_OS, "could not access message file");
2497 2498
	} else {
		error = git_futils_readbuffer(out, git_buf_cstr(&path));
Vicent Marti committed
2499
	}
2500

2501
	git_buf_dispose(&path);
2502 2503

	return error;
2504 2505 2506 2507
}

int git_repository_message_remove(git_repository *repo)
{
Vicent Marti committed
2508 2509
	git_buf path = GIT_BUF_INIT;
	int error;
2510

2511
	if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
2512
		return -1;
2513 2514

	error = p_unlink(git_buf_cstr(&path));
2515
	git_buf_dispose(&path);
2516 2517 2518

	return error;
}
2519 2520

int git_repository_hashfile(
Linquize committed
2521 2522 2523 2524 2525
	git_oid *out,
	git_repository *repo,
	const char *path,
	git_otype type,
	const char *as_path)
2526 2527
{
	int error;
2528
	git_filter_list *fl = NULL;
2529
	git_file fd = -1;
2530 2531 2532
	git_off_t len;
	git_buf full_path = GIT_BUF_INIT;

2533 2534 2535 2536 2537 2538
	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.
	 */
2539 2540

	error = git_path_join_unrooted(
2541
		&full_path, path, git_repository_workdir(repo), NULL);
2542 2543 2544 2545 2546 2547 2548 2549
	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
2550
		error = git_filter_list_load(
2551
			&fl, repo, NULL, as_path,
2552
			GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);
2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568
		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) {
2569
		error = (int)len;
2570 2571 2572 2573
		goto cleanup;
	}

	if (!git__is_sizet(len)) {
2574
		giterr_set(GITERR_OS, "file size overflow for 32-bit systems");
2575 2576 2577 2578
		error = -1;
		goto cleanup;
	}

2579
	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
2580 2581

cleanup:
2582 2583
	if (fd >= 0)
		p_close(fd);
2584
	git_filter_list_free(fl);
2585
	git_buf_dispose(&full_path);
2586 2587 2588 2589

	return error;
}

2590
static int checkout_message(git_buf *out, git_reference *old, const char *new)
2591
{
2592 2593 2594 2595 2596 2597 2598 2599 2600
	git_buf_puts(out, "checkout: moving from ");

	if (git_reference_type(old) == GIT_REF_SYMBOLIC)
		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 ");

2601 2602 2603
	if (git_reference__is_branch(new) ||
		git_reference__is_tag(new) ||
		git_reference__is_remote(new))
2604 2605 2606 2607 2608 2609 2610 2611
		git_buf_puts(out, git_reference__shorthand(new));
	else
		git_buf_puts(out, new);

	if (git_buf_oom(out))
		return -1;

	return 0;
2612 2613
}

2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640
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;

	if ((error = git_object_lookup(&object, repo, id, GIT_OBJ_ANY)) < 0)
		goto cleanup;

	if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
		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:
2641
	git_buf_dispose(&log_message);
2642 2643 2644 2645 2646 2647 2648
	git_object_free(object);
	git_object_free(peeled);
	git_reference_free(current);
	git_reference_free(new_head);
	return error;
}

2649 2650
int git_repository_set_head(
	git_repository* repo,
2651
	const char* refname)
2652
{
2653 2654
	git_reference *ref = NULL, *current = NULL, *new_head = NULL;
	git_buf log_message = GIT_BUF_INIT;
2655 2656 2657 2658
	int error;

	assert(repo && refname);

2659 2660 2661 2662 2663 2664
	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
		return error;

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

2665 2666
	error = git_reference_lookup(&ref, repo, refname);
	if (error < 0 && error != GIT_ENOTFOUND)
2667
		goto cleanup;
2668

2669 2670
	if (ref && current->type == GIT_REF_SYMBOLIC && git__strcmp(current->target.symbolic, ref->name) &&
	    git_reference_is_branch(ref) && git_branch_is_checked_out(ref)) {
2671 2672
		giterr_set(GITERR_REPOSITORY, "cannot set HEAD to reference '%s' as it is the current HEAD "
			"of a linked repository.", git_reference_name(ref));
2673 2674 2675 2676
		error = -1;
		goto cleanup;
	}

2677
	if (!error) {
2678 2679
		if (git_reference_is_branch(ref)) {
			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
2680
					git_reference_name(ref), true, git_buf_cstr(&log_message));
2681
		} else {
2682
			error = detach(repo, git_reference_target(ref),
2683
				git_reference_is_tag(ref) || git_reference_is_remote(ref) ? refname : NULL);
2684
		}
2685
	} else if (git_reference__is_branch(refname)) {
2686
		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
2687
				true, git_buf_cstr(&log_message));
2688
	}
2689

2690
cleanup:
2691
	git_buf_dispose(&log_message);
2692
	git_reference_free(current);
2693 2694 2695 2696 2697
	git_reference_free(ref);
	git_reference_free(new_head);
	return error;
}

2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710
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);

2711
	return detach(repo, git_annotated_commit_id(commitish), commitish->description);
2712 2713
}

2714
int git_repository_detach_head(git_repository* repo)
2715
{
2716
	git_reference *old_head = NULL,	*new_head = NULL, *current = NULL;
2717
	git_object *object = NULL;
2718
	git_buf log_message = GIT_BUF_INIT;
2719
	int error;
2720 2721 2722

	assert(repo);

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

2726 2727 2728
	if ((error = git_repository_head(&old_head, repo)) < 0)
		goto cleanup;

2729
	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
2730 2731
		goto cleanup;

2732 2733 2734
	if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
		goto cleanup;

2735
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
2736
			1, git_buf_cstr(&log_message));
2737 2738

cleanup:
2739
	git_buf_dispose(&log_message);
2740 2741 2742
	git_object_free(object);
	git_reference_free(old_head);
	git_reference_free(new_head);
2743
	git_reference_free(current);
2744 2745
	return error;
}
Edward Thomson committed
2746

2747 2748 2749 2750
/**
 * Loosely ported from git.git
 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
 */
Edward Thomson committed
2751 2752 2753 2754 2755 2756 2757
int git_repository_state(git_repository *repo)
{
	git_buf repo_path = GIT_BUF_INIT;
	int state = GIT_REPOSITORY_STATE_NONE;

	assert(repo);

2758
	if (git_buf_puts(&repo_path, repo->gitdir) < 0)
Edward Thomson committed
2759 2760
		return -1;

2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
	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
2772
		state = GIT_REPOSITORY_STATE_MERGE;
2773
	else if (git_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE)) {
Edward Thomson committed
2774
		state = GIT_REPOSITORY_STATE_REVERT;
2775 2776 2777 2778
		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)) {
2779
		state = GIT_REPOSITORY_STATE_CHERRYPICK;
2780 2781 2782 2783
		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))
2784
		state = GIT_REPOSITORY_STATE_BISECT;
Edward Thomson committed
2785

2786
	git_buf_dispose(&repo_path);
Edward Thomson committed
2787 2788
	return state;
}
Ben Straub committed
2789

2790 2791
int git_repository__cleanup_files(
	git_repository *repo, const char *files[], size_t files_len)
2792
{
2793
	git_buf buf = GIT_BUF_INIT;
2794
	size_t i;
2795
	int error;
2796

2797 2798
	for (error = 0, i = 0; !error && i < files_len; ++i) {
		const char *path;
2799

2800
		if (git_buf_joinpath(&buf, repo->gitdir, files[i]) < 0)
2801
			return -1;
2802

2803 2804 2805 2806 2807 2808 2809 2810
		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);
		}
2811

2812 2813
		git_buf_clear(&buf);
	}
2814

2815
	git_buf_dispose(&buf);
2816 2817 2818 2819 2820 2821 2822 2823
	return error;
}

static const char *state_files[] = {
	GIT_MERGE_HEAD_FILE,
	GIT_MERGE_MODE_FILE,
	GIT_MERGE_MSG_FILE,
	GIT_REVERT_HEAD_FILE,
2824
	GIT_CHERRYPICK_HEAD_FILE,
2825 2826 2827
	GIT_BISECT_LOG_FILE,
	GIT_REBASE_MERGE_DIR,
	GIT_REBASE_APPLY_DIR,
2828
	GIT_SEQUENCER_DIR,
2829 2830 2831 2832 2833 2834 2835 2836 2837
};

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
2838 2839 2840 2841
int git_repository_is_shallow(git_repository *repo)
{
	git_buf path = GIT_BUF_INIT;
	struct stat st;
Ben Straub committed
2842
	int error;
Ben Straub committed
2843

2844
	if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0)
2845 2846
		return error;

Ben Straub committed
2847
	error = git_path_lstat(path.ptr, &st);
2848
	git_buf_dispose(&path);
Ben Straub committed
2849

2850 2851
	if (error == GIT_ENOTFOUND) {
		giterr_clear();
Ben Straub committed
2852
		return 0;
2853 2854
	}

Ben Straub committed
2855 2856 2857
	if (error < 0)
		return error;
	return st.st_size == 0 ? 0 : 1;
Ben Straub committed
2858
}
2859

2860 2861
int git_repository_init_init_options(
	git_repository_init_options *opts, unsigned int version)
2862
{
2863 2864 2865 2866
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_repository_init_options,
		GIT_REPOSITORY_INIT_OPTIONS_INIT);
	return 0;
2867
}
2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898

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);
		GITERR_CHECK_ALLOC(tmp_name);
	}

	if (email) {
		tmp_email = git__strdup(email);
		GITERR_CHECK_ALLOC(tmp_email);
	}

	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;
}
2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926

int git_repository_submodule_cache_all(git_repository *repo)
{
	int error;

	assert(repo);

	if ((error = git_strmap_alloc(&repo->submodule_cache)))
		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;
}