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

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

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

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

35
#define GIT_FILE_CONTENT_PREFIX "gitdir:"
36

37 38
#define GIT_BRANCH_MASTER "master"

39
#define GIT_REPO_VERSION 0
40

41 42 43 44 45 46 47 48 49 50
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;
51

52
static void set_odb(git_repository *repo, git_odb *odb)
53
{
54 55 56 57 58 59 60 61
	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);
62
	}
63
}
64

65
static void set_refdb(git_repository *repo, git_refdb *refdb)
66
{
67 68 69 70 71 72 73 74
	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);
75 76 77
	}
}

78
static void set_config(git_repository *repo, git_config *config)
79
{
80 81 82 83 84 85 86 87
	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);
88
	}
89 90

	git_repository__cvar_cache_clear(repo);
91 92
}

93
static void set_index(git_repository *repo, git_index *index)
94
{
95 96 97 98 99 100 101 102
	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);
103
	}
104 105
}

106
void git_repository__cleanup(git_repository *repo)
107
{
108
	assert(repo);
109

110
	git_cache_clear(&repo->objects);
111
	git_attr_cache_flush(repo);
112
	git_submodule_cache_free(repo);
113

114 115 116 117
	set_config(repo, NULL);
	set_index(repo, NULL);
	set_odb(repo, NULL);
	set_refdb(repo, NULL);
118 119 120 121
}

void git_repository_free(git_repository *repo)
{
122 123
	size_t i;

124 125 126 127 128 129
	if (repo == NULL)
		return;

	git_repository__cleanup(repo);

	git_cache_free(&repo->objects);
130

131
	git_diff_driver_registry_free(repo->diff_drivers);
132
	repo->diff_drivers = NULL;
133

134 135
	for (i = 0; i < repo->reserved_names.size; i++)
		git_buf_free(git_array_get(repo->reserved_names, i));
Edward Thomson committed
136
	git_array_clear(repo->reserved_names);
137

Edward Thomson committed
138
	git__free(repo->path_gitlink);
Russell Belfer committed
139 140
	git__free(repo->path_repository);
	git__free(repo->workdir);
Vicent Marti committed
141
	git__free(repo->namespace);
142 143
	git__free(repo->ident_name);
	git__free(repo->ident_email);
Russell Belfer committed
144

145
	git__memzero(repo, sizeof(*repo));
146
	git__free(repo);
147 148
}

149 150 151 152 153
/*
 * Git repository open methods
 *
 * Open a repository object from its path
 */
154
static bool valid_repository_path(git_buf *repository_path)
155
{
156
	/* Check OBJECTS_DIR first, since it will generate the longest path name */
157
	if (git_path_contains_dir(repository_path, GIT_OBJECTS_DIR) == false)
158
		return false;
159

160
	/* Ensure HEAD file exists */
161
	if (git_path_contains_file(repository_path, GIT_HEAD_FILE) == false)
162
		return false;
163

164
	if (git_path_contains_dir(repository_path, GIT_REFS_DIR)  == false)
165
		return false;
166

167
	return true;
168 169
}

170
static git_repository *repository_alloc(void)
171
{
172
	git_repository *repo = git__calloc(1, sizeof(git_repository));
173

174 175 176 177 178 179 180
	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;
181

182 183 184
	/* set all the entries in the cvar cache to `unset` */
	git_repository__cvar_cache_clear(repo);

185
	return repo;
186 187 188 189 190 191 192

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

	git__free(repo);
	return NULL;
193 194
}

195 196
int git_repository_new(git_repository **out)
{
197 198 199 200 201 202 203
	git_repository *repo;

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

	repo->is_bare = 1;

204 205 206
	return 0;
}

207
static int load_config_data(git_repository *repo, const git_config *config)
208
{
209
	int is_bare;
210

211
	/* Try to figure out if it's bare, default to non-bare if it's not set */
212
	if (git_config_get_bool(&is_bare, config, "core.bare") < 0)
213 214 215
		repo->is_bare = 0;
	else
		repo->is_bare = is_bare;
216

217
	return 0;
218
}
219

220
static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)
221
{
222
	int         error;
223
	git_config_entry *ce;
224
	git_buf     worktree = GIT_BUF_INIT;
225

226
	if (repo->is_bare)
227
		return 0;
228

229 230 231
	if ((error = git_config__lookup_entry(
			&ce, config, "core.worktree", false)) < 0)
		return error;
232

233 234 235
	if (ce && ce->value) {
		if ((error = git_path_prettify_dir(
				&worktree, ce->value, repo->path_repository)) < 0)
236
			goto cleanup;
237 238

		repo->workdir = git_buf_detach(&worktree);
239
	}
240 241
	else if (parent_path && git_path_isdir(parent_path->ptr))
		repo->workdir = git_buf_detach(parent_path);
242
	else {
243
		if (git_path_dirname_r(&worktree, repo->path_repository) < 0 ||
244 245 246 247
		    git_path_to_dir(&worktree) < 0) {
			error = -1;
			goto cleanup;
		}
248 249

		repo->workdir = git_buf_detach(&worktree);
250 251 252
	}

	GITERR_CHECK_ALLOC(repo->workdir);
253 254 255
cleanup:
	git_config_entry_free(ce);
	return error;
256 257
}

258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
/*
 * This function returns furthest offset into path where a ceiling dir
 * is found, so we can stop processing the path at that point.
 *
 * Note: converting this to use git_bufs instead of GIT_PATH_MAX buffers on
 * the stack could remove directories name limits, but at the cost of doing
 * repeated malloc/frees inside the loop below, so let's not do it now.
 */
static int find_ceiling_dir_offset(
	const char *path,
	const char *ceiling_directories)
{
	char buf[GIT_PATH_MAX + 1];
	char buf2[GIT_PATH_MAX + 1];
	const char *ceil, *sep;
273
	size_t len, max_len = 0, min_len;
274 275 276

	assert(path);

277
	min_len = (size_t)(git_path_root(path) + 1);
278 279

	if (ceiling_directories == NULL || min_len == 0)
280
		return (int)min_len;
281 282 283 284 285

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

286
		if (len == 0 || len >= sizeof(buf) || git_path_root(ceil) == -1)
287 288 289 290 291 292 293 294 295 296 297 298 299
			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) &&
300
			(path[len] == '/' || !path[len]) &&
301 302 303 304 305 306
			len > max_len)
		{
			max_len = len;
		}
	}

307
	return (int)(max_len <= min_len ? min_len : max_len);
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
}

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

330 331
	if (git_buf_len(&file) <= prefix_len ||
		memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
332
	{
333 334
		giterr_set(GITERR_REPOSITORY,
			"The `.git` file at '%s' is malformed", file_path);
335 336 337
		error = -1;
	}
	else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
338
		const char *gitlink = git_buf_cstr(&file) + prefix_len;
339
		while (*gitlink && git__isspace(*gitlink)) gitlink++;
340

341 342
		error = git_path_prettify_dir(
			path_out, gitlink, git_buf_cstr(path_out));
343 344 345 346 347 348 349 350 351
	}

	git_buf_free(&file);
	return error;
}

