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

#include "repository.h"

10
#include <ctype.h>
11

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

15 16 17
#include "common.h"
#include "commit.h"
#include "tag.h"
18
#include "blob.h"
19
#include "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 74
#define GIT_BRANCH_MASTER "master"

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 863
	if (config && (error = check_repositoryformatversion(&version, config)) < 0)
		goto cleanup;

	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 948
	const char *start_path,
	int across_fs,
	const char *ceiling_dirs)
{
	uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;

949
	assert(start_path);
950

951
	git_buf_sanitize(out);
952

953
	return find_repo(out, NULL, NULL, NULL, start_path, flags, ceiling_dirs);
954 955
}

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

968
	assert(out);
969

970 971
	if ((error = git_config_new(&cfg)) < 0)
		return error;
972

973 974 975
	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);
976

977 978
		if (error && error != GIT_ENOTFOUND)
			goto on_error;
979

980 981
		git_buf_dispose(&config_path);
	}
982

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

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

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

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

1007
	git_error_clear(); /* clear any lingering ENOTFOUND errors */
1008

1009
	*out = cfg;
1010
	return 0;
1011

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

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

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

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

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

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

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

1060 1061 1062 1063
		git_buf_dispose(&global_buf);
		git_buf_dispose(&xdg_buf);
		git_buf_dispose(&system_buf);
		git_buf_dispose(&programdata_buf);
1064
	}
1065

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

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

1075 1076
	GIT_REFCOUNT_INC(*out);
	return 0;
1077 1078
}

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

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

	return git_config_snapshot(out, weak);
}

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

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

1101 1102 1103
	assert(repo && out);

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

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

1112
		GIT_REFCOUNT_OWN(odb, repo);
1113

1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
		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
1124
		}
1125

1126
		git_buf_dispose(&odb_path);
1127
	}
1128

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

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

1138 1139
	GIT_REFCOUNT_INC(*out);
	return 0;
1140
}
1141

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

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

1153 1154 1155
	assert(out && repo);

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

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

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

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

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

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

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

1194 1195 1196
	assert(out && repo);

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

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

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

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

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

1217
		git_buf_dispose(&index_path);
1218 1219 1220
	}

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

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

1229 1230
	GIT_REFCOUNT_INC(*out);
	return 0;
1231 1232
}

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

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

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

1267 1268 1269 1270 1271
	if (!name)
		return 0;

	name_len = strlen(name);

1272
	if ((name_len == def_len && memcmp(name, def, def_len) == 0) ||
1273
		(name_len == def_dot_git_len && memcmp(name, def_dot_git, def_dot_git_len) == 0)) {
1274 1275 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
		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;
		}

1303 1304 1305 1306 1307 1308
		/* 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.
		 */
1309
		if (!repo->is_bare) {
1310 1311
			int (*prefixcmp)(const char *, const char *);
			int error, ignorecase;
1312

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

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

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

1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339
	*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;
1340
}
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
#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
1358

1359
static int check_repositoryformatversion(int *version, git_config *config)
1360
{
1361
	int error;
1362

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

	if (error < 0)
1369
		return -1;
1370

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

1378
	return 0;
1379 1380
}

1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
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);
}

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

1407 1408 1409
	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;
1410 1411 1412 1413

	if (!ref_name)
		ref_name = GIT_BRANCH_MASTER;

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

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

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

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

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

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

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

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

1457 1458
static bool are_symlinks_supported(const char *wd_path)
{
1459
	git_config *config = NULL;
1460 1461 1462 1463
	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;
1464
	int symlinks = 0;
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488

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

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

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

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

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

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

	return 0;
}

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

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

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

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

		if (!(error = git_config_add_file_ondisk(
1550
				parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, repo, false)))
1551
			error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
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 1578
	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)
1579
		git_error_clear();
1580

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

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

1597 1598
	return 0;
}
1599

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

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

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

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

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

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

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

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

1665
	return error;
1666
}
1667

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

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

1678 1679
	return 0;
}
1680

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

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

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

1695
	git_repository__configmap_lookup_cache_clear(repo);
1696

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

