repository.c 45.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 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
static int repo_init_config(
	const char *repo_dir,
	const char *work_dir,
	uint32_t flags,
	uint32_t mode)
{
	int error = 0;
	git_buf cfg_path = GIT_BUF_INIT;
	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
		if (!(flags & GIT_REPOSITORY_INIT__NATURAL_WD))
1023
			SET_REPO_CONFIG(string, "core.worktree", work_dir);
1024
		else if (is_reinit) {
Ben Straub committed
1025
			if (git_config_delete_entry(config, "core.worktree") < 0)
1026
				giterr_clear();
1027 1028 1029
		}
	}

1030
	if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
1031 1032
		SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
1033
	}
1034
	else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
1035 1036 1037
		SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
	}
1038

1039
cleanup:
1040
	git_buf_free(&cfg_path);
1041
	git_config_free(config);
1042

1043
	return error;
1044
}
1045

1046
static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
1047
{
1048 1049
	git_repository *smrepo = NULL;
	GIT_UNUSED(n); GIT_UNUSED(p);
1050

1051
	if (git_submodule_open(&smrepo, sm) < 0 ||
1052
		git_repository_reinit_filesystem(smrepo, true) < 0)
1053 1054
		giterr_clear();
	git_repository_free(smrepo);
1055

1056 1057
	return 0;
}
1058

1059
int git_repository_reinit_filesystem(git_repository *repo, int recurse)
1060 1061 1062 1063 1064
{
	int error = 0;
	git_buf path = GIT_BUF_INIT;
	git_config *config = NULL;
	const char *repo_dir = git_repository_path(repo);
1065

1066 1067 1068
	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);
1069

1070 1071
	git_config_free(config);
	git_buf_free(&path);
1072 1073 1074

	git_repository__cvar_cache_clear(repo);

1075
	if (!repo->is_bare && recurse)
1076
		(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
1077

1078 1079 1080
	return error;
}

1081
static int repo_write_template(
1082 1083 1084 1085
	const char *git_dir,
	bool allow_overwrite,
	const char *file,
	mode_t mode,
1086
	bool hidden,
1087
	const char *content)
1088 1089
{
	git_buf path = GIT_BUF_INIT;
1090
	int fd, error = 0, flags;
1091 1092 1093 1094

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

1095 1096 1097 1098 1099 1100
	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);
1101

1102 1103
	if (fd >= 0) {
		error = p_write(fd, content, strlen(content));
1104

1105 1106 1107 1108
		p_close(fd);
	}
	else if (errno != EEXIST)
		error = fd;
1109

1110 1111
#ifdef GIT_WIN32
	if (!error && hidden) {
1112
		if (git_win32__sethidden(path.ptr) < 0)
1113 1114 1115 1116 1117 1118
			error = -1;
	}
#else
	GIT_UNUSED(hidden);
#endif

1119
	git_buf_free(&path);
1120 1121 1122 1123 1124 1125

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

	return error;
1126 1127
}

1128 1129
static int repo_write_gitlink(
	const char *in_dir, const char *to_repo)
1130
{
1131 1132 1133 1134 1135 1136 1137
	int error;
	git_buf buf = GIT_BUF_INIT;
	struct stat st;

	git_path_dirname_r(&buf, to_repo);
	git_path_to_dir(&buf);
	if (git_buf_oom(&buf))
1138
		return -1;
1139

1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
	/* don't write gitlink to natural workdir */
	if (git__suffixcmp(to_repo, "/" DOT_GIT "/") == 0 &&
		strcmp(in_dir, buf.ptr) == 0)
	{
		error = GIT_PASSTHROUGH;
		goto cleanup;
	}

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

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

	git_buf_clear(&buf);

	error = git_buf_printf(&buf, "%s %s", GIT_FILE_CONTENT_PREFIX, to_repo);

	if (!error)
1163
		error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
1164 1165 1166 1167 1168 1169

cleanup:
	git_buf_free(&buf);
	return error;
}

1170 1171 1172
static mode_t pick_dir_mode(git_repository_init_options *opts)
{
	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_UMASK)
1173
		return 0777;
1174 1175 1176 1177 1178 1179 1180
	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;
}

1181 1182 1183 1184 1185 1186 1187
#include "repo_template.h"

