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

#include "repository.h"

10
#include <ctype.h>
11

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

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

#include "strmap.h"
36

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

41 42
bool git_repository__fsync_gitdir = false;

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

65 66
static int check_repositoryformatversion(int *version, git_config *config);
static int check_extensions(git_config *config, int version);
67

68
#define GIT_COMMONDIR_FILE "commondir"
69
#define GIT_GITDIR_FILE "gitdir"
70

71
#define GIT_FILE_CONTENT_PREFIX "gitdir:"
72

73
#define GIT_BRANCH_DEFAULT "master"
74

75
#define GIT_REPO_VERSION 0
76
#define GIT_REPO_MAX_VERSION 1
77

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

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

89
static void set_odb(git_repository *repo, git_odb *odb)
90
{
91 92 93 94 95 96 97 98
	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);
99
	}
100
}
101

102
static void set_refdb(git_repository *repo, git_refdb *refdb)
103
{
104 105 106 107 108 109 110 111
	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);
112 113 114
	}
}

115
static void set_config(git_repository *repo, git_config *config)
116
{
117 118 119 120 121 122 123 124
	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);
125
	}
126

127
	git_repository__configmap_lookup_cache_clear(repo);
128 129
}

130
static void set_index(git_repository *repo, git_index *index)
131
{
132 133 134 135 136 137 138 139
	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);
140
	}
141 142
}

143
int git_repository__cleanup(git_repository *repo)
144
{
145
	assert(repo);
146

147
	git_repository_submodule_cache_clear(repo);
148
	git_cache_clear(&repo->objects);
149
	git_attr_cache_flush(repo);
150

151 152 153 154
	set_config(repo, NULL);
	set_index(repo, NULL);
	set_odb(repo, NULL);
	set_refdb(repo, NULL);
155 156

	return 0;
157 158 159 160
}

void git_repository_free(git_repository *repo)
{
161 162
	size_t i;

163 164 165 166 167
	if (repo == NULL)
		return;

	git_repository__cleanup(repo);

168
	git_cache_dispose(&repo->objects);
169

170
	git_diff_driver_registry_free(repo->diff_drivers);
171
	repo->diff_drivers = NULL;
172

173
	for (i = 0; i < repo->reserved_names.size; i++)
174
		git_buf_dispose(git_array_get(repo->reserved_names, i));
Edward Thomson committed
175
	git_array_clear(repo->reserved_names);
176

177 178
	git__free(repo->gitlink);
	git__free(repo->gitdir);
179
	git__free(repo->commondir);
Russell Belfer committed
180
	git__free(repo->workdir);
Vicent Marti committed
181
	git__free(repo->namespace);
182 183
	git__free(repo->ident_name);
	git__free(repo->ident_email);
Russell Belfer committed
184

185
	git__memzero(repo, sizeof(*repo));
186
	git__free(repo);
187 188
}

189 190 191 192 193
/*
 * Git repository open methods
 *
 * Open a repository object from its path
 */
194
static int is_valid_repository_path(bool *out, git_buf *repository_path, git_buf *common_path)
195
{
196 197 198 199
	int error;

	*out = false;

200 201 202 203 204
	/* Check if we have a separate commondir (e.g. we have a
	 * worktree) */
	if (git_path_contains_file(repository_path, GIT_COMMONDIR_FILE)) {
		git_buf common_link  = GIT_BUF_INIT;

205 206 207
		if ((error = git_buf_joinpath(&common_link, repository_path->ptr, GIT_COMMONDIR_FILE)) < 0 ||
		    (error = git_futils_readbuffer(&common_link, common_link.ptr)) < 0)
			return error;
208

209
		git_buf_rtrim(&common_link);
210
		if (git_path_is_relative(common_link.ptr)) {
211 212
			if ((error = git_buf_joinpath(common_path, repository_path->ptr, common_link.ptr)) < 0)
				return error;
213 214 215 216
		} else {
			git_buf_swap(common_path, &common_link);
		}

217
		git_buf_dispose(&common_link);
218 219
	}
	else {
220 221
		if ((error = git_buf_set(common_path, repository_path->ptr, repository_path->size)) < 0)
			return error;
222 223 224 225
	}

	/* Make sure the commondir path always has a trailing * slash */
	if (git_buf_rfind(common_path, '/') != (ssize_t)common_path->size - 1)
226 227
		if ((error = git_buf_putc(common_path, '/')) < 0)
			return error;
228

229
	/* Ensure HEAD file exists */
230
	if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)
231
		return 0;
232 233
	/* Check files in common dir */
	if (git_path_contains_dir(common_path, GIT_OBJECTS_DIR) == false)
234
		return 0;
235
	if (git_path_contains_dir(common_path, GIT_REFS_DIR) == false)
236
		return 0;
237

238 239
	*out = true;
	return 0;
240 241
}

242
static git_repository *repository_alloc(void)
243
{
244
	git_repository *repo = git__calloc(1, sizeof(git_repository));
245

246 247 248 249 250 251 252
	if (repo == NULL ||
		git_cache_init(&repo->objects) < 0)
		goto on_error;

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

254 255
	/* set all the entries in the configmap cache to `unset` */
	git_repository__configmap_lookup_cache_clear(repo);
256

257
	return repo;
258 259 260

on_error:
	if (repo)
261
		git_cache_dispose(&repo->objects);
262 263 264

	git__free(repo);
	return NULL;
265 266
}

267 268
int git_repository_new(git_repository **out)
{
269 270 271
	git_repository *repo;

	*out = repo = repository_alloc();
272
	GIT_ERROR_CHECK_ALLOC(repo);
273 274

	repo->is_bare = 1;
275
	repo->is_worktree = 0;
276

277 278 279
	return 0;
}

280
static int load_config_data(git_repository *repo, const git_config *config)
281
{
282
	int is_bare;
283

284 285 286 287
	int err = git_config_get_bool(&is_bare, config, "core.bare");
	if (err < 0 && err != GIT_ENOTFOUND)
		return err;

288
	/* Try to figure out if it's bare, default to non-bare if it's not set */
289 290
	if (err != GIT_ENOTFOUND)
		repo->is_bare = is_bare && !repo->is_worktree;
291
	else
292
		repo->is_bare = 0;
293

294
	return 0;
295
}
296

297
static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)
298
{
299
	int error;
300
	git_config_entry *ce;
301 302
	git_buf worktree = GIT_BUF_INIT;
	git_buf path = GIT_BUF_INIT;
303

304
	if (repo->is_bare)
305
		return 0;
306

307 308 309
	if ((error = git_config__lookup_entry(
			&ce, config, "core.worktree", false)) < 0)
		return error;
310

311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
	if (repo->is_worktree) {
		char *gitlink = git_worktree__read_link(repo->gitdir, GIT_GITDIR_FILE);
		if (!gitlink) {
			error = -1;
			goto cleanup;
		}

		git_buf_attach(&worktree, gitlink, 0);

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

		repo->workdir = git_buf_detach(&worktree);
	}
	else if (ce && ce->value) {
329
		if ((error = git_path_prettify_dir(
330
				&worktree, ce->value, repo->gitdir)) < 0)
331
			goto cleanup;
332 333

		repo->workdir = git_buf_detach(&worktree);
334
	}
335 336
	else if (parent_path && git_path_isdir(parent_path->ptr))
		repo->workdir = git_buf_detach(parent_path);
337
	else {
338
		if (git_path_dirname_r(&worktree, repo->gitdir) < 0 ||
339 340 341 342
		    git_path_to_dir(&worktree) < 0) {
			error = -1;
			goto cleanup;
		}
343 344

		repo->workdir = git_buf_detach(&worktree);
345 346
	}

347
	GIT_ERROR_CHECK_ALLOC(repo->workdir);
348
cleanup:
349
	git_buf_dispose(&path);
350 351
	git_config_entry_free(ce);
	return error;
352 353
}

354 355 356 357 358 359 360 361
/*
 * 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.
 */
362
static size_t find_ceiling_dir_offset(
363 364 365 366 367 368
	const char *path,
	const char *ceiling_directories)
{
	char buf[GIT_PATH_MAX + 1];
	char buf2[GIT_PATH_MAX + 1];
	const char *ceil, *sep;
369
	size_t len, max_len = 0, min_len;
370 371 372

	assert(path);

373
	min_len = (size_t)(git_path_root(path) + 1);
374 375

	if (ceiling_directories == NULL || min_len == 0)
376
		return min_len;
377 378 379 380 381

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

382
		if (len == 0 || len >= sizeof(buf) || git_path_root(ceil) == -1)
383 384 385 386 387 388 389 390 391 392 393 394 395
			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) &&
396
			(path[len] == '/' || !path[len]) &&
397 398 399 400 401 402
			len > max_len)
		{
			max_len = len;
		}
	}

403
	return (max_len <= min_len ? min_len : max_len);
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
}

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

426 427
	if (git_buf_len(&file) <= prefix_len ||
		memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
428
	{
429
		git_error_set(GIT_ERROR_REPOSITORY,
430
			"the `.git` file at '%s' is malformed", file_path);
431 432 433
		error = -1;
	}
	else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
434
		const char *gitlink = git_buf_cstr(&file) + prefix_len;
435
		while (*gitlink && git__isspace(*gitlink)) gitlink++;
436

437 438
		error = git_path_prettify_dir(
			path_out, gitlink, git_buf_cstr(path_out));
439 440
	}

441
	git_buf_dispose(&file);
442 443 444 445
	return error;
}

static int find_repo(
446 447 448 449
	git_buf *gitdir_path,
	git_buf *workdir_path,
	git_buf *gitlink_path,
	git_buf *commondir_path,
450 451 452
	const char *start_path,
	uint32_t flags,
	const char *ceiling_dirs)