1700 1701 1702
	return error;
}

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

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

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

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

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

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

1741
	git_buf_dispose(&path);
1742 1743

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

	return error;
1748 1749
}

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

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

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

	git_buf_clear(&buf);

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

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

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

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

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

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

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

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

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

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

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

1865 1866 1867 1868 1869 1870 1871
		/*
		 * 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) {
1872 1873 1874
			uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS |
				GIT_CPDIR_SIMPLE_TO_MODE |
				GIT_CPDIR_COPY_DOTFILES;
1875 1876 1877
			if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
					cpflags |= GIT_CPDIR_CHMOD_DIRS;
			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
1878
		}
1879

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

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

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

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

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

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

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

1918
	return error;
1919 1920
}

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

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

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

1962
	/* set up repo path */
1963

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

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

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

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

	/* set up workdir path */

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

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

2011
	dirmode = pick_dir_mode(opts);
2012

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

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

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

2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
	/* 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
2069
	if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
2070 2071 2072 2073 2074 2075 2076 2077 2078
		git_remote_free(remote);
	}

	return error;
}

int git_repository_init(
	git_repository **repo_out, const char *path, unsigned is_bare)
{
2079
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
2080 2081 2082 2083 2084 2085 2086 2087 2088

	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(
2089
	git_repository **out,
2090 2091 2092
	const char *given_repo,
	git_repository_init_options *opts)
{
2093
	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT,
2094
		common_path = GIT_BUF_INIT, head_path = GIT_BUF_INIT;
2095
	const char *wd;
2096
	bool is_valid;
2097
	int error;
2098

2099
	assert(out && given_repo && opts);
2100

2101
	GIT_ERROR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
2102

2103 2104
	if ((error = repo_init_directories(&repo_path, &wd_path, given_repo, opts)) < 0)
		goto out;
2105

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

2108 2109 2110 2111
	if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path)) < 0)
		goto out;

	if (is_valid) {
2112
		if ((opts->flags & GIT_REPOSITORY_INIT_NO_REINIT) != 0) {
2113
			git_error_set(GIT_ERROR_REPOSITORY,
2114
				"attempt to reinitialize '%s'", given_repo);
2115
			error = GIT_EEXISTS;
2116
			goto out;
2117 2118 2119 2120
		}

		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;

2121 2122
		if ((error = repo_init_config(repo_path.ptr, wd, opts->flags, opts->mode)) < 0)
			goto out;
2123 2124

		/* TODO: reinitialize the templates */
2125 2126 2127
	} 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 ||
2128 2129 2130 2131 2132 2133 2134 2135 2136
		    (error = git_buf_joinpath(&head_path, repo_path.ptr, GIT_HEAD_FILE)) < 0)
			goto out;

		/*
		 * Only set the new HEAD if the file does not exist already via
		 * a template or if the caller has explicitly supplied an
		 * initial HEAD value.
		 */
		if ((!git_path_exists(head_path.ptr) || opts->initial_head) &&
2137 2138
		    (error = git_repository_create_head(repo_path.ptr, opts->initial_head)) < 0)
			goto out;
2139 2140
	}

2141 2142
	if ((error = git_repository_open(out, repo_path.ptr)) < 0)
		goto out;
2143

2144 2145 2146
	if (opts->origin_url &&
	    (error = repo_init_create_origin(*out, opts->origin_url)) < 0)
		goto out;
2147

2148
out:
2149
	git_buf_dispose(&head_path);
2150 2151 2152
	git_buf_dispose(&common_path);
	git_buf_dispose(&repo_path);
	git_buf_dispose(&wd_path);
2153 2154

	return error;
2155
}
2156

2157
int git_repository_head_detached(git_repository *repo)
2158 2159
{
	git_reference *ref;
2160
	git_odb *odb = NULL;
2161
	int exists;
2162

2163 2164
	if (git_repository_odb__weakptr(&odb, repo) < 0)
		return -1;
2165

2166 2167
	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
		return -1;
2168

2169
	if (git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC) {
2170
		git_reference_free(ref);
2171
		return 0;
2172
	}
2173

2174
	exists = git_odb_exists(odb, git_reference_target(ref));
2175 2176

	git_reference_free(ref);
2177
	return exists;
2178 2179
}