static int find_repo(
	git_buf *repo_path,
	git_buf *parent_path,
352
	git_buf *link_path,
353 354 355
	const char *start_path,
	uint32_t flags,
	const char *ceiling_dirs)
356
{
357 358 359 360
	int error;
	git_buf path = GIT_BUF_INIT;
	struct stat st;
	dev_t initial_device = 0;
361
	bool try_with_dot_git = ((flags & GIT_REPOSITORY_OPEN_BARE) != 0);
362 363 364 365
	int ceiling_offset;

	git_buf_free(repo_path);

366
	if ((error = git_path_prettify(&path, start_path, NULL)) < 0)
367 368 369 370
		return error;

	ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);

371 372
	if (!try_with_dot_git &&
		(error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0)
373 374
		return error;

nulltoken committed
375
	while (!error && !git_buf_len(repo_path)) {
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
		if (p_stat(path.ptr, &st) == 0) {
			/* check that we have not crossed device boundaries */
			if (initial_device == 0)
				initial_device = st.st_dev;
			else if (st.st_dev != initial_device &&
				(flags & GIT_REPOSITORY_OPEN_CROSS_FS) == 0)
				break;

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

				if (!(error = read_gitfile(&repo_link, path.ptr))) {
395
					if (valid_repository_path(&repo_link)) {
396
						git_buf_swap(repo_path, &repo_link);
397

398 399 400 401 402
						if (link_path)
							error = git_buf_put(link_path, 
								path.ptr, path.size);
					}

403
					git_buf_free(&repo_link);
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428
					break;
				}
				git_buf_free(&repo_link);
			}
		}

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

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

429
	if (!error && parent_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
nulltoken committed
430
		if (!git_buf_len(repo_path))
431 432 433 434 435 436 437 438 439 440 441
			git_buf_clear(parent_path);
		else {
			git_path_dirname_r(parent_path, path.ptr);
			git_path_to_dir(parent_path);
		}
		if (git_buf_oom(parent_path))
			return -1;
	}

	git_buf_free(&path);

nulltoken committed
442
	if (!git_buf_len(repo_path) && !error) {
443
		giterr_set(GITERR_REPOSITORY,
444
			"Could not find repository from '%s'", start_path);
445
		error = GIT_ENOTFOUND;
446
	}
447

448 449 450
	return error;
}

451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
int git_repository_open_bare(
	git_repository **repo_ptr,
	const char *bare_path)
{
	int error;
	git_buf path = GIT_BUF_INIT;
	git_repository *repo = NULL;

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

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

	repo = repository_alloc();
	GITERR_CHECK_ALLOC(repo);

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

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

	*repo_ptr = repo;
	return 0;
}

482 483 484
int git_repository_open_ext(
	git_repository **repo_ptr,
	const char *start_path,
485
	unsigned int flags,
486 487 488
	const char *ceiling_dirs)
{
	int error;
489 490
	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT,
		link_path = GIT_BUF_INIT;
491 492
	git_repository *repo;

493 494
	if (repo_ptr)
		*repo_ptr = NULL;
495

496 497 498
	error = find_repo(
		&path, &parent, &link_path, start_path, flags, ceiling_dirs);

499
	if (error < 0 || !repo_ptr)
500 501
		return error;

502
	repo = repository_alloc();
503
	GITERR_CHECK_ALLOC(repo);
504

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

508 509 510 511 512
	if (link_path.size) {
		repo->path_gitlink = git_buf_detach(&link_path);
		GITERR_CHECK_ALLOC(repo->path_gitlink);
	}

513 514
	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
		repo->is_bare = 1;
515 516 517 518 519 520 521 522
	else {
		git_config *config = NULL;

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

523
		git_config_free(config);
524
	}
525

526 527
	if (!error)
		*repo_ptr = repo;
528
	git_buf_free(&parent);
529 530

	return error;
531
}
532

533 534 535 536 537 538
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);
}

539 540 541 542 543 544 545 546 547 548 549 550 551
int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
{
	git_repository *repo;

	repo = repository_alloc();
	GITERR_CHECK_ALLOC(repo);

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

	return 0;
}

552
int git_repository_discover(
553
	git_buf *out,
554 555 556 557 558 559
	const char *start_path,
	int across_fs,
	const char *ceiling_dirs)
{
	uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;

560
	assert(start_path);
561

562
	git_buf_sanitize(out);
563

564
	return find_repo(out, NULL, NULL, start_path, flags, ceiling_dirs);
565 566
}

567
static int load_config(
568 569 570
	git_config **out,
	git_repository *repo,
	const char *global_config_path,
Sven Strickroth committed
571
	const char *xdg_config_path,
572
	const char *system_config_path)