453
{
454
	git_buf path = GIT_BUF_INIT;
455
	git_buf repo_link = GIT_BUF_INIT;
456
	git_buf common_link = GIT_BUF_INIT;
457 458
	struct stat st;
	dev_t initial_device = 0;
459
	int min_iterations;
460
	bool in_dot_git, is_valid;
461
	size_t ceiling_offset = 0;
462
	int error;
463

464
	git_buf_clear(gitdir_path);
465

466 467
	error = git_path_prettify(&path, start_path, NULL);
	if (error < 0)
468 469
		return error;

470 471
	/* in_dot_git toggles each loop:
	 * /a/b/c/.git, /a/b/c, /a/b/.git, /a/b, /a/.git, /a
472 473 474
	 * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT, we
	 * assume we started with /a/b/c.git and don't append .git the first
	 * time through.
475 476
	 * min_iterations indicates the number of iterations left before going
	 * further counts as a search. */
477
	if (flags & (GIT_REPOSITORY_OPEN_BARE | GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
478 479 480 481 482 483
		in_dot_git = true;
		min_iterations = 1;
	} else {
		in_dot_git = false;
		min_iterations = 2;
	}
484

485
	for (;;) {
486
		if (!(flags & GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
487
			if (!in_dot_git) {
488 489
				if ((error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0)
					goto out;
490
			}
491 492
			in_dot_git = !in_dot_git;
		}
493 494 495 496 497 498

		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 &&
499
				 !(flags & GIT_REPOSITORY_OPEN_CROSS_FS))
500 501 502
				break;

			if (S_ISDIR(st.st_mode)) {
503 504 505 506 507 508 509
				if ((error = is_valid_repository_path(&is_valid, &path, &common_link)) < 0)
					goto out;

				if (is_valid) {
					if ((error = git_path_to_dir(&path)) < 0 ||
					    (error = git_buf_set(gitdir_path, path.ptr, path.size)) < 0)
						goto out;
510

511
					if (gitlink_path)
512 513
						if ((error = git_buf_attach(gitlink_path, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0)
							goto out;
514 515
					if (commondir_path)
						git_buf_swap(&common_link, commondir_path);
516

517 518
					break;
				}
519 520 521 522 523 524
			} else if (S_ISREG(st.st_mode) && git__suffixcmp(path.ptr, "/" DOT_GIT) == 0) {
				if ((error = read_gitfile(&repo_link, path.ptr)) < 0 ||
				    (error = is_valid_repository_path(&is_valid, &repo_link, &common_link)) < 0)
					goto out;

				if (is_valid) {
525
					git_buf_swap(gitdir_path, &repo_link);
526

527
					if (gitlink_path)
528 529
						if ((error = git_buf_put(gitlink_path, path.ptr, path.size)) < 0)
							goto out;
530 531
					if (commondir_path)
						git_buf_swap(&common_link, commondir_path);
532
				}
533
				break;
534 535 536
			}
		}

537 538 539
		/* Move up one directory. If we're in_dot_git, we'll search the
		 * parent itself next. If we're !in_dot_git, we'll search .git
		 * in the parent directory next (added at the top of the loop). */
540 541
		if ((error = git_path_dirname_r(&path, path.ptr)) < 0)
			goto out;
542

543 544 545 546
		/* Once we've checked the directory (and .git if applicable),
		 * find the ceiling for a search. */
		if (min_iterations && (--min_iterations == 0))
			ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);
547 548

		/* Check if we should stop searching here. */
549 550
		if (min_iterations == 0 &&
		    (path.ptr[ceiling_offset] == 0 || (flags & GIT_REPOSITORY_OPEN_NO_SEARCH)))
551
			break;
552 553
	}

554
	if (workdir_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
555 556
		if (!git_buf_len(gitdir_path))
			git_buf_clear(workdir_path);
557 558 559
		else if ((error = git_path_dirname_r(workdir_path, path.ptr)) < 0 ||
			 (error = git_path_to_dir(workdir_path)) < 0)
			goto out;
560 561
	}

562 563
	/* If we didn't find the repository, and we don't have any other error
	 * to report, report that. */
564 565
	if (!git_buf_len(gitdir_path)) {
		git_error_set(GIT_ERROR_REPOSITORY, "could not find repository from '%s'", start_path);
566
		error = GIT_ENOTFOUND;
567
		goto out;
568
	}
569

570
out:
571 572 573
	git_buf_dispose(&path);
	git_buf_dispose(&repo_link);
	git_buf_dispose(&common_link);
574 575 576
	return error;
}

577 578 579 580
int git_repository_open_bare(
	git_repository **repo_ptr,
	const char *bare_path)
{
581
	git_buf path = GIT_BUF_INIT, common_path = GIT_BUF_INIT;
582
	git_repository *repo = NULL;
583 584
	bool is_valid;
	int error;
585

586 587
	if ((error = git_path_prettify_dir(&path, bare_path, NULL)) < 0 ||
	    (error = is_valid_repository_path(&is_valid, &path, &common_path)) < 0)
588 589
		return error;

590
	if (!is_valid) {
591 592
		git_buf_dispose(&path);
		git_buf_dispose(&common_path);
593
		git_error_set(GIT_ERROR_REPOSITORY, "path is not a repository: %s", bare_path);
594 595 596 597
		return GIT_ENOTFOUND;
	}

	repo = repository_alloc();
598
	GIT_ERROR_CHECK_ALLOC(repo);
599

600
	repo->gitdir = git_buf_detach(&path);
601
	GIT_ERROR_CHECK_ALLOC(repo->gitdir);
602
	repo->commondir = git_buf_detach(&common_path);
603
	GIT_ERROR_CHECK_ALLOC(repo->commondir);
604 605 606

	/* of course we're bare! */
	repo->is_bare = 1;
607
	repo->is_worktree = 0;
608 609 610 611 612 613
	repo->workdir = NULL;

	*repo_ptr = repo;
	return 0;
}

614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
static int _git_repository_open_ext_from_env(
	git_repository **out,
	const char *start_path)
{
	git_repository *repo = NULL;
	git_index *index = NULL;
	git_odb *odb = NULL;
	git_buf dir_buf = GIT_BUF_INIT;
	git_buf ceiling_dirs_buf = GIT_BUF_INIT;
	git_buf across_fs_buf = GIT_BUF_INIT;
	git_buf index_file_buf = GIT_BUF_INIT;
	git_buf namespace_buf = GIT_BUF_INIT;
	git_buf object_dir_buf = GIT_BUF_INIT;
	git_buf alts_buf = GIT_BUF_INIT;
	git_buf work_tree_buf = GIT_BUF_INIT;
	git_buf common_dir_buf = GIT_BUF_INIT;
	const char *ceiling_dirs = NULL;
	unsigned flags = 0;
	int error;

	if (!start_path) {
		error = git__getenv(&dir_buf, "GIT_DIR");
		if (error == GIT_ENOTFOUND) {
637
			git_error_clear();
638 639 640 641 642 643 644 645 646 647 648 649
			start_path = ".";
		} else if (error < 0)
			goto error;
		else {
			start_path = git_buf_cstr(&dir_buf);
			flags |= GIT_REPOSITORY_OPEN_NO_SEARCH;
			flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT;
		}
	}

	error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES");
	if (error == GIT_ENOTFOUND)
650
		git_error_clear();
651 652 653 654 655 656 657
	else if (error < 0)
		goto error;
	else
		ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);

	error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM");
	if (error == GIT_ENOTFOUND)
658
		git_error_clear();
659 660 661 662 663 664 665 666 667 668 669 670 671
	else if (error < 0)
		goto error;
	else {
		int across_fs = 0;
		error = git_config_parse_bool(&across_fs, git_buf_cstr(&across_fs_buf));
		if (error < 0)
			goto error;
		if (across_fs)
			flags |= GIT_REPOSITORY_OPEN_CROSS_FS;
	}

	error = git__getenv(&index_file_buf, "GIT_INDEX_FILE");
	if (error == GIT_ENOTFOUND)
672
		git_error_clear();
673 674 675 676 677 678 679 680 681 682
	else if (error < 0)
		goto error;
	else {
		error = git_index_open(&index, git_buf_cstr(&index_file_buf));
		if (error < 0)
			goto error;
	}

	error = git__getenv(&namespace_buf, "GIT_NAMESPACE");
	if (error == GIT_ENOTFOUND)
683
		git_error_clear();
684 685 686 687 688
	else if (error < 0)
		goto error;

	error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");
	if (error == GIT_ENOTFOUND)
689
		git_error_clear();
690 691 692 693 694 695 696 697 698 699
	else if (error < 0)
		goto error;
	else {
		error = git_odb_open(&odb, git_buf_cstr(&object_dir_buf));
		if (error < 0)
			goto error;
	}

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

	error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");
	if (error == GIT_ENOTFOUND)
711
		git_error_clear();
712 713 714
	else if (error < 0)
		goto error;
	else {
715
		git_error_set(GIT_ERROR_INVALID, "GIT_COMMON_DIR unimplemented");
716 717 718 719 720 721 722 723 724 725 726 727
		error = GIT_ERROR;
		goto error;
	}

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

	if (odb)
		git_repository_set_odb(repo, odb);

	error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES");
728
	if (error == GIT_ENOTFOUND) {
729
		git_error_clear();
730 731
		error = 0;
	} else if (error < 0)
732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
		goto error;
        else {
		const char *end;
		char *alt, *sep;
		if (!odb) {
			error = git_repository_odb(&odb, repo);
			if (error < 0)
				goto error;
		}

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

754 755 756 757 758
	if (git_buf_len(&namespace_buf)) {
		error = git_repository_set_namespace(repo, git_buf_cstr(&namespace_buf));
		if (error < 0)
			goto error;
	}
759 760 761 762 763 764 765 766 767 768 769 770

	git_repository_set_index(repo, index);

	if (out) {
		*out = repo;
		goto success;
	}
error:
	git_repository_free(repo);
success:
	git_odb_free(odb);
	git_index_free(index);
771 772 773 774 775 776 777 778 779
	git_buf_dispose(&common_dir_buf);
	git_buf_dispose(&work_tree_buf);
	git_buf_dispose(&alts_buf);
	git_buf_dispose(&object_dir_buf);
	git_buf_dispose(&namespace_buf);
	git_buf_dispose(&index_file_buf);
	git_buf_dispose(&across_fs_buf);
	git_buf_dispose(&ceiling_dirs_buf);
	git_buf_dispose(&dir_buf);
780 781 782
	return error;
}

783 784 785 786 787
static int repo_is_worktree(unsigned *out, const git_repository *repo)
{
	git_buf gitdir_link = GIT_BUF_INIT;
	int error;

788 789 790 791 792 793 794
	/* Worktrees cannot have the same commondir and gitdir */
	if (repo->commondir && repo->gitdir
	    && !strcmp(repo->commondir, repo->gitdir)) {
		*out = 0;
		return 0;
	}

795 796 797 798 799 800 801
	if ((error = git_buf_joinpath(&gitdir_link, repo->gitdir, "gitdir")) < 0)
		return -1;

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

802
	git_buf_dispose(&gitdir_link);
803 804 805
	return error;
}

806 807 808
int git_repository_open_ext(
	git_repository **repo_ptr,
	const char *start_path,
809
	unsigned int flags,
810 811 812
	const char *ceiling_dirs)
{
	int error;
813
	unsigned is_worktree;
814 815
	git_buf gitdir = GIT_BUF_INIT, workdir = GIT_BUF_INIT,
		gitlink = GIT_BUF_INIT, commondir = GIT_BUF_INIT;
816
	git_repository *repo = NULL;
817
	git_config *config = NULL;
818
	int version = 0;
819

820 821 822
	if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)
		return _git_repository_open_ext_from_env(repo_ptr, start_path);

823 824
	if (repo_ptr)
		*repo_ptr = NULL;
825

826
	error = find_repo(
827
		&gitdir, &workdir, &gitlink, &commondir, start_path, flags, ceiling_dirs);
828

829 830
	if (error < 0 || !repo_ptr)
		goto cleanup;
831

832
	repo = repository_alloc();
833
	GIT_ERROR_CHECK_ALLOC(repo);
834

835
	repo->gitdir = git_buf_detach(&gitdir);
836
	GIT_ERROR_CHECK_ALLOC(repo->gitdir);
837

838 839
	if (gitlink.size) {
		repo->gitlink = git_buf_detach(&gitlink);
840
		GIT_ERROR_CHECK_ALLOC(repo->gitlink);
841
	}
842 843
	if (commondir.size) {
		repo->commondir = git_buf_detach(&commondir);
844
		GIT_ERROR_CHECK_ALLOC(repo->commondir);
845
	}
846

847
	if ((error = repo_is_worktree(&is_worktree, repo)) < 0)
848
		goto cleanup;
849
	repo->is_worktree = is_worktree;
850

851 852 853 854 855 856 857 858 859
	/*
	 * We'd like to have the config, but git doesn't particularly
	 * care if it's not there, so we need to deal with that.
	 */

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

860 861 862
	if (config && (error = check_repositoryformatversion(&version, config)) < 0)
		goto cleanup;

863
	if ((error = check_extensions(config, version)) < 0)
864 865
		goto cleanup;

866 867
	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
		repo->is_bare = 1;
868 869
	else {

870 871
		if (config &&
		    ((error = load_config_data(repo, config)) < 0 ||
872
		     (error = load_workdir(repo, config, &workdir)) < 0))
873
			goto cleanup;
874
	}
875

876
cleanup:
877 878
	git_buf_dispose(&gitdir);
	git_buf_dispose(&workdir);
879 880
	git_buf_dispose(&gitlink);
	git_buf_dispose(&commondir);
881 882 883 884
	git_config_free(config);

	if (error < 0)
		git_repository_free(repo);
885
	else if (repo_ptr)
886
		*repo_ptr = repo;
887 888

	return error;
889
}
890

891 892 893 894 895 896
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);
}