static int repo_init_structure(
	const char *repo_dir,
	const char *work_dir,
	git_repository_init_options *opts)
{
1188
	int error = 0;
1189
	repo_template_item *tpl;
1190 1191 1192
	bool external_tpl =
		((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
	mode_t dmode = pick_dir_mode(opts);
1193 1194

	/* Hide the ".git" directory */
1195
#ifdef GIT_WIN32
1196
	if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
1197 1198
		if (git_win32__sethidden(repo_dir) < 0) {
			giterr_set(GITERR_OS,
1199 1200 1201
				"Failed to mark Git repository folder as hidden");
			return -1;
		}
1202
	}
1203 1204 1205 1206 1207 1208
#endif

	/* Create the .git gitlink if appropriate */
	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
		(opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0)
	{
1209
		if (repo_write_gitlink(work_dir, repo_dir) < 0)
1210
			return -1;
1211
	}
1212

1213 1214
	/* Copy external template if requested */
	if (external_tpl) {
Linquize committed
1215 1216 1217
		git_config *cfg = NULL;
		const char *tdir = NULL;
		bool default_template = false;
1218 1219
		git_buf template_buf = GIT_BUF_INIT;

1220 1221
		if (opts->template_path)
			tdir = opts->template_path;
Linquize committed
1222
		else if ((error = git_config_open_default(&cfg)) >= 0) {
1223 1224
			error = git_config_get_string(&tdir, cfg, "init.templatedir");
			giterr_clear();
Linquize committed
1225 1226 1227
		}

		if (!tdir) {
1228
			if (!(error = git_sysdir_find_template_dir(&template_buf)))
1229
				tdir = template_buf.ptr;
Linquize committed
1230
			default_template = true;
1231
		}
1232

1233 1234 1235 1236
		if (tdir)
			error = git_futils_cp_r(tdir, repo_dir,
				GIT_CPDIR_COPY_SYMLINKS | GIT_CPDIR_CHMOD_DIRS |
				GIT_CPDIR_SIMPLE_TO_MODE, dmode);
1237

Linquize committed
1238 1239
		git_buf_free(&template_buf);
		git_config_free(cfg);
1240

1241
		if (error < 0) {
Linquize committed
1242
			if (!default_template)
1243 1244 1245 1246 1247
				return error;

			/* if template was default, ignore error and use internal */
			giterr_clear();
			external_tpl = false;
1248
			error = 0;
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260
		}
	}

	/* Copy internal template
	 * - always ensure existence of dirs
	 * - only create files if no external template was specified
	 */
	for (tpl = repo_template; !error && tpl->path; ++tpl) {
		if (!tpl->content)
			error = git_futils_mkdir(
				tpl->path, repo_dir, dmode, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD);
		else if (!external_tpl) {
1261 1262 1263 1264 1265
			const char *content = tpl->content;

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

1266 1267
			error = repo_write_template(
				repo_dir, false, tpl->path, tpl->mode, false, content);
1268
		}
1269 1270
	}

1271
	return error;
1272 1273
}

1274 1275
static int mkdir_parent(git_buf *buf, uint32_t mode, bool skip2)
{
1276 1277 1278
	/* When making parent directories during repository initialization
	 * don't try to set gid or grant world write access
	 */
1279
	return git_futils_mkdir(
1280
		buf->ptr, NULL, mode & ~(S_ISGID | 0002),
1281 1282 1283 1284
		GIT_MKDIR_PATH | GIT_MKDIR_VERIFY_DIR |
		(skip2 ? GIT_MKDIR_SKIP_LAST2 : GIT_MKDIR_SKIP_LAST));
}

1285 1286 1287 1288 1289
static int repo_init_directories(
	git_buf *repo_path,
	git_buf *wd_path,
	const char *given_repo,
	git_repository_init_options *opts)
1290
{
1291
	int error = 0;
1292
	bool is_bare, add_dotgit, has_dotgit, natural_wd;
1293
	mode_t dirmode;
1294

1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
	/* 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
	 */

1315
	/* set up repo path */
1316

1317 1318
	is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);

1319 1320
	add_dotgit =
		(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
1321
		!is_bare &&
1322 1323
		git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
		git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
1324

1325 1326
	if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
		return -1;
1327

1328 1329 1330 1331 1332 1333
	has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
	if (has_dotgit)
		opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;

	/* set up workdir path */

1334
	if (!is_bare) {
1335
		if (opts->workdir_path) {
1336 1337 1338
			if (git_path_join_unrooted(
					wd_path, opts->workdir_path, repo_path->ptr, NULL) < 0)
				return -1;
1339 1340 1341 1342 1343 1344 1345 1346
		} 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;
		}
1347

1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363
		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 */

1364
	dirmode = pick_dir_mode(opts);
1365

1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
	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;
1394 1395
	}

1396 1397 1398 1399
	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0 ||
		has_dotgit)
	{
1400
		/* create path #1 */
1401 1402
		error = git_futils_mkdir(repo_path->ptr, NULL, dirmode,
			GIT_MKDIR_VERIFY_DIR | ((dirmode & S_ISGID) ? GIT_MKDIR_CHMOD : 0));
1403
	}