573
{
574
	int error;
575
	git_buf config_path = GIT_BUF_INIT;
576
	git_config *cfg = NULL;
577

578
	assert(repo && out);
579

580 581
	if ((error = git_config_new(&cfg)) < 0)
		return error;
582

583 584 585
	error = git_buf_joinpath(
		&config_path, repo->path_repository, GIT_CONFIG_FILENAME_INREPO);
	if (error < 0)
586
		goto on_error;
587

588 589 590
	if ((error = git_config_add_file_ondisk(
			cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, 0)) < 0 &&
		error != GIT_ENOTFOUND)
591 592 593
		goto on_error;

	git_buf_free(&config_path);
594

595 596 597 598 599
	if (global_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, global_config_path, GIT_CONFIG_LEVEL_GLOBAL, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;
600

601 602 603 604 605
	if (xdg_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, xdg_config_path, GIT_CONFIG_LEVEL_XDG, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;
606

607 608 609 610 611
	if (system_config_path != NULL &&
		(error = git_config_add_file_ondisk(
			cfg, system_config_path, GIT_CONFIG_LEVEL_SYSTEM, 0)) < 0 &&
		error != GIT_ENOTFOUND)
		goto on_error;
612

613 614
	giterr_clear(); /* clear any lingering ENOTFOUND errors */

615
	*out = cfg;
616
	return 0;
617

618 619
on_error:
	git_buf_free(&config_path);
620 621
	git_config_free(cfg);
	*out = NULL;
622
	return error;
623 624
}

Russell Belfer committed
625
static const char *path_unless_empty(git_buf *buf)
626
{
Russell Belfer committed
627 628
	return git_buf_len(buf) > 0 ? git_buf_cstr(buf) : NULL;
}
629

Russell Belfer committed
630 631 632
int git_repository_config__weakptr(git_config **out, git_repository *repo)
{
	int error = 0;
633

Russell Belfer committed
634 635 636 637 638 639
	if (repo->_config == NULL) {
		git_buf global_buf = GIT_BUF_INIT;
		git_buf xdg_buf = GIT_BUF_INIT;
		git_buf system_buf = GIT_BUF_INIT;
		git_config *config;

640 641 642
		git_config_find_global(&global_buf);
		git_config_find_xdg(&xdg_buf);
		git_config_find_system(&system_buf);
Russell Belfer committed
643

644 645 646 647
		/* 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
648 649 650 651 652 653 654 655
		error = load_config(
			&config, repo,
			path_unless_empty(&global_buf),
			path_unless_empty(&xdg_buf),
			path_unless_empty(&system_buf));
		if (!error) {
			GIT_REFCOUNT_OWN(config, repo);

656
			config = git__compare_and_swap(&repo->_config, NULL, config);
Russell Belfer committed
657 658 659 660 661
			if (config != NULL) {
				GIT_REFCOUNT_OWN(config, NULL);
				git_config_free(config);
			}
		}
662 663

		git_buf_free(&global_buf);
664
		git_buf_free(&xdg_buf);
665
		git_buf_free(&system_buf);
666
	}
667

668
	*out = repo->_config;
Russell Belfer committed
669
	return error;
670 671
}

672
int git_repository_config(git_config **out, git_repository *repo)
673
{
674 675
	if (git_repository_config__weakptr(out, repo) < 0)
		return -1;
676

677 678
	GIT_REFCOUNT_INC(*out);
	return 0;
679 680
}

681 682
int git_repository_config_snapshot(git_config **out, git_repository *repo)
{
683
	int error;
684 685
	git_config *weak;

686 687
	if ((error = git_repository_config__weakptr(&weak, repo)) < 0)
		return error;
688 689 690 691

	return git_config_snapshot(out, weak);
}

692 693 694
void git_repository_set_config(git_repository *repo, git_config *config)
{
	assert(repo && config);
695
	set_config(repo, config);
696 697 698 699
}

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

702 703 704
	assert(repo && out);

	if (repo->_odb == NULL) {
705
		git_buf odb_path = GIT_BUF_INIT;
Russell Belfer committed
706
		git_odb *odb;
707

708 709
		if ((error = git_buf_joinpath(&odb_path, repo->path_repository, GIT_OBJECTS_DIR)) < 0)
			return error;
710

Russell Belfer committed
711 712 713
		error = git_odb_open(&odb, odb_path.ptr);
		if (!error) {
			GIT_REFCOUNT_OWN(odb, repo);
714

715
			odb = git__compare_and_swap(&repo->_odb, NULL, odb);
Russell Belfer committed
716 717 718 719 720
			if (odb != NULL) {
				GIT_REFCOUNT_OWN(odb, NULL);
				git_odb_free(odb);
			}
		}
721

Russell Belfer committed
722
		git_buf_free(&odb_path);
723
	}
724

725
	*out = repo->_odb;
Russell Belfer committed
726
	return error;
727 728
}

729
int git_repository_odb(git_odb **out, git_repository *repo)
730
{
731 732
	if (git_repository_odb__weakptr(out, repo) < 0)
		return -1;
Vicent Marti committed
733

734 735
	GIT_REFCOUNT_INC(*out);
	return 0;
736
}
737

738 739 740
void git_repository_set_odb(git_repository *repo, git_odb *odb)
{
	assert(repo && odb);
741
	set_odb(repo, odb);
742 743
}

744 745
int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo)
{
Russell Belfer committed
746 747
	int error = 0;

748 749 750
	assert(out && repo);

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

Russell Belfer committed
753 754 755
		error = git_refdb_open(&refdb, repo);
		if (!error) {
			GIT_REFCOUNT_OWN(refdb, repo);
756

757
			refdb = git__compare_and_swap(&repo->_refdb, NULL, refdb);
Russell Belfer committed
758 759 760 761 762
			if (refdb != NULL) {
				GIT_REFCOUNT_OWN(refdb, NULL);
				git_refdb_free(refdb);
			}
		}
763 764 765
	}

	*out = repo->_refdb;
Russell Belfer committed
766
	return error;
767 768 769 770 771 772 773 774 775 776 777 778 779
}

int git_repository_refdb(git_refdb **out, git_repository *repo)
{
	if (git_repository_refdb__weakptr(out, repo) < 0)
		return -1;

	GIT_REFCOUNT_INC(*out);
	return 0;
}

void git_repository_set_refdb(git_repository *repo, git_refdb *refdb)
{
Russell Belfer committed
780
	assert(repo && refdb);
781
	set_refdb(repo, refdb);
782 783
}

784 785
int git_repository_index__weakptr(git_index **out, git_repository *repo)
{
Russell Belfer committed
786 787
	int error = 0;

788 789 790
	assert(out && repo);

	if (repo->_index == NULL) {
791
		git_buf index_path = GIT_BUF_INIT;
Russell Belfer committed
792
		git_index *index;
793

794 795
		if ((error = git_buf_joinpath(&index_path, repo->path_repository, GIT_INDEX_FILE)) < 0)
			return error;
796

Russell Belfer committed
797 798 799
		error = git_index_open(&index, index_path.ptr);
		if (!error) {
			GIT_REFCOUNT_OWN(index, repo);
800

801
			index = git__compare_and_swap(&repo->_index, NULL, index);
Russell Belfer committed
802 803 804 805
			if (index != NULL) {
				GIT_REFCOUNT_OWN(index, NULL);
				git_index_free(index);
			}
806

Russell Belfer committed
807 808
			error = git_index_set_caps(repo->_index, GIT_INDEXCAP_FROM_OWNER);
		}
809

Russell Belfer committed
810
		git_buf_free(&index_path);
811 812 813
	}

	*out = repo->_index;
Russell Belfer committed
814
	return error;
815
}
Vicent Marti committed
816

817 818
int git_repository_index(git_index **out, git_repository *repo)
{
819 820
	if (git_repository_index__weakptr(out, repo) < 0)
		return -1;
821

822 823
	GIT_REFCOUNT_INC(*out);
	return 0;
824 825
}

826 827
void git_repository_set_index(git_repository *repo, git_index *index)
{
828
	assert(repo);
829
	set_index(repo, index);
830 831
}

Vicent Marti committed
832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848
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;
}

849 850
#ifdef GIT_WIN32
static int reserved_names_add8dot3(git_repository *repo, const char *path)
851
{
852 853 854 855
	char *name = git_win32_path_8dot3_name(path);
	const char *def = GIT_DIR_SHORTNAME;
	size_t name_len, def_len = CONST_STRLEN(GIT_DIR_SHORTNAME);
	git_buf *buf;
856

857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
	if (!name)
		return 0;

	name_len = strlen(name);

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

		/* Try to add any repo-specific reserved names */
893
		if (!repo->is_bare) {
894 895
			const char *reserved_path = repo->path_gitlink ?
				repo->path_gitlink : repo->path_repository;
896

897 898
			if (reserved_names_add8dot3(repo, reserved_path) < 0)
				goto on_error;
899 900 901
		}
	}

902 903 904 905 906 907 908 909 910 911 912
	*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;
913
}
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930
#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
931

932
static int check_repositoryformatversion(git_config *config)
933
{
934
	int version;
935

936
	if (git_config_get_int32(&version, config, "core.repositoryformatversion") < 0)
937
		return -1;
938

939
	if (GIT_REPO_VERSION < version) {
940 941
		giterr_set(GITERR_REPOSITORY,
			"Unsupported repository version %d. Only versions up to %d are supported.",
942
			version, GIT_REPO_VERSION);
943 944
		return -1;
	}
945

946
	return 0;
947 948
}

949
static int repo_init_create_head(const char *git_dir, const char *ref_name)
950
{
951
	git_buf ref_path = GIT_BUF_INIT;
952
	git_filebuf ref = GIT_FILEBUF_INIT;
953
	const char *fmt;
954

955
	if (git_buf_joinpath(&ref_path, git_dir, GIT_HEAD_FILE) < 0 ||
956
		git_filebuf_open(&ref, ref_path.ptr, 0, GIT_REFS_FILE_MODE) < 0)
957 958 959 960 961
		goto fail;

	if (!ref_name)
		ref_name = GIT_BRANCH_MASTER;

962
	if (git__prefixcmp(ref_name, GIT_REFS_DIR) == 0)
963 964
		fmt = "ref: %s\n";
	else
965
		fmt = "ref: " GIT_REFS_HEADS_DIR "%s\n";
966 967

	if (git_filebuf_printf(&ref, fmt, ref_name) < 0 ||
968
		git_filebuf_commit(&ref) < 0)
969
		goto fail;
970

971
	git_buf_free(&ref_path);
972
	return 0;
973 974 975 976 977

fail:
	git_buf_free(&ref_path);
	git_filebuf_cleanup(&ref);
	return -1;
978 979
}

980 981 982 983 984 985 986 987 988 989 990 991 992
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;

993
	return (st1.st_mode != st2.st_mode);
994 995
}

996 997 998
static bool is_filesystem_case_insensitive(const char *gitdir_path)
{
	git_buf path = GIT_BUF_INIT;
999
	int is_insensitive = -1;
1000

1001 1002
	if (!git_buf_joinpath(&path, gitdir_path, "CoNfIg"))
		is_insensitive = git_path_exists(git_buf_cstr(&path));
1003 1004

	git_buf_free(&path);
1005
	return is_insensitive;
1006 1007
}

1008 1009 1010 1011 1012
static bool are_symlinks_supported(const char *wd_path)
{
	git_buf path = GIT_BUF_INIT;
	int fd;
	struct stat st;
1013
	int symlinks_supported = -1;
1014

1015
	if ((fd = git_futils_mktmp(&path, wd_path, 0666)) < 0 ||
1016 1017 1018 1019
		p_close(fd) < 0 ||
		p_unlink(path.ptr) < 0 ||
		p_symlink("testing", path.ptr) < 0 ||
		p_lstat(path.ptr, &st) < 0)
1020
		symlinks_supported = false;
1021
	else
1022
		symlinks_supported = (S_ISLNK(st.st_mode) != 0);
1023 1024 1025 1026

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

1027 1028 1029
	return symlinks_supported;
}

1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
static int create_empty_file(const char *path, mode_t mode)
{
	int fd;

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

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

	return 0;
}

1047 1048 1049 1050 1051
static int repo_local_config(
	git_config **out,
	git_buf *config_dir,
	git_repository *repo,
	const char *repo_dir)
1052
{
1053
	int error = 0;
1054 1055
	git_config *parent;
	const char *cfg_path;
1056

1057
	if (git_buf_joinpath(config_dir, repo_dir, GIT_CONFIG_FILENAME_INREPO) < 0)
1058
		return -1;
1059
	cfg_path = git_buf_cstr(config_dir);
1060

1061
	/* make LOCAL config if missing */
1062 1063
	if (!git_path_isfile(cfg_path) &&
		(error = create_empty_file(cfg_path, GIT_CONFIG_FILE_MODE)) < 0)
1064
		return error;
1065

1066 1067 1068 1069 1070 1071 1072 1073 1074
	/* 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) {
1075 1076 1077 1078
		giterr_clear();

		if (!(error = git_config_add_file_ondisk(
				parent, cfg_path, GIT_CONFIG_LEVEL_LOCAL, false)))
1079
			error = git_config_open_level(out, parent, GIT_CONFIG_LEVEL_LOCAL);
1080
	}
1081

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
	git_config_free(parent);

	return error;
}

static int repo_init_fs_configs(
	git_config *cfg,
	const char *cfg_path,
	const char *repo_dir,
	const char *work_dir,
	bool update_ignorecase)
{
	int error = 0;

	if (!work_dir)
		work_dir = repo_dir;

	if ((error = git_config_set_bool(
			cfg, "core.filemode", is_chmod_supported(cfg_path))) < 0)
		return error;

	if (!are_symlinks_supported(work_dir)) {
		if ((error = git_config_set_bool(cfg, "core.symlinks", false)) < 0)
			return error;
	} else if (git_config_delete_entry(cfg, "core.symlinks") < 0)
		giterr_clear();
1108

1109 1110 1111 1112 1113 1114 1115
	if (update_ignorecase) {
		if (is_filesystem_case_insensitive(repo_dir)) {
			if ((error = git_config_set_bool(cfg, "core.ignorecase", true)) < 0)
				return error;
		} else if (git_config_delete_entry(cfg, "core.ignorecase") < 0)
			giterr_clear();
	}
1116

1117
#ifdef GIT_USE_ICONV
1118 1119
	if ((error = git_config_set_bool(
			cfg, "core.precomposeunicode",
1120
			git_path_does_fs_decompose_unicode(work_dir))) < 0)
1121
		return error;
1122
	/* on non-iconv platforms, don't even set core.precomposeunicode */
1123 1124
#endif

1125 1126
	return 0;
}
1127

1128 1129 1130 1131 1132 1133 1134
static int repo_init_config(
	const char *repo_dir,
	const char *work_dir,
	uint32_t flags,
	uint32_t mode)
{
	int error = 0;
1135
	git_buf cfg_path = GIT_BUF_INIT, worktree_path = GIT_BUF_INIT;
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
	git_config *config = NULL;
	bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0);
	bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0);

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

	if (is_reinit && (error = check_repositoryformatversion(config)) < 0)
		goto cleanup;