897 898 899 900
int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *wt)
{
	git_buf path = GIT_BUF_INIT;
	git_repository *repo = NULL;
901 902
	size_t len;
	int err;
903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922

	assert(repo_out && wt);

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

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

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

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

	*repo_out = repo;

out:
923
	git_buf_dispose(&path);
924 925 926 927

	return err;
}

928 929 930 931 932
int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
{
	git_repository *repo;

	repo = repository_alloc();
933
	GIT_ERROR_CHECK_ALLOC(repo);
934 935 936 937 938 939 940

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

	return 0;
}

941
int git_repository_discover(
942
	git_buf *out,
943 944 945 946 947
	const char *start_path,
	int across_fs,
	const char *ceiling_dirs)
{
	uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;
948
	int error;
949

950
	assert(start_path);
951

952 953
	if ((error = git_buf_sanitize(out)) < 0)
		return error;
954

955
	return find_repo(out, NULL, NULL, NULL, start_path, flags, ceiling_dirs);
956 957
}

958
static int load_config(
959 960 961
	git_config **out,
	git_repository *repo,
	const char *global_config_path,
Sven Strickroth committed
962
	const char *xdg_config_path,
963 964
	const char *system_config_path,
	const char *programdata_path)
965
{
966
	int error;
967
	git_buf config_path = GIT_BUF_INIT;
968
	git_config *cfg = NULL;
969

970
	assert(out);
971

972 973
	if ((error = git_config_new(&cfg)) < 0)
		return error;
974

975 976 977
	if (repo) {
		if ((error = git_repository_item_path(&config_path, repo, GIT_REPOSITORY_ITEM_CONFIG)) == 0)
			error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, repo, 0);
978

979 980
		if (error && error != GIT_ENOTFOUND)
			goto on_error;
981

982 983
		git_buf_dispose(&config_path);
	}
984

985 986
	if (global_config_path != NULL &&
		(error = git_config_add_file_ondisk(
987
			cfg, global_config_path, GIT_CONFIG_LEVEL_GLOBAL, repo, 0)) < 0 &&
988 989
		error != GIT_ENOTFOUND)
		goto on_error;
990

991 992
	if (xdg_config_path != NULL &&
		(error = git_config_add_file_ondisk(
993
			cfg, xdg_config_path, GIT_CONFIG_LEVEL_XDG, repo, 0)) < 0 &&
994 995
		error != GIT_ENOTFOUND)
		goto on_error;
996

997 998
	if (system_config_path != NULL &&
		(error = git_config_add_file_ondisk(
999
			cfg, system_config_path, GIT_CONFIG_LEVEL_SYSTEM, repo, 0)) < 0 &&
1000 1001
		error != GIT_ENOTFOUND)
		goto on_error;
1002

1003 1004
	if (programdata_path != NULL &&
		(error = git_config_add_file_ondisk(
1005
			cfg, programdata_path, GIT_CONFIG_LEVEL_PROGRAMDATA, repo, 0)) < 0 &&
1006 1007 1008
		error != GIT_ENOTFOUND)
		goto on_error;

1009
	git_error_clear(); /* clear any lingering ENOTFOUND errors */
1010

1011
	*out = cfg;
1012
	return 0;
1013

1014
on_error:
1015
	git_buf_dispose(&config_path);
1016 1017
	git_config_free(cfg);
	*out = NULL;
1018
	return error;
1019 1020
}

Russell Belfer committed
1021
static const char *path_unless_empty(git_buf *buf)
1022
{
Russell Belfer committed
1023 1024
	return git_buf_len(buf) > 0 ? git_buf_cstr(buf) : NULL;
}
1025

