repository.c 47.2 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
#include <ctype.h>
8

9
#include "git2/object.h"
10
#include "git2/refdb.h"
11
#include "git2/sys/repository.h"
12

13 14 15 16
#include "common.h"
#include "repository.h"
#include "commit.h"
#include "tag.h"
17
#include "blob.h"
18
#include "fileops.h"
19
#include "sysdir.h"
20 21
#include "filebuf.h"
#include "index.h"
22
#include "config.h"
23
#include "refs.h"
24 25
#include "filter.h"
#include "odb.h"
26
#include "remote.h"
Edward Thomson committed
27
#include "merge.h"
28
#include "diff_driver.h"
29

30 31 32 33
#ifdef GIT_WIN32
# include "win32/w32_util.h"
#endif

34
#define GIT_FILE_CONTENT_PREFIX "gitdir:"
35

36 37
#define GIT_BRANCH_MASTER "master"

38
#define GIT_REPO_VERSION 0
39

40
static void set_odb(git_repository *repo, git_odb *odb)
41
{
42 43 44 45 46 47 48 49
	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);
50
	}
51
}
52

53
static void set_refdb(git_repository *repo, git_refdb *refdb)
54
{
55 56 57 58 59 60 61 62
	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);
63 64 65
	}
}

66
static void set_config(git_repository *repo, git_config *config)
67
{
68 69 70 71 72 73 74 75
	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);
76
	}
77 78

	git_repository__cvar_cache_clear(repo);
79 80
}

81
static void set_index(git_repository *repo, git_index *index)
82
{
83 84 85 86 87 88 89 90
	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);
91
	}
92 93
}

94
void git_repository__cleanup(git_repository *repo)
95
{
96
	assert(repo);
97

98
	git_cache_clear(&repo->objects);
99
	git_attr_cache_flush(repo);
100
	git_submodule_cache_free(repo);
101

102 103 104 105
	set_config(repo, NULL);
	set_index(repo, NULL);
	set_odb(repo, NULL);
	set_refdb(repo, NULL);
106 107 108 109 110 111 112 113 114 115
}

void git_repository_free(git_repository *repo)
{
	if (repo == NULL)
		return;

	git_repository__cleanup(repo);

	git_cache_free(&repo->objects);
116

117
	git_diff_driver_registry_free(repo->diff_drivers);
118
	repo->diff_drivers = NULL;
119

Russell Belfer committed
120 121
	git__free(repo->path_repository);
	git__free(repo->workdir);
Vicent Marti committed
122
	git__free(repo->namespace);
Russell Belfer committed
123

124
	git__memzero(repo, sizeof(*repo));
125
	git__free(repo);
126 127
}

128 129 130 131 132
/*
 * Git repository open methods
 *
 * Open a repository object from its path
 */
133
static bool valid_repository_path(git_buf *repository_path)
134
{
135
	/* Check OBJECTS_DIR first, since it will generate the longest path name */
136
	if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR) == false)
137
		return false;
138

139
	/* Ensure HEAD file exists */
140
	if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)
141
		return false;
142

143
	if (git_path_contains_dir(repository_path, GIT_REFS_DIR)  == false)
144
		return false;
145

146
	return true;
147 148
}

149
static git_repository *repository_alloc(void)
150
{
151
	git_repository *repo = git__calloc(1, sizeof(git_repository));
152 153 154
	if (!repo)
		return NULL;

155
	if (git_cache_init(&repo->objects) < 0) {
156
		git__free(repo);
157 158
		return NULL;
	}
159

160 161 162
	/* set all the entries in the cvar cache to `unset` */
	git_repository__cvar_cache_clear(repo);

163 164 165
	return repo;
}

166 167 168 169 170 171
int git_repository_new(git_repository **out)
{
	*out = repository_alloc();
	return 0;
}

172
static int load_config_data(git_repository *repo, const git_config *config)
173
{
174
	int is_bare;
175

176
	/* Try to figure out if it's bare, default to non-bare if it's not set */
177
	if (git_config_get_bool(&is_bare, config, "core.bare") < 0)
178 179 180
		repo->is_bare = 0;
	else
		repo->is_bare = is_bare;
181

182
	return 0;
183
}
184

185
static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)
186
{
187
	int         error;
188 189
	const git_config_entry *ce;
	git_buf     worktree = GIT_BUF_INIT;
190

191
	if (repo->is_bare)
192
		return 0;
193

194 195 196
	if ((error = git_config__lookup_entry(
			&ce, config, "core.worktree", false)) < 0)
		return error;
197

198 199 200
	if (ce && ce->value) {
		if ((error = git_path_prettify_dir(
				&worktree, ce->value, repo->path_repository)) < 0)
201
			return error;
202 203

		repo->workdir = git_buf_detach(&worktree);
204
	}
205 206
	else if (parent_path && git_path_isdir(parent_path->ptr))
		repo->workdir = git_buf_detach(parent_path);
207
	else {
208 209 210 211 212
		if (git_path_dirname_r(&worktree, repo->path_repository) < 0 ||
			git_path_to_dir(&worktree) < 0)
			return -1;

		repo->workdir = git_buf_detach(&worktree);
213 214 215
	}

	GITERR_CHECK_ALLOC(repo->workdir);
216
	return 0;
217 218
}

219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
/*
 * 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.
 */
static int find_ceiling_dir_offset(
	const char *path,
	const char *ceiling_directories)
{
	char buf[GIT_PATH_MAX + 1];
	char buf2[GIT_PATH_MAX + 1];
	const char *ceil, *sep;
234
	size_t len, max_len = 0, min_len;
235 236 237

	assert(path);

238
	min_len = (size_t)(git_path_root(path) + 1);
239 240

	if (ceiling_directories == NULL || min_len == 0)
241
		return (int)min_len;
242 243 244 245 246

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

247
		if (len == 0 || len >= sizeof(buf) || git_path_root(ceil) == -1)
248 249 250 251 252 253 254 255 256 257 258 259 260
			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) &&
261
			(path[len] == '/' || !path[len]) &&
262 263 264 265 266 267
			len > max_len)
		{
			max_len = len;
		}
	}

268
	return (int)(max_len <= min_len ? min_len : max_len);
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
}