#define SET_REPO_CONFIG(TYPE, NAME, VAL) do { \
	if ((error = git_config_set_##TYPE(config, NAME, VAL)) < 0) \
		goto cleanup; } while (0)

	SET_REPO_CONFIG(bool, "core.bare", is_bare);
	SET_REPO_CONFIG(int32, "core.repositoryformatversion", GIT_REPO_VERSION);

	if ((error = repo_init_fs_configs(
			config, cfg_path.ptr, repo_dir, work_dir, !is_reinit)) < 0)
		goto cleanup;
1156

1157 1158
	if (!is_bare) {
		SET_REPO_CONFIG(bool, "core.logallrefupdates", true);
1159

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
		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
1170
			if (git_config_delete_entry(config, "core.worktree") < 0)
1171
				giterr_clear();
1172 1173 1174
		}
	}

1175
	if (mode == GIT_REPOSITORY_INIT_SHARED_GROUP) {
1176 1177
		SET_REPO_CONFIG(int32, "core.sharedrepository", 1);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
1178
	}
1179
	else if (mode == GIT_REPOSITORY_INIT_SHARED_ALL) {
1180 1181 1182
		SET_REPO_CONFIG(int32, "core.sharedrepository", 2);
		SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
	}
1183

1184
cleanup:
1185
	git_buf_free(&cfg_path);
1186
	git_buf_free(&worktree_path);
1187
	git_config_free(config);
1188

1189
	return error;
1190
}
1191