Russell Belfer committed
1026 1027 1028
int git_repository_config__weakptr(git_config **out, git_repository *repo)
{
	int error = 0;
1029

Russell Belfer committed
1030 1031 1032 1033
	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;
1034
		git_buf programdata_buf = GIT_BUF_INIT;
Russell Belfer committed
1035 1036
		git_config *config;

1037 1038 1039
		git_config_find_global(&global_buf);
		git_config_find_xdg(&xdg_buf);
		git_config_find_system(&system_buf);
1040
		git_config_find_programdata(&programdata_buf);
Russell Belfer committed
1041

1042 1043 1044 1045
		/* 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
1046 1047 1048 1049
		error = load_config(
			&config, repo,
			path_unless_empty(&global_buf),
			path_unless_empty(&xdg_buf),
1050 1051
			path_unless_empty(&system_buf),
			path_unless_empty(&programdata_buf));
Russell Belfer committed
1052 1053 1054
		if (!error) {
			GIT_REFCOUNT_OWN(config, repo);

1055
			config = git__compare_and_swap(&repo->_config, NULL, config);
Russell Belfer committed
1056 1057 1058 1059 1060
			if (config != NULL) {
				GIT_REFCOUNT_OWN(config, NULL);
				git_config_free(config);
			}
		}
1061

1062 1063 1064 1065
		git_buf_dispose(&global_buf);
		git_buf_dispose(&xdg_buf);
		git_buf_dispose(&system_buf);
		git_buf_dispose(&programdata_buf);
1066
	}
1067

1068
	*out = repo->_config;
Russell Belfer committed
1069
	return error;
1070 1071
}

1072
int git_repository_config(git_config **out, git_repository *repo)
1073
{
1074 1075
	if (git_repository_config__weakptr(out, repo) < 0)
		return -1;
1076

1077 1078
	GIT_REFCOUNT_INC(*out);
	return 0;
1079 1080
}

1081 1082
int git_repository_config_snapshot(git_config **out, git_repository *repo)
{
1083
	int error;
1084 1085
	git_config *weak;

1086 1087
	if ((error = git_repository_config__weakptr(&weak, repo)) < 0)
		return error;
1088 1089 1090 1091

	return git_config_snapshot(out, weak);
}

1092
int git_repository_set_config(git_repository *repo, git_config *config)
1093 1094
{
	assert(repo && config);
1095
	set_config(repo, config);
1096
	return 0;
1097 1098 1099 1100
}

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

1103 1104 1105
	assert(repo && out);

	if (repo->_odb == NULL) {
1106
		git_buf odb_path = GIT_BUF_INIT;
Russell Belfer committed
1107
		git_odb *odb;
1108

1109
		if ((error = git_repository_item_path(&odb_path, repo,
1110 1111
				GIT_REPOSITORY_ITEM_OBJECTS)) < 0 ||
			(error = git_odb_new(&odb)) < 0)
1112
			return error;
1113

1114
		GIT_REFCOUNT_OWN(odb, repo);
1115

1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
		if ((error = git_odb__set_caps(odb, GIT_ODB_CAP_FROM_OWNER)) < 0 ||
			(error = git_odb__add_default_backends(odb, odb_path.ptr, 0, 0)) < 0) {
			git_odb_free(odb);
			return error;
		}

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

1128
		git_buf_dispose(&odb_path);
1129
	}
1130

1131
	*out = repo->_odb;
Russell Belfer committed
1132
	return error;
1133 1134
}

1135
int git_repository_odb(git_odb **out, git_repository *repo)
1136
{
1137 1138
	if (git_repository_odb__weakptr(out, repo) < 0)
		return -1;
Vicent Marti committed
1139

1140 1141
	GIT_REFCOUNT_INC(*out);
	return 0;
1142
}
1143

1144
int git_repository_set_odb(git_repository *repo, git_odb *odb)
1145 1146
{
	assert(repo && odb);
1147
	set_odb(repo, odb);
1148
	return 0;
1149 1150
}

1151 1152
int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo)
{
Russell Belfer committed
1153 1154
	int error = 0;

1155 1156 1157
	assert(out && repo);

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

Russell Belfer committed
1160 1161 1162
		error = git_refdb_open(&refdb, repo);
		if (!error) {
			GIT_REFCOUNT_OWN(refdb, repo);
1163

1164
			refdb = git__compare_and_swap(&repo->_refdb, NULL, refdb);
Russell Belfer committed
1165 1166 1167 1168 1169
			if (refdb != NULL) {
				GIT_REFCOUNT_OWN(refdb, NULL);
				git_refdb_free(refdb);
			}
		}
1170 1171 1172
	}

	*out = repo->_refdb;
Russell Belfer committed
1173
	return error;
1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
}

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

1185
int git_repository_set_refdb(git_repository *repo, git_refdb *refdb)
1186
{
Russell Belfer committed
1187
	assert(repo && refdb);
1188
	set_refdb(repo, refdb);
1189
	return 0;
1190 1191
}

1192 1193
int git_repository_index__weakptr(git_index **out, git_repository *repo)
{
Russell Belfer committed
1194 1195
	int error = 0;

1196 1197 1198
	assert(out && repo);

	if (repo->_index == NULL) {
1199
		git_buf index_path = GIT_BUF_INIT;
Russell Belfer committed
1200
		git_index *index;
1201

1202
		if ((error = git_buf_joinpath(&index_path, repo->gitdir, GIT_INDEX_FILE)) < 0)
1203
			return error;
1204

Russell Belfer committed
1205 1206 1207
		error = git_index_open(&index, index_path.ptr);
		if (!error) {
			GIT_REFCOUNT_OWN(index, repo);
1208

1209
			index = git__compare_and_swap(&repo->_index, NULL, index);
Russell Belfer committed
1210 1211 1212 1213
			if (index != NULL) {
				GIT_REFCOUNT_OWN(index, NULL);
				git_index_free(index);
			}
1214

1215 1216
			error = git_index_set_caps(repo->_index,
			                           GIT_INDEX_CAPABILITY_FROM_OWNER);
Russell Belfer committed
1217
		}
1218

1219
		git_buf_dispose(&index_path);
1220 1221 1222
	}

	*out = repo->_index;
Russell Belfer committed
1223
	return error;
1224
}
Vicent Marti committed
1225

1226 1227
int git_repository_index(git_index **out, git_repository *repo)
{
1228 1229
	if (git_repository_index__weakptr(out, repo) < 0)
		return -1;
1230

1231 1232
	GIT_REFCOUNT_INC(*out);
	return 0;
1233 1234
}

1235
int git_repository_set_index(git_repository *repo, git_index *index)
1236
{
1237
	assert(repo);
1238
	set_index(repo, index);
1239
	return 0;
1240 1241
}

Vicent Marti committed
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
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;
}

1259 1260
#ifdef GIT_WIN32
static int reserved_names_add8dot3(git_repository *repo, const char *path)
1261
{
1262 1263
	char *name = git_win32_path_8dot3_name(path);
	const char *def = GIT_DIR_SHORTNAME;
1264
	const char *def_dot_git = DOT_GIT;
1265
	size_t name_len, def_len = CONST_STRLEN(GIT_DIR_SHORTNAME);
1266
	size_t def_dot_git_len = CONST_STRLEN(DOT_GIT);
1267
	git_buf *buf;
1268

1269 1270 1271 1272 1273
	if (!name)
		return 0;

	name_len = strlen(name);

1274
	if ((name_len == def_len && memcmp(name, def, def_len) == 0) ||
1275
		(name_len == def_dot_git_len && memcmp(name, def_dot_git, def_dot_git_len) == 0)) {
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
		git__free(name);
		return 0;
	}

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

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

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

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

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

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

1305 1306 1307 1308 1309 1310
		/* Try to add any repo-specific reserved names - the gitlink file
		 * within a submodule or the repository (if the repository directory
		 * is beneath the workdir).  These are typically `.git`, but should
		 * be protected in case they are not.  Note, repo and workdir paths
		 * are always prettified to end in `/`, so a prefixcmp is safe.
		 */
1311
		if (!repo->is_bare) {
1312 1313
			int (*prefixcmp)(const char *, const char *);
			int error, ignorecase;
1314

1315 1316
			error = git_repository__configmap_lookup(
				&ignorecase, repo, GIT_CONFIGMAP_IGNORECASE);
1317 1318 1319
			prefixcmp = (error || ignorecase) ? git__prefixcmp_icase :
				git__prefixcmp;

1320 1321
			if (repo->gitlink &&
				reserved_names_add8dot3(repo, repo->gitlink) < 0)
1322 1323
				goto on_error;

1324 1325 1326
			if (repo->gitdir &&
				prefixcmp(repo->gitdir, repo->workdir) == 0 &&
				reserved_names_add8dot3(repo, repo->gitdir) < 0)
1327
				goto on_error;
1328 1329 1330
		}
	}

1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
	*out = repo->reserved_names.ptr;
	*outlen = repo->reserved_names.size;

	return true;

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

	return false;
1342
}
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
#else
bool git_repository__reserved_names(
	git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs)
{
	GIT_UNUSED(repo);

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

	return true;
}
#endif
1360

1361
static int check_repositoryformatversion(int *version, git_config *config)
1362
{
1363
	int error;
1364

1365
	error = git_config_get_int32(version, config, "core.repositoryformatversion");
1366 1367 1368 1369 1370
	/* git ignores this if the config variable isn't there */
	if (error == GIT_ENOTFOUND)
		return 0;

	if (error < 0)
1371
		return -1;
1372

1373
	if (GIT_REPO_MAX_VERSION < *version) {
1374
		git_error_set(GIT_ERROR_REPOSITORY,
1375 1376
			"unsupported repository version %d; only versions up to %d are supported",
			*version, GIT_REPO_MAX_VERSION);
1377 1378
		return -1;
	}
1379

1380
	return 0;
1381 1382
}

1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401
static int check_valid_extension(const git_config_entry *entry, void *payload)
{
	GIT_UNUSED(payload);

	if (!strcmp(entry->name, "extensions.noop"))
		return 0;

	git_error_set(GIT_ERROR_REPOSITORY, "unsupported extension name %s", entry->name);
	return -1;
}

static int check_extensions(git_config *config, int version)
{
	if (version < 1)
		return 0;

	return git_config_foreach_match(config, "^extensions\\.", check_valid_extension, NULL);
}

1402
int git_repository_create_head(const char *git_dir, const char *ref_name)
1403
{
1404
	git_buf ref_path = GIT_BUF_INIT;
1405
	git_filebuf ref = GIT_FILEBUF_INIT;
1406
	const char *fmt;
1407
	int error;
1408

1409 1410 1411
	if ((error = git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE)) < 0 ||
	    (error = git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE)) < 0)
		goto out;
1412

1413
	if (git__prefixcmp(ref_name, GIT_REFS_DIR) == 0)
1414 1415
		fmt = "ref: %s\n";
	else
1416
		fmt = "ref: " GIT_REFS_HEADS_DIR "%s\n";
1417

1418 1419 1420
	if ((error = git_filebuf_printf(&ref, fmt, ref_name)) < 0 ||
	    (error = git_filebuf_commit(&ref)) < 0)
		goto out;
1421

1422
out:
1423
	git_buf_dispose(&ref_path);
1424
	git_filebuf_cleanup(&ref);
1425
	return error;
1426 1427
}

1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
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;

1441
	return (st1.st_mode != st2.st_mode);
1442 1443
}

1444 1445 1446
static bool is_filesystem_case_insensitive(const char *gitdir_path)
{
	git_buf path = GIT_BUF_INIT;
1447
	int is_insensitive = -1;
1448

1449 1450
	if (!git_buf_joinpath(&path, gitdir_path, "CoNfIg"))
		is_insensitive = git_path_exists(git_buf_cstr(&path));
1451

1452
	git_buf_dispose(&path);
1453
	return is_insensitive;
1454 1455
}

1456 1457
static bool are_symlinks_supported(const char *wd_path)
{
1458
	git_config *config = NULL;
1459 1460 1461 1462
	git_buf global_buf = GIT_BUF_INIT;
	git_buf xdg_buf = GIT_BUF_INIT;
	git_buf system_buf = GIT_BUF_INIT;
	git_buf programdata_buf = GIT_BUF_INIT;
1463
	int symlinks = 0;
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487

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

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

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

1489
	if (!(symlinks = git_path_supports_symlinks(wd_path)))
1490 1491 1492
		goto done;

done:
1493 1494 1495 1496
	git_buf_dispose(&global_buf);
	git_buf_dispose(&xdg_buf);
	git_buf_dispose(&system_buf);
	git_buf_dispose(&programdata_buf);
1497
	git_config_free(config);
1498
	return symlinks != 0;
1499 1500
}