2180 2181 2182 2183 2184 2185
static int get_worktree_file_path(git_buf *out, git_repository *repo, const char *worktree, const char *file)
{
	git_buf_clear(out);
	return git_buf_printf(out, "%s/worktrees/%s/%s", repo->commondir, worktree, file);
}

2186 2187
int git_repository_head_detached_for_worktree(git_repository *repo, const char *name)
{
2188 2189
	git_reference *ref = NULL;
	int error;
2190 2191 2192

	assert(repo && name);

2193 2194
	if ((error = git_repository_head_for_worktree(&ref, repo, name)) < 0)
		goto out;
2195

2196
	error = (git_reference_type(ref) != GIT_REFERENCE_SYMBOLIC);
2197 2198
out:
	git_reference_free(ref);
2199

2200
	return error;
2201 2202
}

2203
int git_repository_head(git_reference **head_out, git_repository *repo)
2204
{
2205
	git_reference *head;
2206 2207
	int error;

2208 2209
	assert(head_out);

2210 2211 2212
	if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
		return error;

2213
	if (git_reference_type(head) == GIT_REFERENCE_DIRECT) {
2214 2215 2216 2217
		*head_out = head;
		return 0;
	}

2218
	error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
2219
	git_reference_free(head);
2220

2221
	return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
2222 2223
}

2224 2225
int git_repository_head_for_worktree(git_reference **out, git_repository *repo, const char *name)
{
2226 2227 2228
	git_buf path = GIT_BUF_INIT;
	git_reference *head = NULL;
	int error;
2229 2230 2231 2232 2233

	assert(out && repo && name);

	*out = NULL;

2234 2235
	if ((error = get_worktree_file_path(&path, repo, name, GIT_HEAD_FILE)) < 0 ||
	    (error = git_reference__read_head(&head, repo, path.ptr)) < 0)
2236 2237
		goto out;

2238
	if (git_reference_type(head) != GIT_REFERENCE_DIRECT) {
2239
		git_reference *resolved;
2240

2241 2242 2243
		error = git_reference_lookup_resolved(&resolved, repo, git_reference_symbolic_target(head), -1);
		git_reference_free(head);
		head = resolved;
2244 2245
	}

2246
	*out = head;
2247 2248

out:
2249 2250
	if (error)
		git_reference_free(head);
2251

2252
	git_buf_dispose(&path);
2253

2254
	return error;
2255 2256
}

2257 2258 2259
int git_repository_foreach_head(git_repository *repo,
				git_repository_foreach_head_cb cb,
				int flags, void *payload)
2260 2261 2262
{
	git_strarray worktrees = GIT_VECTOR_INIT;
	git_buf path = GIT_BUF_INIT;
2263
	int error = 0;
2264 2265 2266
	size_t i;


2267 2268 2269 2270 2271
	if (!(flags & GIT_REPOSITORY_FOREACH_HEAD_SKIP_REPO)) {
		/* Gather HEAD of main repository */
		if ((error = git_buf_joinpath(&path, repo->commondir, GIT_HEAD_FILE)) < 0 ||
		    (error = cb(repo, path.ptr, payload) != 0))
			goto out;
2272 2273
	}

2274 2275 2276
	if (!(flags & GIT_REPOSITORY_FOREACH_HEAD_SKIP_WORKTREES)) {
		if ((error = git_worktree_list(&worktrees, repo)) < 0) {
			error = 0;
2277
			goto out;
2278 2279 2280 2281 2282 2283 2284 2285 2286 2287
		}

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

			if ((error = cb(repo, path.ptr, payload)) != 0)
				goto out;
		}
2288 2289 2290
	}

out:
2291
	git_buf_dispose(&path);
2292
	git_strarray_dispose(&worktrees);
2293 2294 2295
	return error;
}