1192
static int repo_reinit_submodule_fs(git_submodule *sm, const char *n, void *p)
1193
{
1194 1195
	git_repository *smrepo = NULL;
	GIT_UNUSED(n); GIT_UNUSED(p);
1196

1197
	if (git_submodule_open(&smrepo, sm) < 0 ||
1198
		git_repository_reinit_filesystem(smrepo, true) < 0)
1199 1200
		giterr_clear();
	git_repository_free(smrepo);
1201

1202 1203
	return 0;
}
1204

1205
int git_repository_reinit_filesystem(git_repository *repo, int recurse)
1206 1207 1208 1209 1210
{
	int error = 0;
	git_buf path = GIT_BUF_INIT;
	git_config *config = NULL;
	const char *repo_dir = git_repository_path(repo);
1211

1212 1213 1214
	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);
1215

1216 1217
	git_config_free(config);
	git_buf_free(&path);
1218 1219 1220

	git_repository__cvar_cache_clear(repo);

1221
	if (!repo->is_bare && recurse)
1222
		(void)git_submodule_foreach(repo, repo_reinit_submodule_fs, NULL);
1223

1224 1225 1226
	return error;
}

1227
static int repo_write_template(
1228 1229 1230 1231
	const char *git_dir,
	bool allow_overwrite,
	const char *file,
	mode_t mode,
1232
	bool hidden,
1233
	const char *content)
1234 1235
{
	git_buf path = GIT_BUF_INIT;
1236
	int fd, error = 0, flags;
1237 1238 1239 1240

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

1241 1242 1243 1244 1245 1246
	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);
1247

1248 1249
	if (fd >= 0) {
		error = p_write(fd, content, strlen(content));
1250

1251 1252 1253 1254
		p_close(fd);
	}
	else if (errno != EEXIST)
		error = fd;
1255

1256 1257
#ifdef GIT_WIN32
	if (!error && hidden) {
1258
		if (git_win32__sethidden(path.ptr) < 0)
1259 1260 1261 1262 1263 1264
			error = -1;
	}
#else
	GIT_UNUSED(hidden);
#endif

1265
	git_buf_free(&path);
1266 1267 1268 1269 1270 1271

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

	return error;
1272 1273
}

1274
static int repo_write_gitlink(
1275
	const char *in_dir, const char *to_repo, bool use_relative_path)
1276
{
1277 1278
	int error;
	git_buf buf = GIT_BUF_INIT;
1279
	git_buf path_to_repo = GIT_BUF_INIT;
1280 1281 1282 1283 1284
	struct stat st;

	git_path_dirname_r(&buf, to_repo);
	git_path_to_dir(&buf);
	if (git_buf_oom(&buf))
1285
		return -1;
1286

1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
	/* don't write gitlink to natural workdir */
	if (git__suffixcmp(to_repo, "/" DOT_GIT "/") == 0 &&
		strcmp(in_dir, buf.ptr) == 0)
	{
		error = GIT_PASSTHROUGH;
		goto cleanup;
	}

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

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

	git_buf_clear(&buf);

1307 1308 1309 1310 1311 1312 1313
	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);
1314 1315

	if (!error)
1316
		error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
1317 1318 1319

cleanup:
	git_buf_free(&buf);
1320
	git_buf_free(&path_to_repo);
1321 1322 1323
	return error;
}

1324 1325 1326
static mode_t pick_dir_mode(git_repository_init_options *opts)
{
	if (opts->mode == GIT_REPOSITORY_INIT_SHARED_UMASK)
1327
		return 0777;
1328 1329 1330 1331 1332 1333 1334
	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;
}

1335 1336 1337 1338 1339 1340 1341
#include "repo_template.h"