/*
 * 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);
288 289
	/* apparently on Windows, some people use backslashes in paths */
	git_path_mkposix(file.ptr);
290

291 292
	if (git_buf_len(&file) <= prefix_len ||
		memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
293
	{
294 295
		giterr_set(GITERR_REPOSITORY,
			"The `.git` file at '%s' is malformed", file_path);
296 297 298
		error = -1;
	}
	else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
299
		const char *gitlink = git_buf_cstr(&file) + prefix_len;
300
		while (*gitlink && git__isspace(*gitlink)) gitlink++;
301

302 303
		error = git_path_prettify_dir(
			path_out, gitlink, git_buf_cstr(path_out));
304 305 306 307 308 309 310 311 312 313 314 315
	}

	git_buf_free(&file);
	return error;
}

static int find_repo(
	git_buf *repo_path,
	git_buf *parent_path,
	const char *start_path,
	uint32_t flags,
	const char *ceiling_dirs)
316
{
317 318 319 320
	int error;
	git_buf path = GIT_BUF_INIT;
	struct stat st;
	dev_t initial_device = 0;
321
	bool try_with_dot_git = ((flags & GIT_REPOSITORY_OPEN_BARE) != 0);
322 323 324 325
	int ceiling_offset;

	git_buf_free(repo_path);

326
	if ((error = git_path_prettify(&path, start_path, NULL)) < 0)
327 328 329 330
		return error;

	ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);

331 332
	if (!try_with_dot_git &&
		(error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0)
333 334
		return error;

nulltoken committed
335
	while (!error && !git_buf_len(repo_path)) {
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
		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 &&
				(flags & GIT_REPOSITORY_OPEN_CROSS_FS) == 0)
				break;

			if (S_ISDIR(st.st_mode)) {
				if (valid_repository_path(&path)) {
					git_path_to_dir(&path);
					git_buf_set(repo_path, path.ptr, path.size);
					break;
				}
			}
			else if (S_ISREG(st.st_mode)) {
				git_buf repo_link = GIT_BUF_INIT;

				if (!(error = read_gitfile(&repo_link, path.ptr))) {
					if (valid_repository_path(&repo_link))
						git_buf_swap(repo_path, &repo_link);
357 358

					git_buf_free(&repo_link);
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
					break;
				}
				git_buf_free(&repo_link);
			}
		}

		/* move up one directory level */
		if (git_path_dirname_r(&path, path.ptr) < 0) {
			error = -1;
			break;
		}

		if (try_with_dot_git) {
			/* if we tried original dir with and without .git AND either hit
			 * directory ceiling or NO_SEARCH was requested, then be done.
			 */
			if (path.ptr[ceiling_offset] == '\0' ||
				(flags & GIT_REPOSITORY_OPEN_NO_SEARCH) != 0)
				break;
			/* otherwise look first for .git item */
			error = git_buf_joinpath(&path, path.ptr, DOT_GIT);
		}
		try_with_dot_git = !try_with_dot_git;
	}

384
	if (!error && parent_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
nulltoken committed
385
		if (!git_buf_len(repo_path))
386 387 388 389 390 391 392 393 394 395 396
			git_buf_clear(parent_path);
		else {
			git_path_dirname_r(parent_path, path.ptr);
			git_path_to_dir(parent_path);
		}
		if (git_buf_oom(parent_path))
			return -1;
	}

	git_buf_free(&path);

nulltoken committed
397
	if (!git_buf_len(repo_path) && !error) {
398
		giterr_set(GITERR_REPOSITORY,
399
			"Could not find repository from '%s'", start_path);
400
		error = GIT_ENOTFOUND;
401
	}
402

403 404 405
	return error;
}

406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
int git_repository_open_bare(
	git_repository **repo_ptr,
	const char *bare_path)
{
	int error;
	git_buf path = GIT_BUF_INIT;
	git_repository *repo = NULL;

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

	if (!valid_repository_path(&path)) {
		git_buf_free(&path);
		giterr_set(GITERR_REPOSITORY, "Path is not a repository: %s", bare_path);
		return GIT_ENOTFOUND;
	}

	repo = repository_alloc();
	GITERR_CHECK_ALLOC(repo);

	repo->path_repository = git_buf_detach(&path);
	GITERR_CHECK_ALLOC(repo->path_repository);

	/* of course we're bare! */
	repo->is_bare = 1;
	repo->workdir = NULL;

	*repo_ptr = repo;
	return 0;
}

437 438 439
int git_repository_open_ext(
	git_repository **repo_ptr,
	const char *start_path,
440
	unsigned int flags,
441 442 443 444 445 446
	const char *ceiling_dirs)
{
	int error;
	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT;
	git_repository *repo;

447 448
	if (repo_ptr)
		*repo_ptr = NULL;
449

450 451
	error = find_repo(&path, &parent, start_path, flags, ceiling_dirs);
	if (error < 0 || !repo_ptr)
452 453
		return error;

454
	repo = repository_alloc();
455
	GITERR_CHECK_ALLOC(repo);
456

457
	repo->path_repository = git_buf_detach(&path);
458
	GITERR_CHECK_ALLOC(repo->path_repository);
459

460 461
	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
		repo->is_bare = 1;
462 463 464 465 466 467 468 469
	else {
		git_config *config = NULL;

		if ((error = git_repository_config_snapshot(&config, repo)) < 0 ||
			(error = load_config_data(repo, config)) < 0 ||
			(error = load_workdir(repo, config, &parent)) < 0)
			git_repository_free(repo);

470
		git_config_free(config);
471
	}
472

473 474
	if (!error)
		*repo_ptr = repo;
475
	git_buf_free(&parent);
476 477

	return error;
478
}
479

480 481 482 483 484 485
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);
}

486 487 488 489 490 491 492 493 494 495 496 497 498
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;
}

499
int git_repository_discover(
500
	git_buf *out,
501 502 503 504 505 506
	const char *start_path,
	int across_fs,
	const char *ceiling_dirs)
{
	uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;

507
	assert(start_path);
508

509
	git_buf_sanitize(out);
510

511
	return find_repo(out, NULL, start_path, flags, ceiling_dirs);
512 513
}

514
static int load_config(
515 516 517
	git_config **out,
	git_repository *repo,
	const char *global_config_path,
Sven Strickroth committed
518
	const char *xdg_config_path,
519
	const char *system_config_path)