2296
int git_repository_head_unborn(git_repository *repo)
2297
{
2298
	git_reference *ref = NULL;
2299 2300 2301
	int error;

	error = git_repository_head(&ref, repo);
2302
	git_reference_free(ref);
2303

2304
	if (error == GIT_EUNBORNBRANCH) {
2305
		git_error_clear();
2306
		return 1;
2307
	}
2308

2309 2310 2311 2312
	if (error < 0)
		return -1;

	return 0;
2313
}
2314

2315
static int at_least_one_cb(const char *refname, void *payload)
2316
{
2317 2318
	GIT_UNUSED(refname);
	GIT_UNUSED(payload);
2319
	return GIT_PASSTHROUGH;
2320
}
2321

2322 2323
static int repo_contains_no_reference(git_repository *repo)
{
2324
	int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
2325

2326
	if (error == GIT_PASSTHROUGH)
2327
		return 0;
2328

2329 2330
	if (!error)
		return 1;
2331

2332
	return error;
2333
}
2334

2335 2336 2337
int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL;
2338
	int is_empty = 0;
2339

2340
	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0)
2341 2342
		return -1;

2343
	if (git_reference_type(head) == GIT_REFERENCE_SYMBOLIC)
2344 2345 2346 2347
		is_empty =
			(strcmp(git_reference_symbolic_target(head),
					GIT_REFS_HEADS_DIR "master") == 0) &&
			repo_contains_no_reference(repo);
2348 2349

	git_reference_free(head);
2350 2351

	return is_empty;
2352 2353
}

2354
static const char *resolved_parent_path(const git_repository *repo, git_repository_item_t item, git_repository_item_t fallback)
2355 2356 2357
{
	const char *parent;

2358
	switch (item) {
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
		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:
2369
			git_error_set(GIT_ERROR_INVALID, "invalid item directory");
2370
			return NULL;
2371
	}
2372 2373 2374 2375 2376
	if (!parent && fallback != GIT_REPOSITORY_ITEM__LAST)
		return resolved_parent_path(repo, fallback, GIT_REPOSITORY_ITEM__LAST);

	return parent;
}
2377

2378 2379 2380
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);
2381
	if (parent == NULL) {
2382
		git_error_set(GIT_ERROR_INVALID, "path cannot exist in repository");
2383
		return GIT_ENOTFOUND;
2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401
	}

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

2402
const char *git_repository_path(const git_repository *repo)
2403 2404
{
	assert(repo);
2405
	return repo->gitdir;
2406
}
2407

2408
const char *git_repository_workdir(const git_repository *repo)
2409 2410
{
	assert(repo);
2411

2412 2413
	if (repo->is_bare)
		return NULL;
2414

2415 2416
	return repo->workdir;
}
2417

2418
const char *git_repository_commondir(const git_repository *repo)
2419 2420 2421 2422 2423
{
	assert(repo);
	return repo->commondir;
}

2424 2425
int git_repository_set_workdir(
	git_repository *repo, const char *workdir, int update_gitlink)
2426
{
2427
	int error = 0;
2428 2429
	git_buf path = GIT_BUF_INIT;

2430
	assert(repo && workdir);
2431

2432 2433
	if (git_path_prettify_dir(&path, workdir, NULL) < 0)
		return -1;
2434

2435 2436
	if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
		return 0;
2437

2438 2439 2440 2441 2442 2443
	if (update_gitlink) {
		git_config *config;

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

2444
		error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);
2445 2446 2447

		/* passthrough error means gitlink is unnecessary */
		if (error == GIT_PASSTHROUGH)
Ben Straub committed
2448
			error = git_config_delete_entry(config, "core.worktree");
2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465
		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;
2466
}
2467

2468
int git_repository_is_bare(const git_repository *repo)
2469 2470 2471 2472
{
	assert(repo);
	return repo->is_bare;
}
2473

2474
int git_repository_is_worktree(const git_repository *repo)
2475 2476 2477 2478 2479
{
	assert(repo);
	return repo->is_worktree;
}