static int repo_init_structure(
	const char *repo_dir,
	const char *work_dir,
	git_repository_init_options *opts)
{
1342
	int error = 0;
1343
	repo_template_item *tpl;
1344 1345 1346
	bool external_tpl =
		((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
	mode_t dmode = pick_dir_mode(opts);
1347
	bool chmod = opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK;
1348 1349

	/* Hide the ".git" directory */
1350
#ifdef GIT_WIN32
1351
	if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
1352 1353
		if (git_win32__sethidden(repo_dir) < 0) {
			giterr_set(GITERR_OS,
1354 1355 1356
				"Failed to mark Git repository folder as hidden");
			return -1;
		}
1357
	}
1358 1359 1360 1361 1362 1363
#endif

	/* Create the .git gitlink if appropriate */
	if ((opts->flags & GIT_REPOSITORY_INIT_BARE) == 0 &&
		(opts->flags & GIT_REPOSITORY_INIT__NATURAL_WD) == 0)
	{
1364
		if (repo_write_gitlink(work_dir, repo_dir, opts->flags & GIT_REPOSITORY_INIT_RELATIVE_GITLINK) < 0)
1365
			return -1;
1366
	}
1367

1368 1369
	/* Copy external template if requested */
	if (external_tpl) {
Linquize committed
1370 1371 1372
		git_config *cfg = NULL;
		const char *tdir = NULL;
		bool default_template = false;
1373 1374
		git_buf template_buf = GIT_BUF_INIT;

1375 1376
		if (opts->template_path)
			tdir = opts->template_path;
Linquize committed
1377
		else if ((error = git_config_open_default(&cfg)) >= 0) {
1378 1379
			if (!git_config_get_path(&template_buf, cfg, "init.templatedir"))
				tdir = template_buf.ptr;
1380
			giterr_clear();
Linquize committed
1381 1382 1383
		}

		if (!tdir) {
1384
			if (!(error = git_sysdir_find_template_dir(&template_buf)))
1385
				tdir = template_buf.ptr;
Linquize committed
1386
			default_template = true;
1387
		}
1388

1389
		if (tdir) {
1390 1391 1392 1393
			uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS | GIT_CPDIR_SIMPLE_TO_MODE;
			if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
					cpflags |= GIT_CPDIR_CHMOD_DIRS;
			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
1394
		}
1395

Linquize committed
1396 1397
		git_buf_free(&template_buf);
		git_config_free(cfg);
1398

1399
		if (error < 0) {
Linquize committed
1400
			if (!default_template)
1401 1402 1403 1404 1405
				return error;

			/* if template was default, ignore error and use internal */
			giterr_clear();
			external_tpl = false;
1406
			error = 0;
1407 1408 1409 1410 1411 1412 1413 1414
		}
	}

	/* 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) {
1415
		if (!tpl->content) {
1416 1417 1418 1419 1420 1421
			uint32_t mkdir_flags = GIT_MKDIR_PATH;
			if (chmod)
				mkdir_flags |= GIT_MKDIR_CHMOD;

			error = git_futils_mkdir(
				tpl->path, repo_dir, dmode, mkdir_flags);
1422
		}
1423
		else if (!external_tpl) {
1424 1425 1426 1427 1428
			const char *content = tpl->content;

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

1429 1430
			error = repo_write_template(
				repo_dir, false, tpl->path, tpl->mode, false, content);
1431
		}
1432 1433
	}

1434
	return error;
1435 1436
}

1437 1438
static int mkdir_parent(git_buf *buf, uint32_t mode, bool skip2)
{
1439 1440 1441
	/* When making parent directories during repository initialization
	 * don't try to set gid or grant world write access
	 */
1442
	return git_futils_mkdir(
1443
		buf->ptr, NULL, mode & ~(S_ISGID | 0002),
1444 1445 1446 1447
		GIT_MKDIR_PATH | GIT_MKDIR_VERIFY_DIR |
		(skip2 ? GIT_MKDIR_SKIP_LAST2 : GIT_MKDIR_SKIP_LAST));
}

1448 1449 1450 1451 1452
static int repo_init_directories(
	git_buf *repo_path,
	git_buf *wd_path,
	const char *given_repo,
	git_repository_init_options *opts)
1453
{
1454
	int error = 0;
1455
	bool is_bare, add_dotgit, has_dotgit, natural_wd;
1456
	mode_t dirmode;
1457

1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
	/* 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
	 */

1478
	/* set up repo path */
1479

1480 1481
	is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);

1482 1483
	add_dotgit =
		(opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
1484
		!is_bare &&
1485 1486
		git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
		git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
1487

1488 1489
	if (git_buf_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
		return -1;
1490

1491 1492 1493 1494 1495 1496
	has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
	if (has_dotgit)
		opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;

	/* set up workdir path */

1497
	if (!is_bare) {
1498
		if (opts->workdir_path) {
1499 1500 1501
			if (git_path_join_unrooted(
					wd_path, opts->workdir_path, repo_path->ptr, NULL) < 0)
				return -1;
1502 1503 1504 1505 1506 1507 1508 1509
		} else if (has_dotgit) {
			if (git_path_dirname_r(wd_path, repo_path->ptr) < 0)
				return -1;
		} else {
			giterr_set(GITERR_REPOSITORY, "Cannot pick working directory"
				" for non-bare repository that isn't a '.git' directory");
			return -1;
		}
1510

1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
		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 */

1527
	dirmode = pick_dir_mode(opts);
1528

1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556
	if ((opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0) {
		/* create path #5 */
		if (wd_path->size > 0 &&
			(error = mkdir_parent(wd_path, dirmode, false)) < 0)
			return error;

		/* create path #3 (if not the same as #5) */
		if (!natural_wd &&
			(error = mkdir_parent(repo_path, dirmode, has_dotgit)) < 0)
			return error;
	}

	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0)
	{
		/* create path #4 */
		if (wd_path->size > 0 &&
			(error = git_futils_mkdir(
				wd_path->ptr, NULL, dirmode & ~S_ISGID,
				GIT_MKDIR_VERIFY_DIR)) < 0)
			return error;

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

1559 1560 1561 1562
	if ((opts->flags & GIT_REPOSITORY_INIT_MKDIR) != 0 ||
		(opts->flags & GIT_REPOSITORY_INIT_MKPATH) != 0 ||
		has_dotgit)
	{
1563
		/* create path #1 */
1564 1565
		error = git_futils_mkdir(repo_path->ptr, NULL, dirmode,
			GIT_MKDIR_VERIFY_DIR | ((dirmode & S_ISGID) ? GIT_MKDIR_CHMOD : 0));
1566
	}
1567

1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
	/* 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
1585
	if (!(error = git_remote_create(&remote, repo, GIT_REMOTE_ORIGIN, url))) {
1586 1587 1588 1589 1590 1591 1592 1593 1594
		git_remote_free(remote);
	}

	return error;
}

int git_repository_init(
	git_repository **repo_out, const char *path, unsigned is_bare)
{
1595
	git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
1596 1597 1598 1599 1600 1601 1602 1603 1604

	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(
1605
	git_repository **out,
1606 1607 1608 1609 1610
	const char *given_repo,
	git_repository_init_options *opts)
{
	int error;
	git_buf repo_path = GIT_BUF_INIT, wd_path = GIT_BUF_INIT;
1611
	const char *wd;
1612

1613
	assert(out && given_repo && opts);
1614

Ben Straub committed
1615
	GITERR_CHECK_VERSION(opts, GIT_REPOSITORY_INIT_OPTIONS_VERSION, "git_repository_init_options");
1616

1617 1618
	error = repo_init_directories(&repo_path, &wd_path, given_repo, opts);
	if (error < 0)
1619
		goto cleanup;
1620

1621
	wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_buf_cstr(&wd_path);
1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
	if (valid_repository_path(&repo_path)) {

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

		opts->flags |= GIT_REPOSITORY_INIT__IS_REINIT;

1633
		error = repo_init_config(
1634
			repo_path.ptr, wd, opts->flags, opts->mode);
1635 1636 1637 1638 1639

		/* TODO: reinitialize the templates */
	}
	else {
		if (!(error = repo_init_structure(
1640
				repo_path.ptr, wd, opts)) &&
1641
			!(error = repo_init_config(
1642
				repo_path.ptr, wd, opts->flags, opts->mode)))
1643
			error = repo_init_create_head(
1644
				repo_path.ptr, opts->initial_head);
1645
	}
1646 1647 1648
	if (error < 0)
		goto cleanup;

1649
	error = git_repository_open(out, repo_path.ptr);
1650

1651
	if (!error && opts->origin_url)
1652
		error = repo_init_create_origin(*out, opts->origin_url);
1653 1654

cleanup:
1655 1656 1657 1658
	git_buf_free(&repo_path);
	git_buf_free(&wd_path);

	return error;
1659
}
1660

1661
int git_repository_head_detached(git_repository *repo)
1662 1663
{
	git_reference *ref;
1664
	git_odb *odb = NULL;
1665
	int exists;
1666

1667 1668
	if (git_repository_odb__weakptr(&odb, repo) < 0)
		return -1;
1669

1670 1671
	if (git_reference_lookup(&ref, repo, GIT_HEAD_FILE) < 0)
		return -1;
1672

1673 1674
	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
		git_reference_free(ref);
1675
		return 0;
1676
	}
1677

1678
	exists = git_odb_exists(odb, git_reference_target(ref));
1679 1680

	git_reference_free(ref);
1681
	return exists;
1682 1683
}

1684
int git_repository_head(git_reference **head_out, git_repository *repo)
1685
{
1686
	git_reference *head;
1687 1688
	int error;

1689 1690 1691 1692 1693 1694 1695 1696
	if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
		return error;

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

1697
	error = git_reference_lookup_resolved(head_out, repo, git_reference_symbolic_target(head), -1);
1698
	git_reference_free(head);
1699

1700
	return error == GIT_ENOTFOUND ? GIT_EUNBORNBRANCH : error;
1701 1702
}

1703
int git_repository_head_unborn(git_repository *repo)
1704
{
1705
	git_reference *ref = NULL;
1706 1707 1708
	int error;

	error = git_repository_head(&ref, repo);
1709
	git_reference_free(ref);
1710

1711 1712
	if (error == GIT_EUNBORNBRANCH) {
		giterr_clear();
1713
		return 1;
1714
	}
1715

1716 1717 1718 1719
	if (error < 0)
		return -1;

	return 0;
1720
}
1721

1722
static int at_least_one_cb(const char *refname, void *payload)
1723
{
1724 1725
	GIT_UNUSED(refname);
	GIT_UNUSED(payload);
1726
	return GIT_PASSTHROUGH;
1727
}
1728

1729 1730
static int repo_contains_no_reference(git_repository *repo)
{
1731
	int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
1732

1733
	if (error == GIT_PASSTHROUGH)
1734
		return 0;
1735

1736 1737
	if (!error)
		return 1;
1738

1739
	return error;
1740
}
1741

1742 1743 1744
int git_repository_is_empty(git_repository *repo)
{
	git_reference *head = NULL;
1745
	int is_empty = 0;
1746

1747
	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0)
1748 1749
		return -1;

1750 1751 1752 1753 1754
	if (git_reference_type(head) == GIT_REF_SYMBOLIC)
		is_empty =
			(strcmp(git_reference_symbolic_target(head),
					GIT_REFS_HEADS_DIR "master") == 0) &&
			repo_contains_no_reference(repo);
1755 1756

	git_reference_free(head);
1757 1758

	return is_empty;
1759 1760
}

1761
const char *git_repository_path(git_repository *repo)
1762 1763
{
	assert(repo);
1764 1765
	return repo->path_repository;
}
1766

1767 1768 1769
const char *git_repository_workdir(git_repository *repo)
{
	assert(repo);
1770

1771 1772
	if (repo->is_bare)
		return NULL;
1773

1774 1775
	return repo->workdir;
}
1776

1777 1778
int git_repository_set_workdir(
	git_repository *repo, const char *workdir, int update_gitlink)
1779
{
1780
	int error = 0;
1781 1782
	git_buf path = GIT_BUF_INIT;

1783
	assert(repo && workdir);
1784

1785 1786
	if (git_path_prettify_dir(&path, workdir, NULL) < 0)
		return -1;
1787

1788 1789
	if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
		return 0;
1790

1791 1792 1793 1794 1795 1796
	if (update_gitlink) {
		git_config *config;

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

1797
		error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);
1798 1799 1800

		/* passthrough error means gitlink is unnecessary */
		if (error == GIT_PASSTHROUGH)
Ben Straub committed
1801
			error = git_config_delete_entry(config, "core.worktree");
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
		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;
1819
}
1820 1821 1822 1823 1824 1825

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

1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
int git_repository_set_bare(git_repository *repo)
{
	int error;
	git_config *config;

	assert(repo);

	if (repo->is_bare)
		return 0;

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

1840
	if ((error = git_config_set_bool(config, "core.bare", true)) < 0)
1841
		return error;
1842

1843 1844
	if ((error = git_config__update_entry(config, "core.worktree", NULL, true, true)) < 0)
		return error;
1845 1846 1847 1848 1849

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

1850
	return 0;
1851 1852
}

1853 1854
int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
1855 1856 1857
	git_reference *head;
	git_object *obj;
	int error;
1858

1859 1860
	if ((error = git_repository_head(&head, repo)) < 0)
		return error;
1861

1862 1863
	if ((error = git_reference_peel(&obj, head, GIT_OBJ_TREE)) < 0)
		goto cleanup;
1864 1865

	*tree = (git_tree *)obj;
1866 1867 1868 1869

cleanup:
	git_reference_free(head);
	return error;
1870
}
1871