520
{
521
	int error;
522
	git_buf config_path = GIT_BUF_INIT;
523
	git_config *cfg = NULL;
524

525
	assert(repo && out);
526

527 528
	if ((error = git_config_new(&cfg)) < 0)
		return error;
529

530 531 532
	error = git_buf_joinpath(
		&config_path, repo->path_repository, GIT_CONFIG_FILENAME_INREPO);
	if (error < 0)
533
		goto on_error;
534

535 536 537
	if ((error = git_config_add_file_ondisk(
			cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, 0)) < 0 &&
		error != GIT_ENOTFOUND)
538 539 540
		goto on_error;

	git_buf_free(&config_path);
541

542 543 544 545 546
	if (global_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, global_config_path, GIT_CONFIG_LEVEL_GLOBAL, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;
547

548 549 550 551 552
	if (xdg_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, xdg_config_path, GIT_CONFIG_LEVEL_XDG, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;
553

554 555 556 557 558
	if (system_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, system_config_path, GIT_CONFIG_LEVEL_SYSTEM, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;
559

560 561
	giterr_clear(); /* clear any lingering ENOTFOUND errors */

562
	*out = cfg;
563
	return 0;
564

565 566
on_error:
	git_buf_free(&config_path);
567 568
	git_config_free(cfg);
	*out = NULL;
569
	return error;
570 571
}

Russell Belfer committed
572
static const char *path_unless_empty(git_buf *buf)
573
{
Russell Belfer committed
574 575
	return git_buf_len(buf) > 0 ? git_buf_cstr(buf) : NULL;
}
576

Russell Belfer committed
577 578 579
int git_repository_config__weakptr(git_config **out, git_repository *repo)
{
	int error = 0;
580

Russell Belfer committed
581 582 583 584 585 586
	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;
		git_config *config;

587 588 589
		git_config_find_global(&global_buf);
		git_config_find_xdg(&xdg_buf);
		git_config_find_system(&system_buf);
Russell Belfer committed
590

591 592 593 594
		/* 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
595 596 597 598 599 600 601 602
		error = load_config(
			&config, repo,
			path_unless_empty(&global_buf),
			path_unless_empty(&xdg_buf),
			path_unless_empty(&system_buf));
		if (!error) {
			GIT_REFCOUNT_OWN(config, repo);

603
			config = git__compare_and_swap(&repo->_config, NULL, config);
Russell Belfer committed
604 605 606 607 608
			if (config != NULL) {
				GIT_REFCOUNT_OWN(config, NULL);
				git_config_free(config);
			}
		}
609 610

		git_buf_free(&global_buf);
611
		git_buf_free(&xdg_buf);
612
		git_buf_free(&system_buf);
613
	}
614

615
	*out = repo->_config;
Russell Belfer committed
616
	return error;
617 618
}

619
int git_repository_config(git_config **out, git_repository *repo)
620
{
621 622
	if (git_repository_config__weakptr(out, repo) < 0)
		return -1;
623

624 625
	GIT_REFCOUNT_INC(*out);
	return 0;
626 627
}

628 629
int git_repository_config_snapshot(git_config **out, git_repository *repo)
{
630
	int error;
631 632
	git_config *weak;

633 634
	if ((error = git_repository_config__weakptr(&weak, repo)) < 0)
		return error;
635 636 637 638

	return git_config_snapshot(out, weak);
}

639 640 641
void git_repository_set_config(git_repository *repo, git_config *config)
{
	assert(repo && config);
642
	set_config(repo, config);
643 644 645 646
}

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

649 650 651
	assert(repo && out);

	if (repo->_odb == NULL) {
652
		git_buf odb_path = GIT_BUF_INIT;
Russell Belfer committed
653
		git_odb *odb;
654

Russell Belfer committed
655
		git_buf_joinpath(&odb_path, repo->path_repository, GIT_OBJECTS_DIR);
656

Russell Belfer committed
657 658 659
		error = git_odb_open(&odb, odb_path.ptr);
		if (!error) {
			GIT_REFCOUNT_OWN(odb, repo);
660

661
			odb = git__compare_and_swap(&repo->_odb, NULL, odb);
Russell Belfer committed
662 663 664 665 666
			if (odb != NULL) {
				GIT_REFCOUNT_OWN(odb, NULL);
				git_odb_free(odb);
			}
		}
667

Russell Belfer committed
668
		git_buf_free(&odb_path);
669
	}
670

671
	*out = repo->_odb;
Russell Belfer committed
672
	return error;
673 674
}

675
int git_repository_odb(git_odb **out, git_repository *repo)
676
{
677 678
	if (git_repository_odb__weakptr(out, repo) < 0)
		return -1;
Vicent Marti committed
679

680 681
	GIT_REFCOUNT_INC(*out);
	return 0;
682
}
683

684 685 686
void git_repository_set_odb(git_repository *repo, git_odb *odb)
{
	assert(repo && odb);
687
	set_odb(repo, odb);
688 689
}

690 691
int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo)
{
Russell Belfer committed
692 693
	int error = 0;

694 695 696
	assert(out && repo);

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

Russell Belfer committed
699 700 701
		error = git_refdb_open(&refdb, repo);
		if (!error) {
			GIT_REFCOUNT_OWN(refdb, repo);
702

703
			refdb = git__compare_and_swap(&repo->_refdb, NULL, refdb);
Russell Belfer committed
704 705 706 707 708
			if (refdb != NULL) {
				GIT_REFCOUNT_OWN(refdb, NULL);
				git_refdb_free(refdb);
			}
		}
709 710 711
	}

	*out = repo->_refdb;
Russell Belfer committed
712
	return error;
713 714 715 716 717 718 719 720 721 722 723 724 725
}

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
726
	assert(repo && refdb);
727
	set_refdb(repo, refdb);
728 729
}

730 731
int git_repository_index__weakptr(git_index **out, git_repository *repo)
{
Russell Belfer committed
732 733
	int error = 0;

734 735 736
	assert(out && repo);

	if (repo->_index == NULL) {
737
		git_buf index_path = GIT_BUF_INIT;
Russell Belfer committed
738
		git_index *index;
739

Russell Belfer committed
740
		git_buf_joinpath(&index_path, repo->path_repository, GIT_INDEX_FILE);
741

Russell Belfer committed
742 743 744
		error = git_index_open(&index, index_path.ptr);
		if (!error) {
			GIT_REFCOUNT_OWN(index, repo);
745

746
			index = git__compare_and_swap(&repo->_index, NULL, index);
Russell Belfer committed
747 748 749 750
			if (index != NULL) {
				GIT_REFCOUNT_OWN(index, NULL);
				git_index_free(index);
			}
751

Russell Belfer committed
752 753
			error = git_index_set_caps(repo->_index, GIT_INDEXCAP_FROM_OWNER);
		}
754

Russell Belfer committed
755
		git_buf_free(&index_path);
756 757 758
	}

	*out = repo->_index;
Russell Belfer committed
759
	return error;
760
}
Vicent Marti committed
761

762 763
int git_repository_index(git_index **out, git_repository *repo)
{
764 765
	if (git_repository_index__weakptr(out, repo) < 0)
		return -1;
766

767 768
	GIT_REFCOUNT_INC(*out);
	return 0;
769 770
}

771 772 773
void git_repository_set_index(git_repository *repo, git_index *index)
{
	assert(repo && index);
774
	set_index(repo, index);
775 776
}

Vicent Marti committed
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
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;
}

794
static int check_repositoryformatversion(git_config *config)
795
{
796
	int version;
797

798
	if (git_config_get_int32(&version, config, "core.repositoryformatversion") < 0)
799
		return -1;
800

801
	if (GIT_REPO_VERSION < version) {
802 803
		giterr_set(GITERR_REPOSITORY,
			"Unsupported repository version %d. Only versions up to %d are supported.",
804
			version, GIT_REPO_VERSION);
805 806
		return -1;
	}
807

808
	return 0;
809 810
}

811
static int repo_init_create_head(const char *git_dir, const char *ref_name)
812
{
813
	git_buf ref_path = GIT_BUF_INIT;
814
	git_filebuf ref = GIT_FILEBUF_INIT;
815
	const char *fmt;
816

817
	if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 ||
818
		git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE) < 0)
819 820 821 822 823
		goto fail;

	if (!ref_name)
		ref_name = GIT_BRANCH_MASTER;

824
	if (git__prefixcmp(ref_name, GIT_REFS_DIR) == 0)
825 826
		fmt = "ref: %s\n";
	else
827
		fmt = "ref: " GIT_REFS_HEADS_DIR "%s\n";
828 829

	if (git_filebuf_printf(&ref, fmt, ref_name) < 0 ||
830
		git_filebuf_commit(&ref) < 0)
831
		goto fail;
832

833
	git_buf_free(&ref_path);
834
	return 0;
835 836 837 838 839

fail:
	git_buf_free(&ref_path);
	git_filebuf_cleanup(&ref);
	return -1;
840 841
}

842 843 844 845 846 847 848 849 850 851 852 853 854
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;

855
	return (st1.st_mode != st2.st_mode);
856 857
}

858 859 860
static bool is_filesystem_case_insensitive(const char *gitdir_path)
{
	git_buf path = GIT_BUF_INIT;
861
	int is_insensitive = -1;
862

863 864
	if (!git_buf_joinpath(&path, gitdir_path, "CoNfIg"))
		is_insensitive = git_path_exists(git_buf_cstr(&path));
865 866

	git_buf_free(&path);
867
	return is_insensitive;
868 869
}

870 871 872 873 874
static bool are_symlinks_supported(const char *wd_path)
{
	git_buf path = GIT_BUF_INIT;
	int fd;
	struct stat st;
875
	int symlinks_supported = -1;
876

877
	if ((fd = git_futils_mktmp(&path, wd_path, 0666)) < 0 ||
878 879 880 881
		p_close(fd) < 0 ||
		p_unlink(path.ptr) < 0 ||
		p_symlink("testing", path.ptr) < 0 ||
		p_lstat(path.ptr, &st) < 0)
882
		symlinks_supported = false;
883
	else
884
		symlinks_supported = (S_ISLNK(st.st_mode) != 0);
885 886 887 888

	(void)p_unlink(path.ptr);
	git_buf_free(&path);

889 890 891
	return symlinks_supported;
}

892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
static int create_empty_file(const char *path, mode_t mode)
{
	int fd;

	if ((fd = p_creat(path, mode)) < 0) {
		giterr_set(GITERR_OS, "Error while creating '%s'", path);
		return -1;
	}

	if (p_close(fd) < 0) {
		giterr_set(GITERR_OS, "Error while closing '%s'", path);
		return -1;
	}

	return 0;
}

909 910 911 912 913
static int repo_local_config(
	git_config **out,
	git_buf *config_dir,
	git_repository *repo,
	const char *repo_dir)
914
{
915
	int error = 0;
916 917
	git_config *parent;
	const char *cfg_path;
918

919
	if (git_buf_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
920
		return -1;
921
	cfg_path = git_buf_cstr(config_dir);
922

923
	/* make LOCAL config if missing */
924 925
	if (!git_path_isfile(cfg_path) &&
		(error = create_empty_file(cfg_path, GIT_CONFIG_FILE_MODE)) < 0)
926
		return error;
927

928 929 930 931 932 933 934 935 936
	/* 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) {
937 938 939 940
		giterr_clear();

		if (!(error = git_config_add_file_ondisk(
				parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, false)))
941
			error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
942
	}
943

944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
	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();
970

971 972 973 974 975 976 977
	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();
	}
978

979
#ifdef GIT_USE_ICONV
980 981
	if ((error = git_config_set_bool(
			cfg, "core.precomposeunicode",
982
			git_path_does_fs_decompose_unicode(work_dir))) < 0)
983
		return error;
984
	/* on non-iconv platforms, don't even set core.precomposeunicode */
985 986
#endif

987 988
	return 0;
}
989

990 991 992 993 994 995 996
static int repo_init_config(
	const char *repo_dir,
	const char *work_dir,
	uint32_t flags,
	uint32_t mode)
{
	int error = 0;
997
	git_buf cfg_path = GIT_BUF_INIT, worktree_path = GIT_BUF_INIT;
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
	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;
1018

1019 1020
	if (!is_bare) {
		SET_REPO_CONFIG(bool, "core.logallrefupdates", true);
1021

1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
		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
1032
			if (git_config_delete_entry(config, "core.worktree") < 0)
1033
				giterr_clear();
1034 1035 1036
		}
	}

1037
	if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
1038 1039
		SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
1040
	}
1041
	else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
1042 1043 1044
		SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
	}
1045

1046
cleanup:
1047
	git_buf_free(&cfg_path);
1048
	git_buf_free(&worktree_path);
1049
	git_config_free(config);
1050

1051
	return error;
1052
}
1053