2480 2481 2482 2483 2484 2485 2486 2487 2488 2489
int git_repository_set_bare(git_repository *repo)
{
	int error;
	git_config *config;

	assert(repo);

	if (repo->is_bare)
		return 0;

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

2493
	if ((error = git_config_set_bool(config, "core.bare", true)) < 0)
2494
		return error;
2495

2496 2497
	if ((error = git_config__update_entry(config, "core.worktree", NULL, true, true)) < 0)
		return error;
2498 2499 2500 2501 2502

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

2503
	return 0;
2504 2505
}

2506 2507
int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
2508 2509 2510
	git_reference *head;
	git_object *obj;
	int error;
2511

2512 2513
	if ((error = git_repository_head(&head, repo)) < 0)
		return error;
2514

2515
	if ((error = git_reference_peel(&obj, head, GIT_OBJECT_TREE)) < 0)
2516
		goto cleanup;
2517 2518

	*tree = (git_tree *)obj;
2519 2520 2521 2522

cleanup:
	git_reference_free(head);
	return error;
2523
}
2524

2525 2526 2527 2528 2529 2530 2531 2532 2533
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);

2534
	if ((error = git_buf_joinpath(&file_path, repo->gitdir, GIT_ORIG_HEAD_FILE)) == 0 &&
2535
		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_CREATE_LEADING_DIRS, GIT_MERGE_FILE_MODE)) == 0 &&
2536 2537 2538 2539 2540 2541
		(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);

2542
	git_buf_dispose(&file_path);
2543 2544 2545 2546

	return error;
}

2547
int git_repository_message(git_buf *out, git_repository *repo)
2548
{
2549
	git_buf path = GIT_BUF_INIT;
Vicent Marti committed
2550 2551
	struct stat st;
	int error;
2552

2553
	git_buf_sanitize(out);
2554

2555
	if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
2556
		return -1;
2557

2558
	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
2559 2560
		if (errno == ENOENT)
			error = GIT_ENOTFOUND;
2561
		git_error_set(GIT_ERROR_OS, "could not access message file");
2562 2563
	} else {
		error = git_futils_readbuffer(out, git_buf_cstr(&path));
Vicent Marti committed
2564
	}
2565

2566
	git_buf_dispose(&path);
2567 2568

	return error;
2569 2570 2571 2572
}

int git_repository_message_remove(git_repository *repo)
{
Vicent Marti committed
2573 2574
	git_buf path = GIT_BUF_INIT;
	int error;
2575

2576
	if (git_buf_joinpath(&path, repo->gitdir, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
2577
		return -1;
2578 2579

	error = p_unlink(git_buf_cstr(&path));
2580
	git_buf_dispose(&path);
2581 2582 2583

	return error;
}
2584 2585

int git_repository_hashfile(
Linquize committed
2586 2587 2588
	git_oid *out,
	git_repository *repo,
	const char *path,
2589
	git_object_t type,
Linquize committed
2590
	const char *as_path)
2591 2592
{
	int error;
2593
	git_filter_list *fl = NULL;
2594
	git_file fd = -1;
2595
	uint64_t len;
2596 2597
	git_buf full_path = GIT_BUF_INIT;

2598 2599 2600 2601 2602 2603
	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.
	 */
2604 2605

	error = git_path_join_unrooted(
2606
		&full_path, path, git_repository_workdir(repo), NULL);
2607 2608 2609 2610 2611 2612 2613 2614
	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
2615
		error = git_filter_list_load(
2616
			&fl, repo, NULL, as_path,
2617
			GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);
2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631
		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;
	}

2632
	if ((error = git_futils_filesize(&len, fd)) < 0)
2633 2634 2635
		goto cleanup;

	if (!git__is_sizet(len)) {
2636
		git_error_set(GIT_ERROR_OS, "file size overflow for 32-bit systems");
2637 2638 2639 2640
		error = -1;
		goto cleanup;
	}

2641
	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
2642 2643

cleanup:
2644 2645
	if (fd >= 0)
		p_close(fd);
2646
	git_filter_list_free(fl);
2647
	git_buf_dispose(&full_path);
2648 2649 2650 2651

	return error;
}

2652
static int checkout_message(git_buf *out, git_reference *old, const char *new)
2653
{
2654 2655
	git_buf_puts(out, "checkout: moving from ");

2656
	if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC)
2657 2658 2659 2660 2661 2662
		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 ");

2663 2664 2665
	if (git_reference__is_branch(new) ||
		git_reference__is_tag(new) ||
		git_reference__is_remote(new))
2666 2667 2668 2669 2670 2671 2672 2673
		git_buf_puts(out, git_reference__shorthand(new));
	else
		git_buf_puts(out, new);

	if (git_buf_oom(out))
		return -1;

	return 0;
2674 2675
}