1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
int git_repository__set_orig_head(git_repository *repo, const git_oid *orig_head)
{
	git_filebuf file = GIT_FILEBUF_INIT;
	git_buf file_path = GIT_BUF_INIT;
	char orig_head_str[GIT_OID_HEXSZ];
	int error = 0;

	git_oid_fmt(orig_head_str, orig_head);

	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_ORIG_HEAD_FILE)) == 0 &&
		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_MERGE_FILE_MODE)) == 0 &&
		(error = git_filebuf_printf(&file, "%.*s\n", GIT_OID_HEXSZ, orig_head_str)) == 0)
		error = git_filebuf_commit(&file);

	if (error < 0)
		git_filebuf_cleanup(&file);

	git_buf_free(&file_path);

	return error;
}

1894
int git_repository_message(git_buf *out, git_repository *repo)
1895
{
1896
	git_buf path = GIT_BUF_INIT;
Vicent Marti committed
1897 1898
	struct stat st;
	int error;
1899

1900
	git_buf_sanitize(out);
1901

Edward Thomson committed
1902
	if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
1903
		return -1;
1904

1905
	if ((error = p_stat(git_buf_cstr(&path), &st)) < 0) {
1906 1907
		if (errno == ENOENT)
			error = GIT_ENOTFOUND;
1908
		giterr_set(GITERR_OS, "Could not access message file");
1909 1910
	} else {
		error = git_futils_readbuffer(out, git_buf_cstr(&path));
Vicent Marti committed
1911
	}
1912

1913
	git_buf_free(&path);
1914 1915

	return error;
1916 1917 1918 1919
}

int git_repository_message_remove(git_repository *repo)
{
Vicent Marti committed
1920 1921
	git_buf path = GIT_BUF_INIT;
	int error;
1922

Edward Thomson committed
1923
	if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
Vicent Marti committed
1924
		return -1;
1925 1926 1927 1928 1929 1930

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

	return error;
}
1931 1932

int git_repository_hashfile(
Linquize committed
1933 1934 1935 1936 1937
	git_oid *out,
	git_repository *repo,
	const char *path,
	git_otype type,
	const char *as_path)
1938 1939
{
	int error;
1940
	git_filter_list *fl = NULL;
1941
	git_file fd = -1;
1942 1943 1944
	git_off_t len;
	git_buf full_path = GIT_BUF_INIT;

1945 1946 1947 1948 1949 1950
	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.
	 */
1951 1952

	error = git_path_join_unrooted(
1953
		&full_path, path, git_repository_workdir(repo), NULL);
1954 1955 1956 1957 1958 1959 1960 1961
	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
1962
		error = git_filter_list_load(
1963
			&fl, repo, NULL, as_path,
1964
			GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT);
1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980
		if (error < 0)
			return error;
	} else {
		error = 0;
	}

	/* at this point, error is a count of the number of loaded filters */

	fd = git_futils_open_ro(full_path.ptr);
	if (fd < 0) {
		error = fd;
		goto cleanup;
	}

	len = git_futils_filesize(fd);
	if (len < 0) {
1981
		error = (int)len;
1982 1983 1984 1985 1986 1987 1988 1989 1990
		goto cleanup;
	}

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

1991
	error = git_odb__hashfd_filtered(out, fd, (size_t)len, type, fl);
1992 1993

cleanup:
1994 1995
	if (fd >= 0)
		p_close(fd);
1996
	git_filter_list_free(fl);
1997 1998 1999 2000 2001
	git_buf_free(&full_path);

	return error;
}

2002
static int checkout_message(git_buf *out, git_reference *old, const char *new)
2003
{
2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
	git_buf_puts(out, "checkout: moving from ");

	if (git_reference_type(old) == GIT_REF_SYMBOLIC)
		git_buf_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
	else
		git_buf_puts(out, git_oid_tostr_s(git_reference_target(old)));

	git_buf_puts(out, " to ");

	if (git_reference__is_branch(new))
		git_buf_puts(out, git_reference__shorthand(new));
	else
		git_buf_puts(out, new);

	if (git_buf_oom(out))
		return -1;

	return 0;
2022 2023 2024 2025
}