1054
static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
1055
{
1056 1057
	git_repository *smrepo = NULL;
	GIT_UNUSED(n); GIT_UNUSED(p);
1058

1059
	if (git_submodule_open(&smrepo, sm) < 0 ||
1060
		git_repository_reinit_filesystem(smrepo, true) < 0)
1061 1062
		giterr_clear();
	git_repository_free(smrepo);
1063

1064 1065
	return 0;
}
1066

1067
int git_repository_reinit_filesystem(git_repository *repo, int recurse)
1068 1069 1070 1071 1072
{
	int error = 0;
	git_buf path = GIT_BUF_INIT;
	git_config *config = NULL;
	const char *repo_dir = git_repository_path(repo);
1073

1074 1075 1076
	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);
1077

1078 1079
	git_config_free(config);
	git_buf_free(&path);
1080 1081 1082

	git_repository__cvar_cache_clear(repo);

1083
	if (!repo->is_bare && recurse)
1084
		(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
1085

1086 1087 1088
	return error;
}

1089
static int repo_write_template(
1090 1091 1092 1093
	const char *git_dir,
	bool allow_overwrite,
	const char *file,
	mode_t mode,
1094
	bool hidden,
1095
	const char *content)
1096 1097
{
	git_buf path = GIT_BUF_INIT;
1098
	int fd, error = 0, flags;
1099 1100 1101 1102

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

1103 1104 1105 1106 1107 1108
	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);