1501 1502 1503 1504 1505
static int create_empty_file(const char *path, mode_t mode)
{
	int fd;

	if ((fd = p_creat(path, mode)) < 0) {
1506
		git_error_set(GIT_ERROR_OS, "error while creating '%s'", path);
1507 1508 1509 1510
		return -1;
	}

	if (p_close(fd) < 0) {
1511
		git_error_set(GIT_ERROR_OS, "error while closing '%s'", path);
1512 1513 1514 1515 1516 1517
		return -1;
	}

	return 0;
}

1518 1519 1520 1521 1522
static int repo_local_config(
	git_config **out,
	git_buf *config_dir,
	git_repository *repo,
	const char *repo_dir)
1523
{
1524
	int error = 0;
1525 1526
	git_config *parent;
	const char *cfg_path;
1527

1528
	if (git_buf_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
1529
		return -1;
1530
	cfg_path = git_buf_cstr(config_dir);
1531

1532
	/* make LOCAL config if missing */
1533 1534
	if (!git_path_isfile(cfg_path) &&
		(error = create_empty_file(cfg_path, GIT_CONFIG_FILE_MODE)) < 0)
1535
		return error;
1536

1537 1538 1539 1540 1541 1542 1543 1544 1545
	/* 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) {
1546
		git_error_clear();
1547 1548

		if (!(error = git_config_add_file_ondisk(
1549
				parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, repo, false)))
1550
			error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
1551
	}
1552

1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
	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)
1578
		git_error_clear();
1579

1580 1581 1582 1583 1584
	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)
1585
			git_error_clear();
1586
	}
1587

1588
#ifdef GIT_USE_ICONV
1589 1590
	if ((error = git_config_set_bool(
			cfg, "core.precomposeunicode",
1591
			git_path_does_fs_decompose_unicode(work_dir))) < 0)
1592
		return error;
1593
	/* on non-iconv platforms, don't even set core.precomposeunicode */
1594 1595
#endif

1596 1597
	return 0;
}
1598

1599 1600 1601 1602 1603 1604 1605
static int repo_init_config(
	const char *repo_dir,
	const char *work_dir,
	uint32_t flags,
	uint32_t mode)
{
	int error = 0;
1606
	git_buf cfg_path = GIT_BUF_INIT, worktree_path = GIT_BUF_INIT;
1607 1608 1609
	git_config *config = NULL;
	bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0);
	bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0);
1610
	int version = 0;
1611 1612 1613 1614

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

1615 1616 1617
	if (is_reinit && (error = check_repositoryformatversion(&version, config)) < 0)
		goto cleanup;

1618
	if ((error = check_extensions(config, version)) < 0)
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
		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;
1631

1632 1633
	if (!is_bare) {
		SET_REPO_CONFIG(bool, "core.logallrefupdates", true);
1634

1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
		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
1645
			if (git_config_delete_entry(config, "core.worktree") < 0)
1646
				git_error_clear();
1647 1648 1649
		}
	}

1650
	if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
1651 1652
		SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
1653
	}
1654
	else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
1655 1656 1657
		SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
	}
1658

1659
cleanup:
1660 1661
	git_buf_dispose(&cfg_path);
	git_buf_dispose(&worktree_path);
1662
	git_config_free(config);
1663

1664
	return error;
1665
}
1666

1667
static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
1668
{
1669 1670
	git_repository *smrepo = NULL;
	GIT_UNUSED(n); GIT_UNUSED(p);
1671

1672
	if (git_submodule_open(&smrepo, sm) < 0 ||
1673
		git_repository_reinit_filesystem(smrepo, true) < 0)
1674
		git_error_clear();
1675
	git_repository_free(smrepo);
1676

1677 1678
	return 0;
}
1679

1680
int git_repository_reinit_filesystem(git_repository *repo, int recurse)
1681 1682 1683 1684 1685
{
	int error = 0;
	git_buf path = GIT_BUF_INIT;
	git_config *config = NULL;
	const char *repo_dir = git_repository_path(repo);
1686

1687 1688 1689
	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);
1690

1691
	git_config_free(config);
1692
	git_buf_dispose(&path);
1693

1694
	git_repository__configmap_lookup_cache_clear(repo);
1695

1696
	if (!repo->is_bare && recurse)
1697
		(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
1698

1699 1700 1701
	return error;
}

1702
static int repo_write_template(
1703 1704 1705 1706
	const char *git_dir,
	bool allow_overwrite,
	const char *file,
	mode_t mode,
1707
	bool hidden,
1708
	const char *content)
1709 1710
{
	git_buf path = GIT_BUF_INIT;
1711
	int fd, error = 0, flags;
1712 1713 1714 1715

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

1716 1717 1718 1719 1720 1721
	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);
1722

1723 1724
	if (fd >= 0) {
		error = p_write(fd, content, strlen(content));
1725

1726 1727 1728 1729
		p_close(fd);
	}
	else if (errno != EEXIST)
		error = fd;
1730

1731 1732
#ifdef GIT_WIN32
	if (!error && hidden) {
1733
		if (git_win32__set_hidden(path.ptr, true) < 0)
1734 1735 1736 1737 1738 1739
			error = -1;
	}
#else
	GIT_UNUSED(hidden);
#endif

1740
	git_buf_dispose(&path);
1741 1742

	if (error)
1743
		git_error_set(GIT_ERROR_OS,
1744
			"failed to initialize repository with template '%s'", file);
1745 1746

	return error;
1747 1748
}

1749
static int repo_write_gitlink(
1750
	const char *in_dir, const char *to_repo, bool use_relative_path)
1751
{
1752 1753
	int error;
	git_buf buf = GIT_BUF_INIT;
1754
	git_buf path_to_repo = GIT_BUF_INIT;
1755 1756 1757 1758 1759
	struct stat st;

	git_path_dirname_r(&buf, to_repo);
	git_path_to_dir(&buf);
	if (git_buf_oom(&buf))
1760
		return -1;
1761

1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773
	/* 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)) {
1774
		git_error_set(GIT_ERROR_REPOSITORY,
1775
			"cannot overwrite gitlink file into path '%s'", in_dir);
1776 1777 1778 1779 1780 1781
		error = GIT_EEXISTS;
		goto cleanup;
	}

	git_buf_clear(&buf);

1782 1783 1784 1785 1786 1787 1788
	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);
1789 1790

	if (!error)
1791
		error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
1792 1793

cleanup:
1794 1795
	git_buf_dispose(&buf);
	git_buf_dispose(&path_to_repo);
1796 1797 1798
	return error;
}

1799 1800 1801
static mode_t pick_dir_mode(git_repository_init_options *opts)
{
	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_UMASK)
1802
		return 0777;
1803 1804 1805 1806 1807 1808 1809
	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;
}

1810 1811 1812 1813 1814 1815 1816
#include "repo_template.h"

static int repo_init_structure(
	const char *repo_dir,
	const char *work_dir,
	git_repository_init_options *opts)
{
1817
	int error = 0;
1818
	repo_template_item *tpl;
1819 1820 1821
	bool external_tpl =
		((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
	mode_t dmode = pick_dir_mode(opts);
1822
	bool chmod = opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK;
1823 1824

	/* Hide the ".git" directory */
1825
#ifdef GIT_WIN32
1826
	if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
1827
		if (git_win32__set_hidden(repo_dir, true) < 0) {
1828
			git_error_set(GIT_ERROR_OS,
1829
				"failed to mark Git repository folder as hidden");
1830 1831
			return -1;
		}
1832
	}
1833 1834 1835 1836 1837 1838
#endif

	/* Create the .git gitlink if appropriate */
	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
		(opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0)
	{
1839
		if (repo_write_gitlink(work_dir, repo_dir, opts->flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK) < 0)
1840
			return -1;
1841
	}
1842

1843 1844
	/* Copy external template if requested */
	if (external_tpl) {
Linquize committed
1845 1846 1847
		git_config *cfg = NULL;
		const char *tdir = NULL;
		bool default_template = false;
1848 1849
		git_buf template_buf = GIT_BUF_INIT;

1850 1851
		if (opts->template_path)
			tdir = opts->template_path;
Linquize committed
1852
		else if ((error = git_config_open_default(&cfg)) >= 0) {
1853 1854
			if (!git_config_get_path(&template_buf, cfg, "init.templatedir"))
				tdir = template_buf.ptr;
1855
			git_error_clear();
Linquize committed
1856 1857 1858
		}

		if (!tdir) {
1859
			if (!(error = git_sysdir_find_template_dir(&template_buf)))
1860
				tdir = template_buf.ptr;
Linquize committed
1861
			default_template = true;
1862
		}
1863

1864 1865 1866 1867 1868 1869 1870
		/*
		 * If tdir was the empty string, treat it like tdir was a path to an
		 * empty directory (so, don't do any copying). This is the behavior
		 * that git(1) exhibits, although it doesn't seem to be officially
		 * documented.
		 */
		if (tdir && git__strcmp(tdir, "") != 0) {
1871 1872 1873
			uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS |
				GIT_CPDIR_SIMPLE_TO_MODE |
				GIT_CPDIR_COPY_DOTFILES;
1874 1875 1876
			if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
					cpflags |= GIT_CPDIR_CHMOD_DIRS;
			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
1877
		}
1878

1879
		git_buf_dispose(&template_buf);
Linquize committed
1880
		git_config_free(cfg);
1881

1882
		if (error < 0) {
Linquize committed
1883
			if (!default_template)
1884 1885 1886
				return error;

			/* if template was default, ignore error and use internal */
1887
			git_error_clear();
1888
			external_tpl = false;
1889
			error = 0;
1890 1891 1892 1893 1894 1895 1896 1897
		}
	}

	/* 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) {
1898
		if (!tpl->content) {
1899 1900 1901 1902
			uint32_t mkdir_flags = GIT_MKDIR_PATH;
			if (chmod)
				mkdir_flags |= GIT_MKDIR_CHMOD;

1903 1904
			error = git_futils_mkdir_relative(
				tpl->path, repo_dir, dmode, mkdir_flags, NULL);
1905
		}
1906
		else if (!external_tpl) {
1907 1908 1909 1910 1911
			const char *content = tpl->content;

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

1912 1913
			error = repo_write_template(
				repo_dir, false, tpl->path, tpl->mode, false, content);
1914
		}
1915 1916
	}

1917
	return error;
1918 1919
}

1920 1921
static int mkdir_parent(git_buf *buf, uint32_t mode, bool skip2)
{
1922 1923 1924
	/* When making parent directories during repository initialization
	 * don't try to set gid or grant world write access
	 */