2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687
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;

2688
	if ((error = git_object_lookup(&object, repo, id, GIT_OBJECT_ANY)) < 0)
2689 2690
		goto cleanup;

2691
	if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0)
2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702
		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:
2703
	git_buf_dispose(&log_message);
2704 2705 2706 2707 2708 2709 2710
	git_object_free(object);
	git_object_free(peeled);
	git_reference_free(current);
	git_reference_free(new_head);
	return error;
}

2711 2712
int git_repository_set_head(
	git_repository* repo,
2713
	const char* refname)
2714
{
2715 2716
	git_reference *ref = NULL, *current = NULL, *new_head = NULL;
	git_buf log_message = GIT_BUF_INIT;
2717 2718 2719 2720
	int error;

	assert(repo && refname);

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

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

2727 2728
	error = git_reference_lookup(&ref, repo, refname);
	if (error < 0 && error != GIT_ENOTFOUND)
2729
		goto cleanup;
2730

2731
	if (ref && current->type == GIT_REFERENCE_SYMBOLIC && git__strcmp(current->target.symbolic, ref->name) &&
2732
	    git_reference_is_branch(ref) && git_branch_is_checked_out(ref)) {
2733
		git_error_set(GIT_ERROR_REPOSITORY, "cannot set HEAD to reference '%s' as it is the current HEAD "
2734
			"of a linked repository.", git_reference_name(ref));
2735 2736 2737 2738
		error = -1;
		goto cleanup;
	}

2739
	if (!error) {
2740 2741
		if (git_reference_is_branch(ref)) {
			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
2742
					git_reference_name(ref), true, git_buf_cstr(&log_message));
2743
		} else {
2744
			error = detach(repo, git_reference_target(ref),
2745
				git_reference_is_tag(ref) || git_reference_is_remote(ref) ? refname : NULL);
2746
		}
2747
	} else if (git_reference__is_branch(refname)) {
2748
		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
2749
				true, git_buf_cstr(&log_message));
2750
	}
2751

2752
cleanup:
2753
	git_buf_dispose(&log_message);
2754
	git_reference_free(current);
2755 2756 2757 2758 2759
	git_reference_free(ref);
	git_reference_free(new_head);
	return error;
}

2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772
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);

2773
	return detach(repo, git_annotated_commit_id(commitish), commitish->description);
2774 2775
}

2776
int git_repository_detach_head(git_repository* repo)
2777
{
2778
	git_reference *old_head = NULL,	*new_head = NULL, *current = NULL;
2779
	git_object *object = NULL;
2780
	git_buf log_message = GIT_BUF_INIT;
2781
	int error;
2782 2783 2784

	assert(repo);

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

2788 2789 2790
	if ((error = git_repository_head(&old_head, repo)) < 0)
		goto cleanup;

2791
	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0)
2792 2793
		goto cleanup;

2794 2795 2796
	if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
		goto cleanup;

2797
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
2798
			1, git_buf_cstr(&log_message));
2799 2800

cleanup:
2801
	git_buf_dispose(&log_message);
2802 2803 2804
	git_object_free(object);
	git_reference_free(old_head);
	git_reference_free(new_head);
2805
	git_reference_free(current);
2806 2807
	return error;
}
Edward Thomson committed
2808

2809 2810 2811 2812
/**
 * Loosely ported from git.git
 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
 */