1109

1110 1111
	if (fd >= 0) {
		error = p_write(fd, content, strlen(content));
1112

1113 1114 1115 1116
		p_close(fd);
	}
	else if (errno != EEXIST)
		error = fd;
1117

1118 1119
#ifdef GIT_WIN32
	if (!error && hidden) {
1120
		if (git_win32__sethidden(path.ptr) < 0)
1121 1122 1123 1124 1125 1126
			error = -1;
	}
#else
	GIT_UNUSED(hidden);
#endif

1127
	git_buf_free(&path);
1128 1129 1130 1131 1132 1133

	if (error)
		giterr_set(GITERR_OS,
			"Failed to initialize repository with template '%s'", file);

	return error;
1134 1135
}

1136
static int repo_write_gitlink(
1137
	const char *in_dir, const char *to_repo, bool use_relative_path)
1138
{
1139 1140
	int error;
	git_buf buf = GIT_BUF_INIT;
1141
	git_buf path_to_repo = GIT_BUF_INIT;
1142 1143 1144 1145 1146
	struct stat st;

	git_path_dirname_r(&buf, to_repo);
	git_path_to_dir(&buf);
	if (git_buf_oom(&buf))
1147
		return -1;
1148

1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
	/* don't write gitlink to natural workdir */
	if (git__suffixcmp(to_repo, "/" DOT_GIT "/") == 0 &&
		strcmp(in_dir, buf.ptr) == 0)
	{
		error = GIT_PASSTHROUGH;
		goto cleanup;
	}

	if ((error = git_buf_joinpath(&buf, in_dir, DOT_GIT)) < 0)
		goto cleanup;

	if (!p_stat(buf.ptr, &st) && !S_ISREG(st.st_mode)) {
		giterr_set(GITERR_REPOSITORY,
			"Cannot overwrite gitlink file into path '%s'", in_dir);
		error = GIT_EEXISTS;
		goto cleanup;
	}

	git_buf_clear(&buf);

1169 1170 1171 1172 1173 1174 1175
	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);
1176 1177

	if (!error)
1178
		error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
1179 1180 1181

cleanup:
	git_buf_free(&buf);
1182
	git_buf_free(&path_to_repo);
1183 1184 1185
	return error;
}

1186 1187 1188
static mode_t pick_dir_mode(git_repository_init_options *opts)
{
	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_UMASK)
1189
		return 0777;
1190 1191 1192 1193 1194 1195 1196
	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;
}

1197 1198 1199 1200 1201 1202 1203
#include "repo_template.h"