1925
	return git_futils_mkdir(
1926
		buf->ptr, mode & ~(S_ISGID | 0002),
1927 1928 1929 1930
		GIT_MKDIR_PATH | GIT_MKDIR_VERIFY_DIR |
		(skip2 ? GIT_MKDIR_SKIP_LAST2 : GIT_MKDIR_SKIP_LAST));
}

1931 1932 1933 1934 1935
static int repo_init_directories(
	git_buf *repo_path,
	git_buf *wd_path,
	const char *given_repo,
	git_repository_init_options *opts)
1936
{
1937
	int error = 0;
1938
	bool is_bare, add_dotgit, has_dotgit, natural_wd;
1939
	mode_t dirmode;
1940

1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
	/* 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
	 */

1961
	/* set up repo path */
1962

1963 1964
	is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);

1965 1966
	add_dotgit =
		(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
1967
		!is_bare &&
1968 1969
		git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
		git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
1970

1971 1972
	if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
		return -1;
1973

1974 1975 1976 1977 1978 1979
	has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
	if (has_dotgit)
		opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;

	/* set up workdir path */

1980
	if (!is_bare) {
1981
		if (opts->workdir_path) {
1982 1983 1984
			if (git_path_join_unrooted(
					wd_path, opts->workdir_path, repo_path->ptr, NULL) < 0)
				return -1;
1985 1986 1987 1988
		} else if (has_dotgit) {
			if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
				return -1;
		} else {
1989
			git_error_set(GIT_ERROR_REPOSITORY, "cannot pick working directory"
1990 1991 1992
				" for non-bare repository that isn't a '.git' directory");
			return -1;
		}
1993

1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
		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 */

2010
	dirmode = pick_dir_mode(opts);
2011

2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029
	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(
2030
				wd_path->ptr, dirmode & ~S_ISGID,
2031 2032 2033 2034 2035 2036
				GIT_MKDIR_VERIFY_DIR)) < 0)
			return error;

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

2042 2043 2044 2045
	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0 ||
		has_dotgit)
	{
2046
		/* create path #1 */
2047
		error = git_futils_mkdir(repo_path->ptr, dirmode,
2048
			GIT_MKDIR_VERIFY_DIR | ((dirmode & S_ISGID) ? GIT_MKDIR_CHMOD : 0));
2049
	}
2050

2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062
	/* 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;
}

2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
static int repo_init_head(const char *repo_dir, const char *given)
{
	git_config *cfg = NULL;
	git_buf head_path = GIT_BUF_INIT, cfg_branch = GIT_BUF_INIT;
	const char *initial_head = NULL;
	int error;

	if ((error = git_buf_joinpath(&head_path, repo_dir, GIT_HEAD_FILE)) < 0)
		goto out;

	/*
	 * A template may have set a HEAD; use that unless it's been
	 * overridden by the caller's given initial head setting.
	 */
	if (git_path_exists(head_path.ptr) && !given)
		goto out;

	if (given) {
		initial_head = given;
	} else if ((error = git_config_open_default(&cfg)) >= 0 &&
	           (error = git_config_get_string_buf(&cfg_branch, cfg, "init.defaultbranch")) >= 0) {
		initial_head = cfg_branch.ptr;
	}

	if (!initial_head)
		initial_head = GIT_BRANCH_DEFAULT;

	error = git_repository_create_head(repo_dir, initial_head);

out:
	git_config_free(cfg);
	git_buf_dispose(&head_path);
	git_buf_dispose(&cfg_branch);

	return error;
}

2100 2101 2102 2103 2104
static int repo_init_create_origin(git_repository *repo, const char *url)
{
	int error;
	git_remote *remote;

Ben Straub committed
2105
	if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
2106 2107 2108 2109 2110 2111 2112 2113 2114
		git_remote_free(remote);
	}

	return error;
}

int git_repository_init(
	git_repository **repo_out, const char *path, unsigned is_bare)
{
2115
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
2116 2117 2118 2119 2120 2121 2122 2123 2124

	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(
2125
	git_repository **out,
2126 2127 2128
	const char *given_repo,
	git_repository_init_options *opts)
{
2129
	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT,
2130
		common_path = GIT_BUF_INIT;
2131
	const char *wd;
2132
	bool is_valid;
2133
	int error;
2134

2135
	assert(out && given_repo && opts);
2136

2137
	GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
2138

2139 2140
	if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0)
		goto out;
2141

2142
	wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_buf_cstr(&wd_path);
2143

2144 2145 2146 2147
	if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path)) < 0)
		goto out;

	if (is_valid) {
2148
		if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
2149
			git_error_set(GIT_ERROR_REPOSITORY,
2150
				"attempt to reinitialize '%s'", given_repo);
2151
			error = GIT_EEXISTS;
2152
			goto out;
2153 2154 2155 2156
		}

		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;

2157 2158
		if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0)
			goto out;
2159 2160

		/* TODO: reinitialize the templates */
2161 2162 2163
	} else {
		if ((error = repo_init_structure(repo_path.ptr, wd, opts)) < 0 ||
		    (error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0 ||
2164
		    (error = repo_init_head(repo_path.ptr, opts->initial_head)) < 0)
2165
			goto out;
2166 2167
	}

2168 2169
	if ((error = git_repository_open(out, repo_path.ptr)) < 0)
		goto out;
2170

2171 2172 2173
	if (opts->origin_url &&
	    (error = repo_init_create_origin(*out, opts->origin_url)) < 0)
		goto out;
2174

2175
out:
2176 2177 2178
	git_buf_dispose(&common_path);
	git_buf_dispose(&repo_path);
	git_buf_dispose(&wd_path);
2179 2180

	return error;
2181
}
2182

2183
int git_repository_head_detached(git_repository *repo)
2184 2185
{
	git_reference *ref;
2186
	git_odb *odb = NULL;
2187
	int exists;
2188

2189 2190
	if (git_repository_odb__weakptr(&odb, repo) < 0)
		return -1;
2191

2192 2193
	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
		return -1;
2194

2195
	if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
2196
		git_reference_free(ref);
2197
		return 0;
2198
	}
2199

2200
	exists = git_odb_exists(odb, git_reference_target(ref));
2201 2202

	git_reference_free(ref);
2203
	return exists;
2204 2205
}

2206 2207
int git_repository_head_detached_for_worktree(git_repository *repo, const char *name)
{
2208 2209
	git_reference *ref = NULL;
	int error;
2210 2211 2212

	assert(repo && name);

2213 2214
	if ((error = git_repository_head_for_worktree(&ref, repo, name)) < 0)
		goto out;
2215

2216
	error = (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC);
2217 2218
out:
	git_reference_free(ref);
2219

2220
	return error;
2221 2222
}

2223
int git_repository_head(git_reference **head_out, git_repository *repo)
2224
{
2225
	git_reference *head;
2226 2227
	int error;

2228 2229
	assert(head_out);

2230 2231 2232
	if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
		return error;

2233
	if (git_reference_type(head) == GIT_REFERENCE_DIRECT) {
2234 2235 2236 2237
		*head_out = head;
		return 0;
	}

2238
	error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
2239
	git_reference_free(head);
2240

2241
	return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
2242 2243
}

2244 2245
int git_repository_head_for_worktree(git_reference **out, git_repository *repo, const char *name)
{
2246 2247
	git_repository *worktree_repo = NULL;
	git_worktree *worktree = NULL;
2248 2249
	git_reference *head = NULL;
	int error;
2250 2251 2252 2253 2254

	assert(out && repo && name);

	*out = NULL;

2255 2256 2257
	if ((error = git_worktree_lookup(&worktree, repo, name)) < 0 ||
	    (error = git_repository_open_from_worktree(&worktree_repo, worktree)) < 0 ||
	    (error = git_reference_lookup(&head, worktree_repo, GIT_HEAD_FILE)) < 0)
2258 2259
		goto out;

2260
	if (git_reference_type(head) != GIT_REFERENCE_DIRECT) {
2261 2262 2263 2264 2265
		if ((error = git_reference_lookup_resolved(out, worktree_repo, git_reference_symbolic_target(head), -1)) < 0)
			goto out;
	} else {
		*out = head;
		head = NULL;
2266 2267 2268
	}

out:
2269 2270 2271
	git_reference_free(head);
	git_worktree_free(worktree);
	git_repository_free(worktree_repo);
2272
	return error;
2273 2274
}

2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319
int git_repository_foreach_worktree(git_repository *repo,
				    git_repository_foreach_worktree_cb cb,
				    void *payload)
{
	git_strarray worktrees = {0};
	git_repository *worktree_repo = NULL;
	git_worktree *worktree = NULL;
	int error;
	size_t i;

	if ((error = git_repository_open(&worktree_repo, repo->commondir)) < 0 ||
	    (error = cb(worktree_repo, payload) != 0))
		goto out;

	git_repository_free(worktree_repo);
	worktree_repo = NULL;

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

	for (i = 0; i < worktrees.count; i++) {
		git_repository_free(worktree_repo);
		worktree_repo = NULL;
		git_worktree_free(worktree);
		worktree = NULL;

		if ((error = git_worktree_lookup(&worktree, repo, worktrees.strings[i]) < 0) ||
		    (error = git_repository_open_from_worktree(&worktree_repo, worktree)) < 0) {
			if (error != GIT_ENOTFOUND)
				goto out;
			error = 0;
			continue;
		}

		if ((error = cb(worktree_repo, payload)) != 0)
			goto out;
	}

out:
	git_strarray_dispose(&worktrees);
	git_repository_free(worktree_repo);
	git_worktree_free(worktree);
	return error;
}