1404

1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
	/* 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
1422
	if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
1423 1424 1425 1426 1427 1428 1429 1430 1431
		git_remote_free(remote);
	}

	return error;
}

int git_repository_init(
	git_repository **repo_out, const char *path, unsigned is_bare)
{
1432
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
1433 1434 1435 1436 1437 1438 1439 1440 1441

	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(
1442
	git_repository **out,
1443 1444 1445 1446 1447 1448
	const char *given_repo,
	git_repository_init_options *opts)
{
	int error;
	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT;

1449
	assert(out && given_repo && opts);
1450

Ben Straub committed
1451
	GITERR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
1452

1453 1454
	error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
	if (error < 0)
1455
		goto cleanup;
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467

	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;

1468
		error = repo_init_config(
1469
			repo_path.ptr, wd_path.ptr, opts->flags, opts->mode);
1470 1471 1472 1473 1474

		/* TODO: reinitialize the templates */
	}
	else {
		if (!(error = repo_init_structure(
1475
				repo_path.ptr, wd_path.ptr, opts)) &&
1476
			!(error = repo_init_config(
1477
				repo_path.ptr, wd_path.ptr, opts->flags, opts->mode)))
1478
			error = repo_init_create_head(
1479
				repo_path.ptr, opts->initial_head);
1480
	}
1481 1482 1483
	if (error < 0)
		goto cleanup;

1484
	error = git_repository_open(out, repo_path.ptr);
1485

1486
	if (!error && opts->origin_url)
1487
		error = repo_init_create_origin(*out, opts->origin_url);
1488 1489

cleanup:
1490 1491 1492 1493
	git_buf_free(&repo_path);
	git_buf_free(&wd_path);

	return error;
1494
}
1495

1496
int git_repository_head_detached(git_repository *repo)
1497 1498
{
	git_reference *ref;
1499
	git_odb *odb = NULL;
1500
	int exists;
1501

1502 1503
	if (git_repository_odb__weakptr(&odb, repo) < 0)
		return -1;
1504

1505 1506
	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
		return -1;
1507

1508 1509
	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
		git_reference_free(ref);
1510
		return 0;
1511
	}
1512

1513
	exists = git_odb_exists(odb, git_reference_target(ref));
1514 1515

	git_reference_free(ref);
1516
	return exists;
1517 1518
}

1519
int git_repository_head(git_reference **head_out, git_repository *repo)
1520
{
1521
	git_reference *head;
1522 1523
	int error;

1524 1525 1526 1527 1528 1529 1530 1531
	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;
	}

1532
	error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
1533
	git_reference_free(head);
1534

1535
	return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
1536 1537
}

1538
int git_repository_head_unborn(git_repository *repo)
1539
{
1540
	git_reference *ref = NULL;
1541 1542 1543
	int error;

	error = git_repository_head(&ref, repo);
1544
	git_reference_free(ref);
1545

1546
	if (error == GIT_EUNBORNBRANCH)
1547
		return 1;
1548

1549 1550 1551 1552
	if (error < 0)
		return -1;

	return 0;
1553
}
1554

1555
static int at_least_one_cb(const char *refname, void *payload)
1556
{
1557 1558
	GIT_UNUSED(refname);
	GIT_UNUSED(payload);
1559
	return GIT_PASSTHROUGH;
1560
}
1561