static int repo_init_structure(
	const char *repo_dir,
	const char *work_dir,
	git_repository_init_options *opts)
{
1204
	int error = 0;
1205
	repo_template_item *tpl;
1206 1207 1208
	bool external_tpl =
		((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
	mode_t dmode = pick_dir_mode(opts);
1209
	bool chmod = opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK;
1210 1211

	/* Hide the ".git" directory */
1212
#ifdef GIT_WIN32
1213
	if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
1214 1215
		if (git_win32__sethidden(repo_dir) < 0) {
			giterr_set(GITERR_OS,
1216 1217 1218
				"Failed to mark Git repository folder as hidden");
			return -1;
		}
1219
	}
1220 1221 1222 1223 1224 1225
#endif

	/* Create the .git gitlink if appropriate */
	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
		(opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0)
	{
1226
		if (repo_write_gitlink(work_dir, repo_dir, opts->flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK) < 0)
1227
			return -1;
1228
	}
1229

1230 1231
	/* Copy external template if requested */
	if (external_tpl) {
Linquize committed
1232 1233 1234
		git_config *cfg = NULL;
		const char *tdir = NULL;
		bool default_template = false;
1235 1236
		git_buf template_buf = GIT_BUF_INIT;

1237 1238
		if (opts->template_path)
			tdir = opts->template_path;
Linquize committed
1239
		else if ((error = git_config_open_default(&cfg)) >= 0) {
1240 1241
			error = git_config_get_string(&tdir, cfg, "init.templatedir");
			giterr_clear();
Linquize committed
1242 1243 1244
		}

		if (!tdir) {
1245
			if (!(error = git_sysdir_find_template_dir(&template_buf)))
1246
				tdir = template_buf.ptr;
Linquize committed
1247
			default_template = true;
1248
		}
1249

1250
		if (tdir) {
1251 1252 1253 1254
			uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS | GIT_CPDIR_SIMPLE_TO_MODE;
			if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
					cpflags |= GIT_CPDIR_CHMOD_DIRS;
			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
1255
		}
1256

Linquize committed
1257 1258
		git_buf_free(&template_buf);
		git_config_free(cfg);
1259

1260
		if (error < 0) {
Linquize committed
1261
			if (!default_template)
1262 1263 1264 1265 1266
				return error;

			/* if template was default, ignore error and use internal */
			giterr_clear();
			external_tpl = false;
1267
			error = 0;
1268 1269 1270 1271 1272 1273 1274 1275
		}
	}

	/* 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) {
1276
		if (!tpl->content) {
1277 1278 1279 1280 1281 1282
			uint32_t mkdir_flags = GIT_MKDIR_PATH;
			if (chmod)
				mkdir_flags |= GIT_MKDIR_CHMOD;

			error = git_futils_mkdir(
				tpl->path, repo_dir, dmode, mkdir_flags);
1283
		}
1284
		else if (!external_tpl) {
1285 1286 1287 1288 1289
			const char *content = tpl->content;

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

1290 1291
			error = repo_write_template(
				repo_dir, false, tpl->path, tpl->mode, false, content);
1292
		}
1293 1294
	}

1295
	return error;
1296 1297
}

1298 1299
static int mkdir_parent(git_buf *buf, uint32_t mode, bool skip2)
{
1300 1301 1302
	/* When making parent directories during repository initialization
	 * don't try to set gid or grant world write access
	 */
1303
	return git_futils_mkdir(
1304
		buf->ptr, NULL, mode & ~(S_ISGID | 0002),
1305 1306 1307 1308
		GIT_MKDIR_PATH | GIT_MKDIR_VERIFY_DIR |
		(skip2 ? GIT_MKDIR_SKIP_LAST2 : GIT_MKDIR_SKIP_LAST));
}

1309 1310 1311 1312 1313
static int repo_init_directories(
	git_buf *repo_path,
	git_buf *wd_path,
	const char *given_repo,
	git_repository_init_options *opts)
1314
{
1315
	int error = 0;
1316
	bool is_bare, add_dotgit, has_dotgit, natural_wd;
1317
	mode_t dirmode;
1318

1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338
	/* 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
	 */

1339
	/* set up repo path */
1340

1341 1342
	is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);

1343 1344
	add_dotgit =
		(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
1345
		!is_bare &&
1346 1347
		git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
		git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
1348

1349 1350
	if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
		return -1;
1351

1352 1353 1354 1355 1356 1357
	has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
	if (has_dotgit)
		opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;

	/* set up workdir path */

1358
	if (!is_bare) {
1359
		if (opts->workdir_path) {
1360 1361 1362
			if (git_path_join_unrooted(
					wd_path, opts->workdir_path, repo_path->ptr, NULL) < 0)
				return -1;
1363 1364 1365 1366 1367 1368 1369 1370
		} else if (has_dotgit) {
			if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
				return -1;
		} else {
			giterr_set(GITERR_REPOSITORY, "Cannot pick working directory"
				" for non-bare repository that isn't a '.git' directory");
			return -1;
		}
1371

1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
		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 */

1388
	dirmode = pick_dir_mode(opts);
1389

1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
	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(
				wd_path->ptr, NULL, dirmode & ~S_ISGID,
				GIT_MKDIR_VERIFY_DIR)) < 0)
			return error;

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

1420 1421 1422 1423
	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0 ||
		has_dotgit)
	{
1424
		/* create path #1 */
1425 1426
		error = git_futils_mkdir(repo_path->ptr, NULL, dirmode,
			GIT_MKDIR_VERIFY_DIR | ((dirmode & S_ISGID) ? GIT_MKDIR_CHMOD : 0));
1427
	}
1428

1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445
	/* 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
1446
	if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
1447 1448 1449 1450 1451 1452 1453 1454 1455
		git_remote_free(remote);
	}

	return error;
}

int git_repository_init(
	git_repository **repo_out, const char *path, unsigned is_bare)
{
1456
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
1457 1458 1459 1460 1461 1462 1463 1464 1465

	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(
1466
	git_repository **out,
1467 1468 1469 1470 1471 1472
	const char *given_repo,
	git_repository_init_options *opts)
{
	int error;
	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT;

1473
	assert(out && given_repo && opts);
1474

Ben Straub committed
1475
	GITERR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
1476

1477 1478
	error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
	if (error < 0)
1479
		goto cleanup;
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491

	if (valid_repository_path(&repo_path)) {

		if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
			giterr_set(GITERR_REPOSITORY,
				"Attempt to reinitialize '%s'", given_repo);
			error = GIT_EEXISTS;
			goto cleanup;
		}

		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;

1492
		error = repo_init_config(
1493
			repo_path.ptr, wd_path.ptr, opts->flags, opts->mode);
1494 1495 1496 1497 1498

		/* TODO: reinitialize the templates */
	}
	else {
		if (!(error = repo_init_structure(
1499
				repo_path.ptr, wd_path.ptr, opts)) &&
1500
			!(error = repo_init_config(
1501
				repo_path.ptr, wd_path.ptr, opts->flags, opts->mode)))
1502
			error = repo_init_create_head(
1503
				repo_path.ptr, opts->initial_head);
1504
	}
1505 1506 1507
	if (error < 0)
		goto cleanup;

1508
	error = git_repository_open(out, repo_path.ptr);
1509

1510
	if (!error && opts->origin_url)
1511
		error = repo_init_create_origin(*out, opts->origin_url);
1512 1513

cleanup:
1514 1515 1516 1517
	git_buf_free(&repo_path);
	git_buf_free(&wd_path);

	return error;
1518
}
1519

1520
int git_repository_head_detached(git_repository *repo)
1521 1522
{
	git_reference *ref;
1523
	git_odb *odb = NULL;
1524
	int exists;
1525

1526 1527
	if (git_repository_odb__weakptr(&odb, repo) < 0)
		return -1;
1528

1529 1530
	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
		return -1;
1531

1532 1533
	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
		git_reference_free(ref);
1534
		return 0;
1535
	}
1536