2320
int git_repository_head_unborn(git_repository *repo)
2321
{
2322
	git_reference *ref = NULL;
2323 2324 2325
	int error;

	error = git_repository_head(&ref, repo);
2326
	git_reference_free(ref);
2327

2328
	if (error == GIT_EUNBORNBRANCH) {
2329
		git_error_clear();
2330
		return 1;
2331
	}
2332

2333 2334 2335 2336
	if (error < 0)
		return -1;

	return 0;
2337
}
2338

2339
static int at_least_one_cb(const char *refname, void *payload)
2340
{
2341 2342
	GIT_UNUSED(refname);
	GIT_UNUSED(payload);
2343
	return GIT_PASSTHROUGH;
2344
}
2345

2346 2347
static int repo_contains_no_reference(git_repository *repo)
{
2348
	int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
2349

2350
	if (error == GIT_PASSTHROUGH)
2351
		return 0;
2352

2353 2354
	if (!error)
		return 1;
2355

2356
	return error;
2357
}
2358

2359 2360 2361 2362 2363
int git_repository_initialbranch(git_buf *out, git_repository *repo)
{
	git_config *config;
	git_config_entry *entry = NULL;
	const char *branch;
2364
	int valid, error;
2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379

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

	if ((error = git_config_get_entry(&entry, config, "init.defaultbranch")) == 0) {
		branch = entry->value;
	}
	else if (error == GIT_ENOTFOUND) {
		branch = GIT_BRANCH_DEFAULT;
	}
	else {
		goto done;
	}

	if ((error = git_buf_puts(out, GIT_REFS_HEADS_DIR)) < 0 ||
2380 2381
	    (error = git_buf_puts(out, branch)) < 0 ||
	    (error = git_reference_name_is_valid(&valid, out->ptr)) < 0)
2382 2383
	    goto done;

2384
	if (!valid) {
2385 2386 2387 2388 2389 2390 2391 2392 2393
		git_error_set(GIT_ERROR_INVALID, "the value of init.defaultBranch is not a valid reference name");
		error = -1;
	}

done:
	git_config_entry_free(entry);
	return error;
}

2394 2395 2396
int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL;
2397 2398
	git_buf initialbranch = GIT_BUF_INIT;
	int result = 0;
2399

2400 2401 2402
	if ((result = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0 ||
	    (result = git_repository_initialbranch(&initialbranch, repo)) < 0)
		goto done;
2403

2404 2405 2406
	result = (git_reference_type(head) == GIT_REFERENCE_SYMBOLIC &&
	          strcmp(git_reference_symbolic_target(head), initialbranch.ptr) == 0 &&
	          repo_contains_no_reference(repo));
2407

2408
done:
2409
	git_reference_free(head);
2410
	git_buf_dispose(&initialbranch);
2411

2412
	return result;
2413 2414
}

2415
static const char *resolved_parent_path(const git_repository *repo, git_repository_item_t item, git_repository_item_t fallback)
2416 2417 2418
{
	const char *parent;

2419
	switch (item) {
2420 2421 2422 2423 2424 2425 2426 2427 2428 2429
		case GIT_REPOSITORY_ITEM_GITDIR:
			parent = git_repository_path(repo);
			break;
		case GIT_REPOSITORY_ITEM_WORKDIR:
			parent = git_repository_workdir(repo);
			break;
		case GIT_REPOSITORY_ITEM_COMMONDIR:
			parent = git_repository_commondir(repo);
			break;
		default:
2430
			git_error_set(GIT_ERROR_INVALID, "invalid item directory");
2431
			return NULL;
2432
	}
2433 2434 2435 2436 2437
	if (!parent && fallback != GIT_REPOSITORY_ITEM__LAST)
		return resolved_parent_path(repo, fallback, GIT_REPOSITORY_ITEM__LAST);

	return parent;
}
2438

2439 2440 2441
int git_repository_item_path(git_buf *out, const git_repository *repo, git_repository_item_t item)
{
	const char *parent = resolved_parent_path(repo, items[item].parent, items[item].fallback);
2442
	if (parent == NULL) {
2443
		git_error_set(GIT_ERROR_INVALID, "path cannot exist in repository");
2444
		return GIT_ENOTFOUND;
2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462
	}

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

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

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

	return 0;
}

2463
const char *git_repository_path(const git_repository *repo)
2464 2465
{
	assert(repo);
2466
	return repo->gitdir;
2467
}
2468

2469
const char *git_repository_workdir(const git_repository *repo)
2470 2471
{
	assert(repo);
2472

2473 2474
	if (repo->is_bare)
		return NULL;
2475

2476 2477
	return repo->workdir;
}
2478

2479
const char *git_repository_commondir(const git_repository *repo)
2480 2481 2482 2483 2484
{
	assert(repo);
	return repo->commondir;
}

2485 2486
int git_repository_set_workdir(
	git_repository *repo, const char *workdir, int update_gitlink)
2487
{
2488
	int error = 0;
2489 2490
	git_buf path = GIT_BUF_INIT;

2491
	assert(repo && workdir);
2492

2493 2494
	if (git_path_prettify_dir(&path, workdir, NULL) < 0)
		return -1;
2495

2496 2497
	if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
		return 0;
2498

2499 2500 2501 2502 2503 2504
	if (update_gitlink) {
		git_config *config;

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

2505
		error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);
2506 2507 2508

		/* passthrough error means gitlink is unnecessary */
		if (error == GIT_PASSTHROUGH)
Ben Straub committed
2509
			error = git_config_delete_entry(config, "core.worktree");
2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526
		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;
2527
}
2528

2529
int git_repository_is_bare(const git_repository *repo)
2530 2531 2532 2533
{
	assert(repo);
	return repo->is_bare;
}
2534

2535
int git_repository_is_worktree(const git_repository *repo)
2536 2537 2538 2539 2540
{
	assert(repo);
	return repo->is_worktree;
}

2541 2542 2543 2544 2545 2546 2547 2548 2549 2550
int git_repository_set_bare(git_repository *repo)
{
	int error;
	git_config *config;

	assert(repo);

	if (repo->is_bare)
		return 0;

2551 2552 2553
	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
		return error;

2554
	if ((error = git_config_set_bool(config, "core.bare", true)) < 0)
2555
		return error;
2556

2557 2558
	if ((error = git_config__update_entry(config, "core.worktree", NULL, true, true)) < 0)
		return error;
2559 2560 2561 2562 2563

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

2564
	return 0;
2565 2566
}

2567 2568
int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
2569 2570 2571
	git_reference *head;
	git_object *obj;
	int error;
2572

2573 2574
	if ((error = git_repository_head(&head, repo)) < 0)
		return error;
2575

2576
	if ((error = git_reference_peel(&obj, head, GIT_OBJECT_TREE)) < 0)
2577
		goto cleanup;
2578 2579

	*tree = (git_tree *)obj;
2580 2581 2582 2583

cleanup:
	git_reference_free(head);
	return error;
2584
}
2585

2586 2587 2588 2589 2590 2591 2592 2593 2594
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);

2595
	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 &&
2596
		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) == 0 &&
2597 2598 2599 2600 2601 2602
		(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);

2603
	git_buf_dispose(&file_path);
2604 2605 2606 2607

	return error;
}

2608
int git_repository_message(git_buf *out, git_repository *repo)
2609
{
2610
	git_buf path = GIT_BUF_INIT;
Vicent Marti committed
2611 2612
	struct stat st;
	int error;
2613

2614 2615
	if ((error = git_buf_sanitize(out)) < 0)
		return error;
2616

2617
	if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
2618
		return -1;
2619

2620
	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
2621 2622
		if (errno == ENOENT)
			error = GIT_ENOTFOUND;
2623
		git_error_set(GIT_ERROR_OS, "could not access message file");
2624 2625
	} else {
		error = git_futils_readbuffer(out, git_buf_cstr(&path));
Vicent Marti committed
2626
	}
2627

2628
	git_buf_dispose(&path);
2629 2630

	return error;
2631 2632 2633 2634
}

int git_repository_message_remove(git_repository *repo)
{
Vicent Marti committed
2635 2636
	git_buf path = GIT_BUF_INIT;
	int error;
2637

2638
	if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
2639
		return -1;
2640 2641

	error = p_unlink(git_buf_cstr(&path));
2642
	git_buf_dispose(&path);
2643 2644 2645

	return error;
}
2646 2647

int git_repository_hashfile(
Linquize committed
2648 2649 2650
	git_oid *out,
	git_repository *repo,
	const char *path,
2651
	git_object_t type,
Linquize committed
2652
	const char *as_path)
2653 2654
{
	int error;
2655
	git_filter_list *fl = NULL;
2656
	git_file fd = -1;
2657
	uint64_t len;
2658 2659
	git_buf full_path = GIT_BUF_INIT;

2660 2661 2662 2663 2664 2665
	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.
	 */
2666 2667

	error = git_path_join_unrooted(
2668
		&full_path, path, git_repository_workdir(repo), NULL);
2669 2670 2671 2672 2673 2674 2675 2676
	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
2677
		error = git_filter_list_load(
2678
			&fl, repo, NULL, as_path,
2679
			GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);
2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693
		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;
	}

2694
	if ((error = git_futils_filesize(&len, fd)) < 0)