int git_repository_set_head(
	git_repository* repo,
2026
	const char* refname)
2027
{
2028 2029
	git_reference *ref = NULL, *current = NULL, *new_head = NULL;
	git_buf log_message = GIT_BUF_INIT;
2030 2031 2032 2033
	int error;

	assert(repo && refname);

2034 2035 2036 2037 2038 2039
	if ((error = git_reference_lookup(&current, repo, GIT_HEAD_FILE)) < 0)
		return error;

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

2040 2041
	error = git_reference_lookup(&ref, repo, refname);
	if (error < 0 && error != GIT_ENOTFOUND)
2042
		goto cleanup;
2043 2044

	if (!error) {
2045 2046
		if (git_reference_is_branch(ref)) {
			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
2047
					git_reference_name(ref), true, git_buf_cstr(&log_message));
2048
		} else {
2049
			error = git_repository_set_head_detached(repo, git_reference_target(ref));
2050
		}
2051
	} else if (git_reference__is_branch(refname)) {
2052
		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
2053
				true, git_buf_cstr(&log_message));
2054
	}
2055

2056
cleanup:
2057
	git_buf_free(&log_message);
2058
	git_reference_free(current);
2059 2060 2061 2062 2063
	git_reference_free(ref);
	git_reference_free(new_head);
	return error;
}

2064
static int detach(git_repository *repo, const git_oid *id, const char *from)
2065 2066
{
	int error;
2067 2068 2069
	git_buf log_message = GIT_BUF_INIT;
	git_object *object = NULL, *peeled = NULL;
	git_reference *new_head = NULL, *current = NULL;
2070

2071
	assert(repo && id);
2072

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

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

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

2082 2083 2084 2085
	if (from == NULL)
		from = git_oid_tostr_s(git_object_id(peeled));

	if ((error = checkout_message(&log_message, current, from)) < 0)
2086 2087 2088
		goto cleanup;

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

cleanup:
2091
	git_buf_free(&log_message);
2092 2093
	git_object_free(object);
	git_object_free(peeled);
2094
	git_reference_free(current);
2095 2096 2097 2098
	git_reference_free(new_head);
	return error;
}

2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
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);

	return detach(repo, git_annotated_commit_id(commitish), commitish->ref_name);
}

2115
int git_repository_detach_head(git_repository* repo)
2116
{
2117
	git_reference *old_head = NULL,	*new_head = NULL, *current = NULL;
2118
	git_object *object = NULL;
2119
	git_buf log_message = GIT_BUF_INIT;
2120
	int error;
2121 2122 2123

	assert(repo);

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

2127 2128 2129
	if ((error = git_repository_head(&old_head, repo)) < 0)
		goto cleanup;

2130
	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
2131 2132
		goto cleanup;

2133 2134 2135
	if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
		goto cleanup;

2136
	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
2137
			1, git_buf_cstr(&log_message));
2138 2139

cleanup:
2140
	git_buf_free(&log_message);
2141 2142 2143
	git_object_free(object);
	git_reference_free(old_head);
	git_reference_free(new_head);
2144
	git_reference_free(current);
2145 2146
	return error;
}
Edward Thomson committed
2147

2148 2149 2150 2151
/**
 * Loosely ported from git.git
 * https://github.com/git/git/blob/master/contrib/completion/git-prompt.sh#L198-289
 */
Edward Thomson committed
2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
int git_repository_state(git_repository *repo)
{
	git_buf repo_path = GIT_BUF_INIT;
	int state = GIT_REPOSITORY_STATE_NONE;

	assert(repo);

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

2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172
	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
2173 2174 2175
		state = GIT_REPOSITORY_STATE_MERGE;
	else if(git_path_contains_file(&repo_path, GIT_REVERT_HEAD_FILE))
		state = GIT_REPOSITORY_STATE_REVERT;
2176 2177
	else if(git_path_contains_file(&repo_path, GIT_CHERRYPICK_HEAD_FILE))
		state = GIT_REPOSITORY_STATE_CHERRYPICK;
2178 2179
	else if(git_path_contains_file(&repo_path, GIT_BISECT_LOG_FILE))
		state = GIT_REPOSITORY_STATE_BISECT;
Edward Thomson committed
2180 2181 2182 2183

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

2185 2186
int git_repository__cleanup_files(
	git_repository *repo, const char *files[], size_t files_len)
2187
{
2188
	git_buf buf = GIT_BUF_INIT;
2189
	size_t i;
2190
	int error;
2191

2192 2193
	for (error = 0, i = 0; !error && i < files_len; ++i) {
		const char *path;
2194

2195 2196
		if (git_buf_joinpath(&buf, repo->path_repository, files[i]) < 0)
			return -1;
2197

2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
		path = git_buf_cstr(&buf);

		if (git_path_isfile(path)) {
			error = p_unlink(path);
		} else if (git_path_isdir(path)) {
			error = git_futils_rmdir_r(path, NULL,
				GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS);
		}
			
		git_buf_clear(&buf);
	}
2209

2210
	git_buf_free(&buf);
2211 2212 2213 2214 2215 2216 2217 2218
	return error;
}

static const char *state_files[] = {
	GIT_MERGE_HEAD_FILE,
	GIT_MERGE_MODE_FILE,
	GIT_MERGE_MSG_FILE,
	GIT_REVERT_HEAD_FILE,
2219
	GIT_CHERRYPICK_HEAD_FILE,
2220 2221 2222
	GIT_BISECT_LOG_FILE,
	GIT_REBASE_MERGE_DIR,
	GIT_REBASE_APPLY_DIR,
2223 2224 2225 2226 2227 2228 2229 2230 2231
};

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
2232 2233 2234 2235
int git_repository_is_shallow(git_repository *repo)
{
	git_buf path = GIT_BUF_INIT;
	struct stat st;
Ben Straub committed
2236
	int error;
Ben Straub committed
2237

2238 2239 2240
	if ((error = git_buf_joinpath(&path, repo->path_repository, "shallow")) < 0)
		return error;

Ben Straub committed
2241 2242
	error = git_path_lstat(path.ptr, &st);
	git_buf_free(&path);
Ben Straub committed
2243

2244 2245
	if (error == GIT_ENOTFOUND) {
		giterr_clear();
Ben Straub committed
2246
		return 0;
2247 2248
	}

Ben Straub committed
2249 2250 2251
	if (error < 0)
		return error;
	return st.st_size == 0 ? 0 : 1;
Ben Straub committed
2252
}
2253

2254 2255
int git_repository_init_init_options(
	git_repository_init_options *opts, unsigned int version)
2256
{
2257 2258 2259 2260
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
		opts, version, git_repository_init_options,
		GIT_REPOSITORY_INIT_OPTIONS_INIT);
	return 0;
2261
}
2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292

int git_repository_ident(const char **name, const char **email, const git_repository *repo)
{
	*name = repo->ident_name;
	*email = repo->ident_email;

	return 0;
}

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

	if (name) {
		tmp_name = git__strdup(name);
		GITERR_CHECK_ALLOC(tmp_name);
	}

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

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

	git__free(tmp_name);
	git__free(tmp_email);

	return 0;
}