1537
	exists = git_odb_exists(odb, git_reference_target(ref));
1538 1539

	git_reference_free(ref);
1540
	return exists;
1541 1542
}

1543
int git_repository_head(git_reference **head_out, git_repository *repo)
1544
{
1545
	git_reference *head;
1546 1547
	int error;

1548 1549 1550 1551 1552 1553 1554 1555
	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;
	}

1556
	error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
1557
	git_reference_free(head);
1558

1559
	return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
1560 1561
}

1562
int git_repository_head_unborn(git_repository *repo)
1563
{
1564
	git_reference *ref = NULL;
1565 1566 1567
	int error;

	error = git_repository_head(&ref, repo);
1568
	git_reference_free(ref);
1569

1570 1571
	if (error == GIT_EUNBORNBRANCH) {
		giterr_clear();
1572
		return 1;
1573
	}
1574

1575 1576 1577 1578
	if (error < 0)
		return -1;

	return 0;
1579
}
1580

1581
static int at_least_one_cb(const char *refname, void *payload)
1582
{
1583 1584
	GIT_UNUSED(refname);
	GIT_UNUSED(payload);
1585
	return GIT_PASSTHROUGH;
1586
}
1587

1588 1589
static int repo_contains_no_reference(git_repository *repo)
{
1590
	int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
1591

1592
	if (error == GIT_PASSTHROUGH)
1593
		return 0;
1594

1595 1596
	if (!error)
		return 1;
1597

1598
	return error;
1599
}
1600

1601 1602 1603
int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL;
1604
	int is_empty = 0;
1605

1606
	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0)
1607 1608
		return -1;

1609 1610 1611 1612 1613
	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);
1614 1615

	git_reference_free(head);
1616 1617

	return is_empty;
1618 1619
}

1620
const char *git_repository_path(git_repository *repo)
1621 1622
{
	assert(repo);
1623 1624
	return repo->path_repository;
}
1625

1626 1627 1628
const char *git_repository_workdir(git_repository *repo)
{
	assert(repo);
1629

1630 1631
	if (repo->is_bare)
		return NULL;
1632

1633 1634
	return repo->workdir;
}
1635

1636 1637
int git_repository_set_workdir(
	git_repository *repo, const char *workdir, int update_gitlink)
1638
{
1639
	int error = 0;
1640 1641
	git_buf path = GIT_BUF_INIT;

1642
	assert(repo && workdir);
1643

1644 1645
	if (git_path_prettify_dir(&path, workdir, NULL) < 0)
		return -1;
1646

1647 1648
	if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
		return 0;
1649

1650 1651 1652 1653 1654 1655
	if (update_gitlink) {
		git_config *config;

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

1656
		error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);
1657 1658 1659

		/* passthrough error means gitlink is unnecessary */
		if (error == GIT_PASSTHROUGH)
Ben Straub committed
1660
			error = git_config_delete_entry(config, "core.worktree");
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
		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;
1678
}
1679 1680 1681 1682 1683 1684

int git_repository_is_bare(git_repository *repo)
{
	assert(repo);
	return repo->is_bare;
}
1685

1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
int git_repository_set_bare(git_repository *repo)
{
	int error;
	git_config *config;

	assert(repo);

	if (repo->is_bare)
		return 0;

1696 1697 1698 1699 1700
	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
		return error;

	if ((error = git_config_set_bool(config, "core.bare", false)) < 0)
		return error;
1701

1702 1703
	if ((error = git_config__update_entry(config, "core.worktree", NULL, true, true)) < 0)
		return error;
1704 1705 1706 1707 1708

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

1709
	return 0;
1710 1711
}

1712 1713
int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
1714 1715 1716
	git_reference *head;
	git_object *obj;
	int error;
1717

1718 1719
	if ((error = git_repository_head(&head, repo)) < 0)
		return error;
1720

1721 1722
	if ((error = git_reference_peel(&obj, head, GIT_OBJ_TREE)) < 0)
		goto cleanup;
1723 1724

	*tree = (git_tree *)obj;
1725 1726 1727 1728

cleanup:
	git_reference_free(head);
	return error;
1729
}
1730

1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752
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);

	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_ORIG_HEAD_FILE)) == 0 &&
		(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);

	git_buf_free(&file_path);

	return error;
}

1753
int git_repository_message(git_buf *out, git_repository *repo)
1754
{
1755
	git_buf path = GIT_BUF_INIT;
Vicent Marti committed
1756 1757
	struct stat st;
	int error;
1758

1759
	git_buf_sanitize(out);
1760

Edward Thomson committed
1761
	if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
1762
		return -1;
1763

1764
	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
1765 1766
		if (errno == ENOENT)
			error = GIT_ENOTFOUND;
1767
		giterr_set(GITERR_OS, "Could not access message file");
1768 1769
	} else {
		error = git_futils_readbuffer(out, git_buf_cstr(&path));
Vicent Marti committed
1770
	}
1771

1772
	git_buf_free(&path);
1773 1774

	return error;
1775 1776 1777 1778
}

int git_repository_message_remove(git_repository *repo)
{
Vicent Marti committed
1779 1780
	git_buf path = GIT_BUF_INIT;
	int error;
1781

Edward Thomson committed
1782
	if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
1783
		return -1;
1784 1785 1786 1787 1788 1789

	error = p_unlink(git_buf_cstr(&path));
	git_buf_free(&path);

	return error;
}
1790 1791

int git_repository_hashfile(
Linquize committed
1792 1793 1794 1795 1796
	git_oid *out,
	git_repository *repo,
	const char *path,
	git_otype type,
	const char *as_path)
1797 1798
{
	int error;
1799
	git_filter_list *fl = NULL;
1800
	git_file fd = -1;
1801 1802 1803
	git_off_t len;
	git_buf full_path = GIT_BUF_INIT;

1804 1805 1806 1807 1808 1809
	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.
	 */
1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820

	error = git_path_join_unrooted(
		&full_path, path, repo ? git_repository_workdir(repo) : NULL, NULL);
	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
1821
		error = git_filter_list_load(
1822 1823
			&fl, repo, NULL, as_path,
			GIT_FILTER_TO_ODB, GIT_FILTER_OPT_DEFAULT);
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
		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) {
1840
		error = (int)len;
1841 1842 1843 1844 1845 1846 1847 1848 1849
		goto cleanup;
	}

	if (!git__is_sizet(len)) {
		giterr_set(GITERR_OS, "File size overflow for 32-bit systems");
		error = -1;
		goto cleanup;
	}