2695 2696 2697
		goto cleanup;

	if (!git__is_sizet(len)) {
2698
		git_error_set(GIT_ERROR_OS, "file size overflow for 32-bit systems");
2699 2700 2701 2702
		error = -1;
		goto cleanup;
	}

2703
	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
2704 2705

cleanup:
2706 2707
	if (fd >= 0)
		p_close(fd);
2708
	git_filter_list_free(fl);
2709
	git_buf_dispose(&full_path);
2710 2711 2712 2713

	return error;
}

2714
static int checkout_message(git_buf *out, git_reference *old, const char *new)
2715
{
2716 2717
	git_buf_puts(out, "checkout: moving from ");

2718
	if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC)
2719 2720 2721 2722 2723 2724
		git_buf_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
	else
		git_buf_puts(out, git_oid_tostr_s(git_reference_target(old)));

	git_buf_puts(out, " to ");

2725 2726 2727
	if (git_reference__is_branch(new) ||
		git_reference__is_tag(new) ||
		git_reference__is_remote(new))
2728 2729 2730 2731 2732 2733 2734 2735
		git_buf_puts(out, git_reference__shorthand(new));
	else
		git_buf_puts(out, new);

	if (git_buf_oom(out))
		return -1;

	return 0;
2736 2737
}

2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749
static int detach(git_repository *repo, const git_oid *id, const char *new)
{
	int error;
	git_buf log_message = GIT_BUF_INIT;
	git_object *object = NULL, *peeled = NULL;
	git_reference *new_head = NULL, *current = NULL;

	assert(repo && id);

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

2750
	if ((error = git_object_lookup(&object, repo, id, GIT_OBJECT_ANY)) < 0)
2751 2752
		goto cleanup;

2753
	if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0)
2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764
		goto cleanup;

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

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

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

cleanup:
2765
	git_buf_dispose(&log_message);
2766 2767 2768 2769 2770 2771 2772
	git_object_free(object);
	git_object_free(peeled);
	git_reference_free(current);
	git_reference_free(new_head);
	return error;
}

2773 2774
int git_repository_set_head(
	git_repository* repo,
2775
	const char* refname)
2776
{
2777 2778
	git_reference *ref = NULL, *current = NULL, *new_head = NULL;
	git_buf log_message = GIT_BUF_INIT;
2779 2780 2781 2782
	int error;

	assert(repo && refname);

2783 2784 2785 2786 2787 2788
	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
		return error;

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

2789 2790
	error = git_reference_lookup(&ref, repo, refname);
	if (error < 0 && error != GIT_ENOTFOUND)
2791
		goto cleanup;
2792

2793
	if (ref && current->type == GIT_REFERENCE_SYMBOLIC && git__strcmp(current->target.symbolic, ref->name) &&
2794
	    git_reference_is_branch(ref) && git_branch_is_checked_out(ref)) {
2795
		git_error_set(GIT_ERROR_REPOSITORY, "cannot set HEAD to reference '%s' as it is the current HEAD "
2796
			"of a linked repository.", git_reference_name(ref));
2797 2798 2799 2800
		error = -1;
		goto cleanup;
	}

2801
	if (!error) {
2802 2803
		if (git_reference_is_branch(ref)) {
			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
2804
					git_reference_name(ref), true, git_buf_cstr(&log_message));
2805
		} else {
2806
			error = detach(repo, git_reference_target(ref),
2807
				git_reference_is_tag(ref) || git_reference_is_remote(ref) ? refname : NULL);
2808
		}
2809
	} else if (git_reference__is_branch(refname)) {
2810
		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
2811
				true, git_buf_cstr(&log_message));
2812
	}
2813

2814
cleanup:
2815
	git_buf_dispose(&log_message);
2816
	git_reference_free(current);
2817 2818 2819 2820 2821
	git_reference_free(ref);
	git_reference_free(new_head);
	return error;
}

2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834
int git_repository_set_head_detached(
	git_repository* repo,
	const git_oid* commitish)
{
	return detach(repo, commitish, NULL);
}

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

2835
	return detach(repo, git_annotated_commit_id(commitish), commitish->description);
2836 2837
}

2838
int git_repository_detach_head(git_repository* repo)
2839
{
2840
	git_reference *old_head = NULL,	*new_head = NULL, *current = NULL;
2841
	git_object *object = NULL;
2842
	git_buf log_message = GIT_BUF_INIT;
2843
	int error;
2844 2845 2846

	assert(repo);

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

2850 2851 2852
	if ((error = git_repository_head(&old_head, repo)) < 0)
		goto cleanup;

2853
	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0)
2854 2855
		goto cleanup;

2856 2857 2858
	if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
		goto cleanup;

2859
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
2860
			1, git_buf_cstr(&log_message));
2861 2862

cleanup:
2863
	git_buf_dispose(&log_message);
2864 2865 2866
	git_object_free(object);
	git_reference_free(old_head);
	git_reference_free(new_head);
2867
	git_reference_free(current);
2868 2869
	return error;
}
Edward Thomson committed
2870

2871 2872 2873 2874
/**
 * Loosely ported from git.git
 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
 */
Edward Thomson committed
2875 2876 2877 2878 2879 2880 2881
int git_repository_state(git_repository *repo)
{
	git_buf repo_path = GIT_BUF_INIT;
	int state = GIT_REPOSITORY_STATE_NONE;

	assert(repo);

2882
	if (git_buf_puts(&repo_path, repo->gitdir) < 0)
Edward Thomson committed
2883 2884
		return -1;

2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895
	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
2896
		state = GIT_REPOSITORY_STATE_MERGE;
2897
	else if (git_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE)) {
Edward Thomson committed
2898
		state = GIT_REPOSITORY_STATE_REVERT;
2899 2900 2901 2902
		if (git_path_contains_file(&repo_path, GIT_SEQUENCER_TODO_FILE)) {
			state = GIT_REPOSITORY_STATE_REVERT_SEQUENCE;
		}
	} else if (git_path_contains_file(&repo_path, GIT_CHERRYPICK_HEAD_FILE)) {
2903
		state = GIT_REPOSITORY_STATE_CHERRYPICK;
2904 2905 2906 2907
		if (git_path_contains_file(&repo_path, GIT_SEQUENCER_TODO_FILE)) {
			state = GIT_REPOSITORY_STATE_CHERRYPICK_SEQUENCE;
		}
	} else if (git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
2908
		state = GIT_REPOSITORY_STATE_BISECT;
Edward Thomson committed
2909

2910
	git_buf_dispose(&repo_path);
Edward Thomson committed
2911 2912
	return state;
}
Ben Straub committed
2913

2914 2915
int git_repository__cleanup_files(
	git_repository *repo, const char *files[], size_t files_len)
2916
{
2917
	git_buf buf = GIT_BUF_INIT;
2918
	size_t i;
2919
	int error;
2920

2921 2922
	for (error = 0, i = 0; !error && i < files_len; ++i) {
		const char *path;
2923

2924
		if (git_buf_joinpath(&buf, repo->gitdir, files[i]) < 0)
2925
			return -1;
2926

2927 2928 2929 2930 2931 2932 2933 2934
		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);
		}
2935

2936 2937
		git_buf_clear(&buf);
	}
2938

2939
	git_buf_dispose(&buf);
2940 2941 2942 2943 2944 2945 2946 2947
	return error;
}

static const char *state_files[] = {
	GIT_MERGE_HEAD_FILE,
	GIT_MERGE_MODE_FILE,
	GIT_MERGE_MSG_FILE,
	GIT_REVERT_HEAD_FILE,
2948
	GIT_CHERRYPICK_HEAD_FILE,
2949 2950 2951
	GIT_BISECT_LOG_FILE,
	GIT_REBASE_MERGE_DIR,
	GIT_REBASE_APPLY_DIR,
2952
	GIT_SEQUENCER_DIR,
2953 2954 2955 2956 2957 2958 2959 2960 2961
};

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
2962 2963 2964 2965
int git_repository_is_shallow(git_repository *repo)
{
	git_buf path = GIT_BUF_INIT;
	struct stat st;
Ben Straub committed
2966
	int error;
Ben Straub committed
2967

2968
	if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0)
2969 2970
		return error;

Ben Straub committed
2971
	error = git_path_lstat(path.ptr, &st);
2972
	git_buf_dispose(&path);
Ben Straub committed
2973

2974
	if (error == GIT_ENOTFOUND) {
2975
		git_error_clear();
Ben Straub committed
2976
		return 0;
2977 2978
	}

Ben Straub committed
2979 2980 2981
	if (error < 0)
		return error;
	return st.st_size == 0 ? 0 : 1;
Ben Straub committed
2982
}
2983

2984
int git_repository_init_options_init(
2985
	git_repository_init_options *opts, unsigned int version)
2986
{
2987 2988 2989 2990
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_repository_init_options,
		GIT_REPOSITORY_INIT_OPTIONS_INIT);
	return 0;
2991
}
2992

2993
#ifndef GIT_DEPRECATE_HARD
2994 2995 2996 2997 2998
int git_repository_init_init_options(
	git_repository_init_options *opts, unsigned int version)
{
	return git_repository_init_options_init(opts, version);
}
2999
#endif
3000

3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014
int git_repository_ident(const char **name, const char **email, const git_repository *repo)
{
	*name = repo->ident_name;
	*email = repo->ident_email;

	return 0;
}

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

	if (name) {
		tmp_name = git__strdup(name);
3015
		GIT_ERROR_CHECK_ALLOC(tmp_name);
3016 3017 3018 3019
	}

	if (email) {
		tmp_email = git__strdup(email);
3020
		GIT_ERROR_CHECK_ALLOC(tmp_email);
3021 3022 3023 3024 3025 3026 3027 3028 3029 3030
	}

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

	git__free(tmp_name);
	git__free(tmp_email);

	return 0;
}
3031 3032 3033 3034 3035 3036 3037

int git_repository_submodule_cache_all(git_repository *repo)
{
	int error;

	assert(repo);

3038
	if ((error = git_strmap_new(&repo->submodule_cache)))
3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058
		return error;

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

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