Edward Thomson committed
2813 2814 2815 2816 2817 2818 2819
int git_repository_state(git_repository *repo)
{
	git_buf repo_path = GIT_BUF_INIT;
	int state = GIT_REPOSITORY_STATE_NONE;

	assert(repo);

2820
	if (git_buf_puts(&repo_path, repo->gitdir) < 0)
Edward Thomson committed
2821 2822
		return -1;

2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833
	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
2834
		state = GIT_REPOSITORY_STATE_MERGE;
2835
	else if (git_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE)) {
Edward Thomson committed
2836
		state = GIT_REPOSITORY_STATE_REVERT;
2837 2838 2839 2840
		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)) {
2841
		state = GIT_REPOSITORY_STATE_CHERRYPICK;
2842 2843 2844 2845
		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))
2846
		state = GIT_REPOSITORY_STATE_BISECT;
Edward Thomson committed
2847

2848
	git_buf_dispose(&repo_path);
Edward Thomson committed
2849 2850
	return state;
}
Ben Straub committed
2851

2852 2853
int git_repository__cleanup_files(
	git_repository *repo, const char *files[], size_t files_len)
2854
{
2855
	git_buf buf = GIT_BUF_INIT;
2856
	size_t i;
2857
	int error;
2858

2859 2860
	for (error = 0, i = 0; !error && i < files_len; ++i) {
		const char *path;
2861

2862
		if (git_buf_joinpath(&buf, repo->gitdir, files[i]) < 0)
2863
			return -1;
2864

2865 2866 2867 2868 2869 2870 2871 2872
		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);
		}
2873

2874 2875
		git_buf_clear(&buf);
	}
2876

2877
	git_buf_dispose(&buf);
2878 2879 2880 2881 2882 2883 2884 2885
	return error;
}

static const char *state_files[] = {
	GIT_MERGE_HEAD_FILE,
	GIT_MERGE_MODE_FILE,
	GIT_MERGE_MSG_FILE,
	GIT_REVERT_HEAD_FILE,
2886
	GIT_CHERRYPICK_HEAD_FILE,
2887 2888 2889
	GIT_BISECT_LOG_FILE,
	GIT_REBASE_MERGE_DIR,
	GIT_REBASE_APPLY_DIR,
2890
	GIT_SEQUENCER_DIR,
2891 2892 2893 2894 2895 2896 2897 2898 2899
};

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
2900 2901 2902 2903
int git_repository_is_shallow(git_repository *repo)
{
	git_buf path = GIT_BUF_INIT;
	struct stat st;
Ben Straub committed
2904
	int error;
Ben Straub committed
2905

2906
	if ((error = git_buf_joinpath(&path, repo->gitdir, "shallow")) < 0)
2907 2908
		return error;

Ben Straub committed
2909
	error = git_path_lstat(path.ptr, &st);
2910
	git_buf_dispose(&path);
Ben Straub committed
2911

2912
	if (error == GIT_ENOTFOUND) {
2913
		git_error_clear();
Ben Straub committed
2914
		return 0;
2915 2916
	}

Ben Straub committed
2917 2918 2919
	if (error < 0)
		return error;
	return st.st_size == 0 ? 0 : 1;
Ben Straub committed
2920
}
2921

2922
int git_repository_init_options_init(
2923
	git_repository_init_options *opts, unsigned int version)
2924
{
2925 2926 2927 2928
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_repository_init_options,
		GIT_REPOSITORY_INIT_OPTIONS_INIT);
	return 0;
2929
}
2930

2931 2932 2933 2934 2935 2936
int git_repository_init_init_options(
	git_repository_init_options *opts, unsigned int version)
{
	return git_repository_init_options_init(opts, version);
}

2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950
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);
2951
		GIT_ERROR_CHECK_ALLOC(tmp_name);
2952 2953 2954 2955
	}

	if (email) {
		tmp_email = git__strdup(email);
2956
		GIT_ERROR_CHECK_ALLOC(tmp_email);
2957 2958 2959 2960 2961 2962 2963 2964 2965 2966
	}

	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;
}
2967 2968 2969 2970 2971 2972 2973

int git_repository_submodule_cache_all(git_repository *repo)
{
	int error;

	assert(repo);

2974
	if ((error = git_strmap_new(&repo->submodule_cache)))
2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994
		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;
}