1562 1563
static int repo_contains_no_reference(git_repository *repo)
{
1564
	int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
1565

1566
	if (error == GIT_PASSTHROUGH)
1567
		return 0;
1568

1569 1570
	if (!error)
		return 1;
1571

1572
	return error;
1573
}
1574

1575 1576 1577
int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL;
1578
	int is_empty = 0;
1579

1580
	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0)
1581 1582
		return -1;

1583 1584 1585 1586 1587
	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);
1588 1589

	git_reference_free(head);
1590 1591

	return is_empty;
1592 1593
}

1594
const char *git_repository_path(git_repository *repo)
1595 1596
{
	assert(repo);
1597 1598
	return repo->path_repository;
}
1599

1600 1601 1602
const char *git_repository_workdir(git_repository *repo)
{
	assert(repo);
1603

1604 1605
	if (repo->is_bare)
		return NULL;
1606

1607 1608
	return repo->workdir;
}
1609

1610 1611
int git_repository_set_workdir(
	git_repository *repo, const char *workdir, int update_gitlink)
1612
{
1613
	int error = 0;
1614 1615
	git_buf path = GIT_BUF_INIT;

1616
	assert(repo && workdir);
1617

1618 1619
	if (git_path_prettify_dir(&path, workdir, NULL) < 0)
		return -1;
1620

1621 1622
	if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
		return 0;
1623

1624 1625 1626 1627 1628 1629
	if (update_gitlink) {
		git_config *config;

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

1630
		error = repo_write_gitlink(path.ptr, git_repository_path(repo));
1631 1632 1633

		/* passthrough error means gitlink is unnecessary */
		if (error == GIT_PASSTHROUGH)
Ben Straub committed
1634
			error = git_config_delete_entry(config, "core.worktree");
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
		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;
1652
}
1653 1654 1655 1656 1657 1658

int git_repository_is_bare(git_repository *repo)
{
	assert(repo);
	return repo->is_bare;
}
1659 1660 1661

int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
1662 1663 1664
	git_reference *head;
	git_object *obj;
	int error;
1665

1666 1667
	if ((error = git_repository_head(&head, repo)) < 0)
		return error;
1668

1669 1670
	if ((error = git_reference_peel(&obj, head, GIT_OBJ_TREE)) < 0)
		goto cleanup;
1671 1672

	*tree = (git_tree *)obj;
1673 1674 1675 1676

cleanup:
	git_reference_free(head);
	return error;
1677
}
1678

1679
int git_repository_message(git_buf *out, git_repository *repo)
1680
{
1681
	git_buf path = GIT_BUF_INIT;
Vicent Marti committed
1682 1683
	struct stat st;
	int error;
1684

1685
	git_buf_sanitize(out);
1686

Edward Thomson committed
1687
	if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
1688
		return -1;
1689

1690
	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
1691 1692
		if (errno == ENOENT)
			error = GIT_ENOTFOUND;
1693
		giterr_set(GITERR_OS, "Could not access message file");
1694 1695
	} else {
		error = git_futils_readbuffer(out, git_buf_cstr(&path));
Vicent Marti committed
1696
	}
1697

1698
	git_buf_free(&path);
1699 1700

	return error;
1701 1702 1703 1704
}

int git_repository_message_remove(git_repository *repo)
{
Vicent Marti committed
1705 1706
	git_buf path = GIT_BUF_INIT;
	int error;
1707

Edward Thomson committed
1708
	if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
1709
		return -1;
1710 1711 1712 1713 1714 1715

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

	return error;
}
1716 1717

int git_repository_hashfile(
Linquize committed
1718 1719 1720 1721 1722
	git_oid *out,
	git_repository *repo,
	const char *path,
	git_otype type,
	const char *as_path)
1723 1724
{
	int error;
1725
	git_filter_list *fl = NULL;
1726
	git_file fd = -1;
1727 1728 1729
	git_off_t len;
	git_buf full_path = GIT_BUF_INIT;

1730 1731 1732 1733 1734 1735
	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.
	 */
1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746

	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
1747
		error = git_filter_list_load(
1748 1749
			&fl, repo, NULL, as_path,
			GIT_FILTER_TO_ODB, GIT_FILTER_OPT_DEFAULT);
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765
		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) {
1766
		error = (int)len;
1767 1768 1769 1770 1771 1772 1773 1774 1775
		goto cleanup;
	}

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

1776
	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