1850
	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
1851 1852

cleanup:
1853 1854
	if (fd >= 0)
		p_close(fd);
1855
	git_filter_list_free(fl);
1856 1857 1858 1859 1860
	git_buf_free(&full_path);

	return error;
}

1861 1862 1863 1864 1865 1866 1867
static bool looks_like_a_branch(const char *refname)
{
	return git__prefixcmp(refname, GIT_REFS_HEADS_DIR) == 0;
}

int git_repository_set_head(
	git_repository* repo,
1868 1869 1870
	const char* refname,
	const git_signature *signature,
	const char *log_message)
1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
{
	git_reference *ref,
		*new_head = NULL;
	int error;

	assert(repo && refname);

	error = git_reference_lookup(&ref, repo, refname);
	if (error < 0 && error != GIT_ENOTFOUND)
		return error;

	if (!error) {
1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
		if (git_reference_is_branch(ref)) {
			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
					git_reference_name(ref), true, signature, log_message);
		} else {
			error = git_repository_set_head_detached(repo, git_reference_target(ref),
					signature, log_message);
		}
	} else if (looks_like_a_branch(refname)) {
		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
				true, signature, log_message);
	}
1894 1895 1896 1897 1898 1899

	git_reference_free(ref);
	git_reference_free(new_head);
	return error;
}

1900 1901
int git_repository_set_head_detached(
	git_repository* repo,
1902 1903 1904
	const git_oid* commitish,
	const git_signature *signature,
	const char *log_message)
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
{
	int error;
	git_object *object,
		*peeled = NULL;
	git_reference *new_head = NULL;

	assert(repo && commitish);

	if ((error = git_object_lookup(&object, repo, commitish, GIT_OBJ_ANY)) < 0)
		return error;

	if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
		goto cleanup;

1919
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, signature, log_message);
1920 1921 1922 1923 1924 1925 1926 1927

cleanup:
	git_object_free(object);
	git_object_free(peeled);
	git_reference_free(new_head);
	return error;
}

1928
int git_repository_detach_head(
1929 1930 1931
	git_repository* repo,
	const git_signature *signature,
	const char *reflog_message)
1932 1933 1934 1935
{
	git_reference *old_head = NULL,
		*new_head = NULL;
	git_object *object = NULL;
1936
	int error;
1937 1938 1939

	assert(repo);

1940 1941
	if ((error = git_repository_head(&old_head, repo)) < 0)
		return error;
1942

1943
	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
1944 1945
		goto cleanup;

1946 1947
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
			1, signature, reflog_message);
1948 1949 1950 1951 1952 1953 1954

cleanup:
	git_object_free(object);
	git_reference_free(old_head);
	git_reference_free(new_head);
	return error;
}
Edward Thomson committed
1955

1956 1957 1958 1959
/**
 * Loosely ported from git.git
 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
 */
Edward Thomson committed
1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
int git_repository_state(git_repository *repo)
{
	git_buf repo_path = GIT_BUF_INIT;
	int state = GIT_REPOSITORY_STATE_NONE;

	assert(repo);

	if (git_buf_puts(&repo_path, repo->path_repository) < 0)
		return -1;

1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
	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
1981 1982 1983
		state = GIT_REPOSITORY_STATE_MERGE;
	else if(git_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE))
		state = GIT_REPOSITORY_STATE_REVERT;
1984 1985
	else if(git_path_contains_file(&repo_path, GIT_CHERRYPICK_HEAD_FILE))
		state = GIT_REPOSITORY_STATE_CHERRYPICK;
1986 1987
	else if(git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
		state = GIT_REPOSITORY_STATE_BISECT;
Edward Thomson committed
1988 1989 1990 1991

	git_buf_free(&repo_path);
	return state;
}
Ben Straub committed
1992

1993 1994
int git_repository__cleanup_files(
	git_repository *repo, const char *files[], size_t files_len)
1995
{
1996
	git_buf buf = GIT_BUF_INIT;
1997
	size_t i;
1998
	int error;
1999

2000 2001
	for (error = 0, i = 0; !error && i < files_len; ++i) {
		const char *path;
2002

2003 2004
		if (git_buf_joinpath(&buf, repo->path_repository, files[i]) < 0)
			return -1;
2005

2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
		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);
		}
			
		git_buf_clear(&buf);
	}
2017

2018
	git_buf_free(&buf);
2019 2020 2021 2022 2023 2024 2025 2026
	return error;
}

static const char *state_files[] = {
	GIT_MERGE_HEAD_FILE,
	GIT_MERGE_MODE_FILE,
	GIT_MERGE_MSG_FILE,
	GIT_REVERT_HEAD_FILE,
2027
	GIT_CHERRYPICK_HEAD_FILE,
2028 2029 2030
	GIT_BISECT_LOG_FILE,
	GIT_REBASE_MERGE_DIR,
	GIT_REBASE_APPLY_DIR,
2031 2032 2033 2034 2035 2036 2037 2038 2039
};

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
2040 2041 2042 2043
int git_repository_is_shallow(git_repository *repo)
{
	git_buf path = GIT_BUF_INIT;
	struct stat st;
Ben Straub committed
2044
	int error;
Ben Straub committed
2045 2046

	git_buf_joinpath(&path, repo->path_repository, "shallow");
Ben Straub committed
2047 2048
	error = git_path_lstat(path.ptr, &st);
	git_buf_free(&path);
Ben Straub committed
2049

2050 2051
	if (error == GIT_ENOTFOUND) {
		giterr_clear();
Ben Straub committed
2052
		return 0;
2053 2054
	}

Ben Straub committed
2055 2056 2057
	if (error < 0)
		return error;
	return st.st_size == 0 ? 0 : 1;
Ben Straub committed
2058
}
2059

2060 2061
int git_repository_init_init_options(
	git_repository_init_options *opts, unsigned int version)
2062
{
2063 2064 2065 2066
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_repository_init_options,
		GIT_REPOSITORY_INIT_OPTIONS_INIT);
	return 0;
2067
}