1777 1778

cleanup:
1779 1780
	if (fd >= 0)
		p_close(fd);
1781
	git_filter_list_free(fl);
1782 1783 1784 1785 1786
	git_buf_free(&full_path);

	return error;
}

1787 1788 1789 1790 1791 1792 1793
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,
1794 1795 1796
	const char* refname,
	const git_signature *signature,
	const char *log_message)
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808
{
	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) {
1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
		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);
	}
1820 1821 1822 1823 1824 1825

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

1826 1827
int git_repository_set_head_detached(
	git_repository* repo,
1828 1829 1830
	const git_oid* commitish,
	const git_signature *signature,
	const char *log_message)
1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844
{
	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;

1845
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, signature, log_message);
1846 1847 1848 1849 1850 1851 1852 1853

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

1854
int git_repository_detach_head(
1855 1856 1857
	git_repository* repo,
	const git_signature *signature,
	const char *reflog_message)
1858 1859 1860 1861
{
	git_reference *old_head = NULL,
		*new_head = NULL;
	git_object *object = NULL;
1862
	int error;
1863 1864 1865

	assert(repo);

1866 1867
	if ((error = git_repository_head(&old_head, repo)) < 0)
		return error;
1868

1869
	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
1870 1871
		goto cleanup;

1872 1873
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
			1, signature, reflog_message);
1874 1875 1876 1877 1878 1879 1880

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

1882 1883 1884 1885
/**
 * Loosely ported from git.git
 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
 */
Edward Thomson committed
1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
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;

1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
	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
1907 1908 1909 1910 1911
		state = GIT_REPOSITORY_STATE_MERGE;
	else if(git_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE))
		state = GIT_REPOSITORY_STATE_REVERT;
	else if(git_path_contains_file(&repo_path, GIT_CHERRY_PICK_HEAD_FILE))
		state = GIT_REPOSITORY_STATE_CHERRY_PICK;
1912 1913
	else if(git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
		state = GIT_REPOSITORY_STATE_BISECT;
Edward Thomson committed
1914 1915 1916 1917

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

1919 1920
int git_repository__cleanup_files(
	git_repository *repo, const char *files[], size_t files_len)
1921
{
1922
	git_buf buf = GIT_BUF_INIT;
1923
	size_t i;
1924
	int error;
1925

1926 1927
	for (error = 0, i = 0; !error && i < files_len; ++i) {
		const char *path;
1928

1929 1930
		if (git_buf_joinpath(&buf, repo->path_repository, files[i]) < 0)
			return -1;
1931

1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
		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);
	}
1943

1944
	git_buf_free(&buf);
1945 1946 1947 1948 1949 1950 1951 1952 1953
	return error;
}

static const char *state_files[] = {
	GIT_MERGE_HEAD_FILE,
	GIT_MERGE_MODE_FILE,
	GIT_MERGE_MSG_FILE,
	GIT_REVERT_HEAD_FILE,
	GIT_CHERRY_PICK_HEAD_FILE,
1954 1955 1956
	GIT_BISECT_LOG_FILE,
	GIT_REBASE_MERGE_DIR,
	GIT_REBASE_APPLY_DIR,
1957 1958 1959 1960 1961 1962 1963 1964 1965
};

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
1966 1967 1968 1969
int git_repository_is_shallow(git_repository *repo)
{
	git_buf path = GIT_BUF_INIT;
	struct stat st;
Ben Straub committed
1970
	int error;
Ben Straub committed
1971 1972

	git_buf_joinpath(&path, repo->path_repository, "shallow");
Ben Straub committed
1973 1974
	error = git_path_lstat(path.ptr, &st);
	git_buf_free(&path);
Ben Straub committed
1975

1976 1977
	if (error == GIT_ENOTFOUND) {
		giterr_clear();
Ben Straub committed
1978
		return 0;
1979 1980
	}

Ben Straub committed
1981 1982 1983
	if (error < 0)
		return error;
	return st.st_size == 0 ? 0 : 1;
Ben Straub committed
1984
}
1985

1986 1987
int git_repository_init_init_options(
	git_repository_init_options *opts, unsigned int version)
1988
{
1989 1990 1991 1992
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_repository_init_options,
		GIT_REPOSITORY_INIT_OPTIONS_INIT);
	return 0;
1993
}