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

8 9
#include "refdb_fs.h"

10 11 12 13
#include "refs.h"
#include "hash.h"
#include "repository.h"
#include "fileops.h"
14
#include "filebuf.h"
15 16 17
#include "pack.h"
#include "reflog.h"
#include "refdb.h"
18
#include "iterator.h"
19
#include "sortedcache.h"
20
#include "signature.h"
21 22 23 24

#include <git2/tag.h>
#include <git2/object.h>
#include <git2/refdb.h>
25
#include <git2/branch.h>
26
#include <git2/sys/refdb_backend.h>
27
#include <git2/sys/refs.h>
28
#include <git2/sys/reflog.h>
29 30 31 32 33

#define DEFAULT_NESTING_LEVEL	5
#define MAX_NESTING_LEVEL		10

enum {
34 35
	PACKREF_HAS_PEEL = 1,
	PACKREF_WAS_LOOSE = 2,
36 37
	PACKREF_CANNOT_PEEL = 4,
	PACKREF_SHADOWED = 8,
38 39 40 41 42 43
};

enum {
	PEELING_NONE = 0,
	PEELING_STANDARD,
	PEELING_FULL
44 45 46 47 48 49 50 51 52 53 54 55 56
};

struct packref {
	git_oid oid;
	git_oid peel;
	char flags;
	char name[GIT_FLEX_ARRAY];
};

typedef struct refdb_fs_backend {
	git_refdb_backend parent;

	git_repository *repo;
57 58
	/* path to git directory */
	char *gitpath;
59 60
	/* path to common objects' directory */
	char *commonpath;
61

62
	git_sortedcache *refcache;
63
	int peeling_mode;
64 65
	git_iterator_flag_t iterator_flags;
	uint32_t direach_flags;
66
	int fsync;
67 68
} refdb_fs_backend;

69 70
static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name);

71
static int packref_cmp(const void *a_, const void *b_)
72
{
73 74
	const struct packref *a = a_, *b = b_;
	return strcmp(a->name, b->name);
75 76
}

77
static int packed_reload(refdb_fs_backend *backend)
78
{
79 80 81
	int error;
	git_buf packedrefs = GIT_BUF_INIT;
	char *scan, *eof, *eol;
82

83
	if (!backend->gitpath)
84 85
		return 0;

86
	error = git_sortedcache_lockandload(backend->refcache, &packedrefs);
87 88

	/*
89 90 91 92
	 * If we can't find the packed-refs, clear table and return.
	 * Any other error just gets passed through.
	 * If no error, and file wasn't changed, just return.
	 * Anything else means we need to refresh the packed refs.
93
	 */
94 95 96 97 98 99 100
	if (error <= 0) {
		if (error == GIT_ENOTFOUND) {
			git_sortedcache_clear(backend->refcache, true);
			giterr_clear();
			error = 0;
		}
		return error;
101 102
	}

103
	/* At this point, refresh the packed refs from the loaded buffer. */
104

105
	git_sortedcache_clear(backend->refcache, false);
106

107 108
	scan = (char *)packedrefs.ptr;
	eof  = scan + packedrefs.size;
109

110 111
	backend->peeling_mode = PEELING_NONE;

112
	if (*scan == '#') {
nulltoken committed
113
		static const char *traits_header = "# pack-refs with: ";
114

115 116 117
		if (git__prefixcmp(scan, traits_header) == 0) {
			scan += strlen(traits_header);
			eol = strchr(scan, '\n');
118

119
			if (!eol)
120
				goto parse_failed;
121
			*eol = '\0';
122

123
			if (strstr(scan, " fully-peeled ") != NULL) {
124
				backend->peeling_mode = PEELING_FULL;
125
			} else if (strstr(scan, " peeled ") != NULL) {
126 127 128
				backend->peeling_mode = PEELING_STANDARD;
			}

129
			scan = eol + 1;
130 131 132
		}
	}

133 134
	while (scan < eof && *scan == '#') {
		if (!(eol = strchr(scan, '\n')))
135
			goto parse_failed;
136
		scan = eol + 1;
137 138
	}

139 140 141 142 143
	while (scan < eof) {
		struct packref *ref;
		git_oid oid;

		/* parse "<OID> <refname>\n" */
144

145
		if (git_oid_fromstr(&oid, scan) < 0)
146
			goto parse_failed;
147
		scan += GIT_OID_HEXSZ;
148

149 150 151 152 153 154 155
		if (*scan++ != ' ')
			goto parse_failed;
		if (!(eol = strchr(scan, '\n')))
			goto parse_failed;
		*eol = '\0';
		if (eol[-1] == '\r')
			eol[-1] = '\0';
156

157
		if (git_sortedcache_upsert((void **)&ref, backend->refcache, scan) < 0)
158
			goto parse_failed;
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
		scan = eol + 1;

		git_oid_cpy(&ref->oid, &oid);

		/* look for optional "^<OID>\n" */

		if (*scan == '^') {
			if (git_oid_fromstr(&oid, scan + 1) < 0)
				goto parse_failed;
			scan += GIT_OID_HEXSZ + 1;

			if (scan < eof) {
				if (!(eol = strchr(scan, '\n')))
					goto parse_failed;
				scan = eol + 1;
			}

			git_oid_cpy(&ref->peel, &oid);
			ref->flags |= PACKREF_HAS_PEEL;
		}
		else if (backend->peeling_mode == PEELING_FULL ||
				(backend->peeling_mode == PEELING_STANDARD &&
				 git__prefixcmp(ref->name, GIT_REFS_TAGS_DIR) == 0))
			ref->flags |= PACKREF_CANNOT_PEEL;
183 184
	}

185
	git_sortedcache_wunlock(backend->refcache);
186
	git_buf_dispose(&packedrefs);
187

188 189 190
	return 0;

parse_failed:
191
	giterr_set(GITERR_REFERENCE, "corrupted packed references file");
192 193

	git_sortedcache_clear(backend->refcache, false);
194
	git_sortedcache_wunlock(backend->refcache);
195
	git_buf_dispose(&packedrefs);
196

197 198 199
	return -1;
}

200 201
static int loose_parse_oid(
	git_oid *oid, const char *filename, git_buf *file_content)
202
{
203
	const char *str = git_buf_cstr(file_content);
204

205
	if (git_buf_len(file_content) < GIT_OID_HEXSZ)
206 207 208
		goto corrupted;

	/* we need to get 40 OID characters from the file */
209
	if (git_oid_fromstr(oid, str) < 0)
210 211 212 213 214 215 216 217
		goto corrupted;

	/* If the file is longer than 40 chars, the 41st must be a space */
	str += GIT_OID_HEXSZ;
	if (*str == '\0' || git__isspace(*str))
		return 0;

corrupted:
218
	giterr_set(GITERR_REFERENCE, "corrupted loose reference file: %s", filename);
219 220 221
	return -1;
}

222 223 224 225 226 227 228
static int loose_readbuffer(git_buf *buf, const char *base, const char *path)
{
	int error;

	/* build full path to file */
	if ((error = git_buf_joinpath(buf, base, path)) < 0 ||
		(error = git_futils_readbuffer(buf, buf->ptr)) < 0)
229
		git_buf_dispose(buf);
230 231 232 233 234

	return error;
}

static int loose_lookup_to_packfile(refdb_fs_backend *backend, const char *name)
235
{
236
	int error = 0;
237 238
	git_buf ref_file = GIT_BUF_INIT;
	struct packref *ref = NULL;
239
	git_oid oid;
240

241 242 243
	/* if we fail to load the loose reference, assume someone changed
	 * the filesystem under us and skip it...
	 */
244
	if (loose_readbuffer(&ref_file, backend->gitpath, name) < 0) {
245 246 247
		giterr_clear();
		goto done;
	}
248

249
	/* skip symbolic refs */
250 251
	if (!git__prefixcmp(git_buf_cstr(&ref_file), GIT_SYMREF))
		goto done;
252

253 254 255
	/* parse OID from file */
	if ((error = loose_parse_oid(&oid, name, &ref_file)) < 0)
		goto done;
256

257
	git_sortedcache_wlock(backend->refcache);
258

259 260
	if (!(error = git_sortedcache_upsert(
			(void **)&ref, backend->refcache, name))) {
261

262 263
		git_oid_cpy(&ref->oid, &oid);
		ref->flags = PACKREF_WAS_LOOSE;
264 265
	}

266
	git_sortedcache_wunlock(backend->refcache);
267

268
done:
269
	git_buf_dispose(&ref_file);
270
	return error;
271 272
}

273
static int _dirent_loose_load(void *payload, git_buf *full_path)
274
{
275
	refdb_fs_backend *backend = payload;
276 277
	const char *file_path;

278 279 280
	if (git__suffixcmp(full_path->ptr, ".lock") == 0)
		return 0;

281 282
	if (git_path_isdir(full_path->ptr)) {
		int error = git_path_direach(
283
			full_path, backend->direach_flags, _dirent_loose_load, backend);
284 285 286 287 288 289 290 291
		/* Race with the filesystem, ignore it */
		if (error == GIT_ENOTFOUND) {
			giterr_clear();
			return 0;
		}

		return error;
	}
292

293
	file_path = full_path->ptr + strlen(backend->gitpath);
294

295
	return loose_lookup_to_packfile(backend, file_path);
296 297 298 299 300 301 302 303 304 305
}

/*
 * Load all the loose references from the repository
 * into the in-memory Packfile, and build a vector with
 * all the references so it can be written back to
 * disk.
 */
static int packed_loadloose(refdb_fs_backend *backend)
{
306
	int error;
307 308
	git_buf refs_path = GIT_BUF_INIT;

309
	if (git_buf_joinpath(&refs_path, backend->gitpath, GIT_REFS_DIR) < 0)
310 311 312 313 314 315 316
		return -1;

	/*
	 * Load all the loose files from disk into the Packfile table.
	 * This will overwrite any old packed entries with their
	 * updated loose versions
	 */
317
	error = git_path_direach(
318
		&refs_path, backend->direach_flags, _dirent_loose_load, backend);
319

320
	git_buf_dispose(&refs_path);
321

322
	return error;
323 324 325 326 327 328 329
}

static int refdb_fs_backend__exists(
	int *exists,
	git_refdb_backend *_backend,
	const char *ref_name)
{
330
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
331
	git_buf ref_path = GIT_BUF_INIT;
332
	int error;
333

334
	assert(backend);
335

336
	if ((error = packed_reload(backend)) < 0 ||
337
		(error = git_buf_joinpath(&ref_path, backend->gitpath, ref_name)) < 0)
338
		return error;
339

340
	*exists = git_path_isfile(ref_path.ptr) ||
341
		(git_sortedcache_lookup(backend->refcache, ref_name) != NULL);
342

343
	git_buf_dispose(&ref_path);
344 345 346 347 348 349 350 351 352 353 354
	return 0;
}

static const char *loose_parse_symbolic(git_buf *file_content)
{
	const unsigned int header_len = (unsigned int)strlen(GIT_SYMREF);
	const char *refname_start;

	refname_start = (const char *)file_content->ptr;

	if (git_buf_len(file_content) < header_len + 1) {
355
		giterr_set(GITERR_REFERENCE, "corrupted loose reference file");
356 357 358 359 360 361 362 363 364 365 366 367
		return NULL;
	}

	/*
	 * Assume we have already checked for the header
	 * before calling this function
	 */
	refname_start += header_len;

	return refname_start;
}

368 369 370 371 372 373 374
/*
 * Returns whether a reference is stored per worktree or not.
 * Per-worktree references are:
 *
 * - all pseudorefs, e.g. HEAD and MERGE_HEAD
 * - all references stored inside of "refs/bisect/"
 */
375 376
static bool is_per_worktree_ref(const char *ref_name)
{
377 378
	return git__prefixcmp(ref_name, "refs/") != 0 ||
	    git__prefixcmp(ref_name, "refs/bisect/") == 0;
379 380
}

381 382 383 384 385 386 387
static int loose_lookup(
	git_reference **out,
	refdb_fs_backend *backend,
	const char *ref_name)
{
	git_buf ref_file = GIT_BUF_INIT;
	int error = 0;
388
	const char *ref_dir;
389

390 391 392
	if (out)
		*out = NULL;

393 394 395 396 397 398
	if (is_per_worktree_ref(ref_name))
		ref_dir = backend->gitpath;
	else
		ref_dir = backend->commonpath;

	if ((error = loose_readbuffer(&ref_file, ref_dir, ref_name)) < 0)
399 400 401
		/* cannot read loose ref file - gah */;
	else if (git__prefixcmp(git_buf_cstr(&ref_file), GIT_SYMREF) == 0) {
		const char *target;
402 403 404

		git_buf_rtrim(&ref_file);

405
		if (!(target = loose_parse_symbolic(&ref_file)))
406
			error = -1;
407
		else if (out != NULL)
408
			*out = git_reference__alloc_symbolic(ref_name, target);
409
	} else {
410
		git_oid oid;
411

412 413
		if (!(error = loose_parse_oid(&oid, ref_name, &ref_file)) &&
			out != NULL)
414
			*out = git_reference__alloc(ref_name, &oid, NULL);
415 416
	}

417
	git_buf_dispose(&ref_file);
418 419 420
	return error;
}

421
static int ref_error_notfound(const char *name)
422
{
423
	giterr_set(GITERR_REFERENCE, "reference '%s' not found", name);
424
	return GIT_ENOTFOUND;
425 426 427 428 429 430 431 432
}

static int packed_lookup(
	git_reference **out,
	refdb_fs_backend *backend,
	const char *ref_name)
{
	int error = 0;
433
	struct packref *entry;
434

435 436
	if ((error = packed_reload(backend)) < 0)
		return error;
437

438 439
	if (git_sortedcache_rlock(backend->refcache) < 0)
		return -1;
440 441 442 443 444 445 446 447 448 449

	entry = git_sortedcache_lookup(backend->refcache, ref_name);
	if (!entry) {
		error = ref_error_notfound(ref_name);
	} else {
		*out = git_reference__alloc(ref_name, &entry->oid, &entry->peel);
		if (!*out)
			error = -1;
	}

450 451
	git_sortedcache_runlock(backend->refcache);

452
	return error;
453 454 455 456 457 458 459
}

static int refdb_fs_backend__lookup(
	git_reference **out,
	git_refdb_backend *_backend,
	const char *ref_name)
{
460 461
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
	int error;
462

463
	assert(backend);
464

465
	if (!(error = loose_lookup(out, backend, ref_name)))
466 467 468 469
		return 0;

	/* only try to lookup this reference on the packfile if it
	 * wasn't found on the loose refs; not if there was a critical error */
470
	if (error == GIT_ENOTFOUND) {
471
		giterr_clear();
472
		error = packed_lookup(out, backend, ref_name);
473 474
	}

475
	return error;
476 477
}

478 479
typedef struct {
	git_reference_iterator parent;
480

481
	char *glob;
482 483

	git_pool pool;
484
	git_vector loose;
485

486
	git_sortedcache *cache;
487 488
	size_t loose_pos;
	size_t packed_pos;
489 490 491
} refdb_fs_iter;

static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)
492
{
493
	refdb_fs_iter *iter = (refdb_fs_iter *) _iter;
494 495

	git_vector_free(&iter->loose);
496
	git_pool_clear(&iter->pool);
497
	git_sortedcache_free(iter->cache);
498 499
	git__free(iter);
}
500

501
static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter)
502
{
503
	int error = 0;
504
	git_buf path = GIT_BUF_INIT;
505
	git_iterator *fsit = NULL;
506
	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
507
	const git_index_entry *entry = NULL;
508 509
	const char *ref_prefix = GIT_REFS_DIR;
	size_t ref_prefix_len = strlen(ref_prefix);
510

511
	if (!backend->commonpath) /* do nothing if no commonpath for loose refs */
512 513
		return 0;

514 515
	fsit_opts.flags = backend->iterator_flags;

516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
	if (iter->glob) {
		const char *last_sep = NULL;
		const char *pos;
		for (pos = iter->glob; *pos; ++pos) {
			switch (*pos) {
			case '?':
			case '*':
			case '[':
			case '\\':
				break;
			case '/':
				last_sep = pos;
				/* FALLTHROUGH */
			default:
				continue;
			}
			break;
		}
		if (last_sep) {
			ref_prefix = iter->glob;
			ref_prefix_len = (last_sep - ref_prefix) + 1;
		}
	}

540
	if ((error = git_buf_printf(&path, "%s/", backend->commonpath)) < 0 ||
541
		(error = git_buf_put(&path, ref_prefix, ref_prefix_len)) < 0) {
542
		git_buf_dispose(&path);
543 544
		return error;
	}
545

546
	if ((error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {
547
		git_buf_dispose(&path);
548 549 550
		return (iter->glob && error == GIT_ENOTFOUND)? 0 : error;
	}

551
	error = git_buf_sets(&path, ref_prefix);
552

553
	while (!error && !git_iterator_advance(&entry, fsit)) {
554
		const char *ref_name;
555
		struct packref *ref;
556
		char *ref_dup;
557

558
		git_buf_truncate(&path, ref_prefix_len);
559 560
		git_buf_puts(&path, entry->path);
		ref_name = git_buf_cstr(&path);
561

562
		if (git__suffixcmp(ref_name, ".lock") == 0 ||
563
			(iter->glob && p_fnmatch(iter->glob, ref_name, 0) != 0))
564
			continue;
565

566
		git_sortedcache_rlock(backend->refcache);
567 568
		ref = git_sortedcache_lookup(backend->refcache, ref_name);
		if (ref)
569
			ref->flags |= PACKREF_SHADOWED;
570
		git_sortedcache_runlock(backend->refcache);
571

572 573
		ref_dup = git_pool_strdup(&iter->pool, ref_name);
		if (!ref_dup)
574
			error = -1;
575 576
		else
			error = git_vector_insert(&iter->loose, ref_dup);
577
	}
578

579
	git_iterator_free(fsit);
580
	git_buf_dispose(&path);
581

582
	return error;
583 584
}

585 586
static int refdb_fs_backend__iterator_next(
	git_reference **out, git_reference_iterator *_iter)
587
{
588
	int error = GIT_ITEROVER;
589
	refdb_fs_iter *iter = (refdb_fs_iter *)_iter;
590
	refdb_fs_backend *backend = (refdb_fs_backend *)iter->parent.db->backend;
591
	struct packref *ref;
592

Vicent Marti committed
593
	while (iter->loose_pos < iter->loose.length) {
594
		const char *path = git_vector_get(&iter->loose, iter->loose_pos++);
Vicent Marti committed
595 596 597 598 599

		if (loose_lookup(out, backend, path) == 0)
			return 0;

		giterr_clear();
600
	}
601

602 603 604 605
	if (!iter->cache) {
		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
			return error;
	}
606

607 608 609
	error = GIT_ITEROVER;
	while (iter->packed_pos < git_sortedcache_entrycount(iter->cache)) {
		ref = git_sortedcache_entry(iter->cache, iter->packed_pos++);
610 611
		if (!ref) /* stop now if another thread deleted refs and we past end */
			break;
612 613 614 615 616

		if (ref->flags & PACKREF_SHADOWED)
			continue;
		if (iter->glob && p_fnmatch(iter->glob, ref->name, 0) != 0)
			continue;
617

Vicent Marti committed
618
		*out = git_reference__alloc(ref->name, &ref->oid, &ref->peel);
619 620
		error = (*out != NULL) ? 0 : -1;
		break;
621 622
	}

623
	return error;
624 625
}

626 627 628
static int refdb_fs_backend__iterator_next_name(
	const char **out, git_reference_iterator *_iter)
{
629
	int error = GIT_ITEROVER;
630 631
	refdb_fs_iter *iter = (refdb_fs_iter *)_iter;
	refdb_fs_backend *backend = (refdb_fs_backend *)iter->parent.db->backend;
632
	struct packref *ref;
633 634 635 636

	while (iter->loose_pos < iter->loose.length) {
		const char *path = git_vector_get(&iter->loose, iter->loose_pos++);

637 638 639
		if (loose_lookup(NULL, backend, path) == 0) {
			*out = path;
			return 0;
640 641
		}

642
		giterr_clear();
643 644
	}

645 646 647 648
	if (!iter->cache) {
		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
			return error;
	}
649

650 651 652
	error = GIT_ITEROVER;
	while (iter->packed_pos < git_sortedcache_entrycount(iter->cache)) {
		ref = git_sortedcache_entry(iter->cache, iter->packed_pos++);
653 654
		if (!ref) /* stop now if another thread deleted refs and we past end */
			break;
655 656 657

		if (ref->flags & PACKREF_SHADOWED)
			continue;
658
		if (iter->glob && p_fnmatch(iter->glob, ref->name, 0) != 0)
659 660
			continue;

661 662 663
		*out = ref->name;
		error = 0;
		break;
664 665
	}

666
	return error;
667 668 669 670 671
}

static int refdb_fs_backend__iterator(
	git_reference_iterator **out, git_refdb_backend *_backend, const char *glob)
{
672
	int error;
673
	refdb_fs_iter *iter;
674
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
675

676
	assert(backend);
677

678 679
	if ((error = packed_reload(backend)) < 0)
		return error;
680 681 682 683

	iter = git__calloc(1, sizeof(refdb_fs_iter));
	GITERR_CHECK_ALLOC(iter);

684 685 686
	git_pool_init(&iter->pool, 1);

	if (git_vector_init(&iter->loose, 8, NULL) < 0)
687 688 689 690 691
		goto fail;

	if (glob != NULL &&
		(iter->glob = git_pool_strdup(&iter->pool, glob)) == NULL)
		goto fail;
692 693 694 695 696

	iter->parent.next = refdb_fs_backend__iterator_next;
	iter->parent.next_name = refdb_fs_backend__iterator_next_name;
	iter->parent.free = refdb_fs_backend__iterator_free;

697 698
	if (iter_load_loose_paths(backend, iter) < 0)
		goto fail;
699 700 701

	*out = (git_reference_iterator *)iter;
	return 0;
702 703 704 705

fail:
	refdb_fs_backend__iterator_free((git_reference_iterator *)iter);
	return -1;
706 707
}

Vicent Marti committed
708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
static bool ref_is_available(
	const char *old_ref, const char *new_ref, const char *this_ref)
{
	if (old_ref == NULL || strcmp(old_ref, this_ref)) {
		size_t reflen = strlen(this_ref);
		size_t newlen = strlen(new_ref);
		size_t cmplen = reflen < newlen ? reflen : newlen;
		const char *lead = reflen < newlen ? new_ref : this_ref;

		if (!strncmp(new_ref, this_ref, cmplen) && lead[cmplen] == '/') {
			return false;
		}
	}

	return true;
}

static int reference_path_available(
	refdb_fs_backend *backend,
	const char *new_ref,
	const char* old_ref,
	int force)
{
731
	size_t i;
732
	int error;
Vicent Marti committed
733

734 735
	if ((error = packed_reload(backend)) < 0)
		return error;
Vicent Marti committed
736 737 738 739

	if (!force) {
		int exists;

740 741 742 743
		if ((error = refdb_fs_backend__exists(
			&exists, (git_refdb_backend *)backend, new_ref)) < 0) {
			return error;
		}
Vicent Marti committed
744 745 746

		if (exists) {
			giterr_set(GITERR_REFERENCE,
747
				"failed to write reference '%s': a reference with "
748
				"that name already exists.", new_ref);
Vicent Marti committed
749 750 751 752
			return GIT_EEXISTS;
		}
	}

753
	git_sortedcache_rlock(backend->refcache);
754 755

	for (i = 0; i < git_sortedcache_entrycount(backend->refcache); ++i) {
756
		struct packref *ref = git_sortedcache_entry(backend->refcache, i);
757

758 759
		if (ref && !ref_is_available(old_ref, new_ref, ref->name)) {
			git_sortedcache_runlock(backend->refcache);
Vicent Marti committed
760
			giterr_set(GITERR_REFERENCE,
761
				"path to reference '%s' collides with existing one", new_ref);
Vicent Marti committed
762 763
			return -1;
		}
764
	}
765

766
	git_sortedcache_runlock(backend->refcache);
Vicent Marti committed
767 768
	return 0;
}
769

770
static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char *name)
771
{
772
	int error, filebuf_flags;
773
	git_buf ref_path = GIT_BUF_INIT;
774
	const char *basedir;
775

776
	assert(file && backend && name);
777

778
	if (!git_path_isvalid(backend->repo, name, 0, GIT_PATH_REJECT_FILESYSTEM_DEFAULTS)) {
779
		giterr_set(GITERR_INVALID, "invalid reference name '%s'", name);
780 781 782
		return GIT_EINVALIDSPEC;
	}

783 784 785 786 787
	if (is_per_worktree_ref(name))
		basedir = backend->gitpath;
	else
		basedir = backend->commonpath;

788 789 790
	/* Remove a possibly existing empty directory hierarchy
	 * which name would collide with the reference name
	 */
791
	if ((error = git_futils_rmdir_r(name, basedir, GIT_RMDIR_SKIP_NONEMPTY)) < 0)
792
		return error;
793

794
	if (git_buf_joinpath(&ref_path, basedir, name) < 0)
795 796
		return -1;

797
	filebuf_flags = GIT_FILEBUF_FORCE;
798
	if (backend->fsync)
799 800 801
		filebuf_flags |= GIT_FILEBUF_FSYNC;

	error = git_filebuf_open(file, ref_path.ptr, filebuf_flags, GIT_REFS_FILE_MODE);
802

803 804 805
	if (error == GIT_EDIRECTORY)
		giterr_set(GITERR_REFERENCE, "cannot lock ref '%s', there are refs beneath that folder", name);

806
	git_buf_dispose(&ref_path);
807
	return error;
808
}
809

810 811
static int loose_commit(git_filebuf *file, const git_reference *ref)
{
812 813
	assert(file && ref);

814 815
	if (ref->type == GIT_REF_OID) {
		char oid[GIT_OID_HEXSZ + 1];
816
		git_oid_nfmt(oid, sizeof(oid), &ref->target.oid);
817

818
		git_filebuf_printf(file, "%s\n", oid);
819
	} else if (ref->type == GIT_REF_SYMBOLIC) {
820
		git_filebuf_printf(file, GIT_SYMREF "%s\n", ref->target.symbolic);
821 822 823 824
	} else {
		assert(0); /* don't let this happen */
	}

825
	return git_filebuf_commit(file);
826 827
}

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
static int refdb_fs_backend__lock(void **out, git_refdb_backend *_backend, const char *refname)
{
	int error;
	git_filebuf *lock;
	refdb_fs_backend *backend = (refdb_fs_backend *) _backend;

	lock = git__calloc(1, sizeof(git_filebuf));
	GITERR_CHECK_ALLOC(lock);

	if ((error = loose_lock(lock, backend, refname)) < 0) {
		git__free(lock);
		return error;
	}

	*out = lock;
	return 0;
}

static int refdb_fs_backend__write_tail(
	git_refdb_backend *_backend,
	const git_reference *ref,
	git_filebuf *file,
	int update_reflog,
	const git_signature *who,
	const char *message,
	const git_oid *old_id,
	const char *old_target);

static int refdb_fs_backend__delete_tail(
	git_refdb_backend *_backend,
	git_filebuf *file,
	const char *ref_name,
	const git_oid *old_id, const char *old_target);

static int refdb_fs_backend__unlock(git_refdb_backend *backend, void *payload, int success, int update_reflog,
				    const git_reference *ref, const git_signature *sig, const char *message)
{
	git_filebuf *lock = (git_filebuf *) payload;
	int error = 0;

	if (success == 2)
		error = refdb_fs_backend__delete_tail(backend, lock, ref->name, NULL, NULL);
	else if (success)
		error = refdb_fs_backend__write_tail(backend, ref, lock, update_reflog, sig, message, NULL, NULL);
	else
		git_filebuf_cleanup(lock);

	git__free(lock);
	return error;
}

879 880 881 882 883 884 885 886 887 888 889 890
/*
 * Find out what object this reference resolves to.
 *
 * For references that point to a 'big' tag (e.g. an
 * actual tag object on the repository), we need to
 * cache on the packfile the OID of the object to
 * which that 'big tag' is pointing to.
 */
static int packed_find_peel(refdb_fs_backend *backend, struct packref *ref)
{
	git_object *object;

891
	if (ref->flags & PACKREF_HAS_PEEL || ref->flags & PACKREF_CANNOT_PEEL)
892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
		return 0;

	/*
	 * Find the tagged object in the repository
	 */
	if (git_object_lookup(&object, backend->repo, &ref->oid, GIT_OBJ_ANY) < 0)
		return -1;

	/*
	 * If the tagged object is a Tag object, we need to resolve it;
	 * if the ref is actually a 'weak' ref, we don't need to resolve
	 * anything.
	 */
	if (git_object_type(object) == GIT_OBJ_TAG) {
		git_tag *tag = (git_tag *)object;

		/*
		 * Find the object pointed at by this tag
		 */
		git_oid_cpy(&ref->peel, git_tag_target_id(tag));
912
		ref->flags |= PACKREF_HAS_PEEL;
913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930

		/*
		 * The reference has now cached the resolved OID, and is
		 * marked at such. When written to the packfile, it'll be
		 * accompanied by this resolved oid
		 */
	}

	git_object_free(object);
	return 0;
}

/*
 * Write a single reference into a packfile
 */
static int packed_write_ref(struct packref *ref, git_filebuf *file)
{
	char oid[GIT_OID_HEXSZ + 1];
931
	git_oid_nfmt(oid, sizeof(oid), &ref->oid);
932 933 934 935 936 937 938 939 940 941 942

	/*
	 * For references that peel to an object in the repo, we must
	 * write the resulting peel on a separate line, e.g.
	 *
	 *	6fa8a902cc1d18527e1355773c86721945475d37 refs/tags/libgit2-0.4
	 *	^2ec0cb7959b0bf965d54f95453f5b4b34e8d3100
	 *
	 * This obviously only applies to tags.
	 * The required peels have already been loaded into `ref->peel_target`.
	 */
943
	if (ref->flags & PACKREF_HAS_PEEL) {
944
		char peel[GIT_OID_HEXSZ + 1];
945
		git_oid_nfmt(peel, sizeof(peel), &ref->peel);
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967

		if (git_filebuf_printf(file, "%s %s\n^%s\n", oid, ref->name, peel) < 0)
			return -1;
	} else {
		if (git_filebuf_printf(file, "%s %s\n", oid, ref->name) < 0)
			return -1;
	}

	return 0;
}

/*
 * Remove all loose references
 *
 * Once we have successfully written a packfile,
 * all the loose references that were packed must be
 * removed from disk.
 *
 * This is a dangerous method; make sure the packfile
 * is well-written, because we are destructing references
 * here otherwise.
 */
968
static int packed_remove_loose(refdb_fs_backend *backend)
969
{
970
	size_t i;
971
	git_filebuf lock = GIT_FILEBUF_INIT;
972
	git_buf ref_content = GIT_BUF_INIT;
973
	int error = 0;
974

975 976 977 978
	/* backend->refcache is already locked when this is called */

	for (i = 0; i < git_sortedcache_entrycount(backend->refcache); ++i) {
		struct packref *ref = git_sortedcache_entry(backend->refcache, i);
979
		git_oid current_id;
980

981
		if (!ref || !(ref->flags & PACKREF_WAS_LOOSE))
982 983
			continue;

984 985
		git_filebuf_cleanup(&lock);

986 987 988
		/* We need to stop anybody from updating the ref while we try to do a safe delete */
		error = loose_lock(&lock, backend, ref->name);
		/* If someone else is updating it, let them do it */
989
		if (error == GIT_EEXISTS || error == GIT_ENOTFOUND)
990 991 992
			continue;

		if (error < 0) {
993
			git_buf_dispose(&ref_content);
994 995
			giterr_set(GITERR_REFERENCE, "failed to lock loose reference '%s'", ref->name);
			return error;
996 997 998 999
		}

		error = git_futils_readbuffer(&ref_content, lock.path_original);
		/* Someone else beat us to cleaning up the ref, let's simply continue */
1000
		if (error == GIT_ENOTFOUND)
1001 1002 1003
			continue;

		/* This became a symref between us packing and trying to delete it, so ignore it */
1004
		if (!git__prefixcmp(ref_content.ptr, GIT_SYMREF))
1005 1006
			continue;

1007 1008
		/* Figure out the current id; if we find a bad ref file, skip it so we can do the rest */
		if (loose_parse_oid(&current_id, lock.path_original, &ref_content) < 0)
1009
			continue;
1010

1011
		/* If the ref moved since we packed it, we must not delete it */
1012
		if (!git_oid_equal(&current_id, &ref->oid))
1013 1014
			continue;

1015 1016 1017
		/*
		 * if we fail to remove a single file, this is *not* good,
		 * but we should keep going and remove as many as possible.
1018 1019
		 * If we fail to remove, the ref is still in the old state, so
		 * we haven't lost information.
1020
		 */
1021
		p_unlink(lock.path_original);
1022 1023
	}

1024
	git_buf_dispose(&ref_content);
1025
	git_filebuf_cleanup(&lock);
1026
	return 0;
1027 1028 1029 1030 1031 1032 1033
}

/*
 * Write all the contents in the in-memory packfile to disk.
 */
static int packed_write(refdb_fs_backend *backend)
{
1034
	git_sortedcache *refcache = backend->refcache;
1035
	git_filebuf pack_file = GIT_FILEBUF_INIT;
1036
	int error, open_flags = 0;
1037
	size_t i;
1038

1039
	/* lock the cache to updates while we do this */
1040 1041
	if ((error = git_sortedcache_wlock(refcache)) < 0)
		return error;
1042

1043
	if (backend->fsync)
1044 1045
		open_flags = GIT_FILEBUF_FSYNC;

1046
	/* Open the file! */
1047
	if ((error = git_filebuf_open(&pack_file, git_sortedcache_path(refcache), open_flags, GIT_PACKEDREFS_FILE_MODE)) < 0)
1048
		goto fail;
1049 1050 1051 1052

	/* Packfiles have a header... apparently
	 * This is in fact not required, but we might as well print it
	 * just for kicks */
1053
	if ((error = git_filebuf_printf(&pack_file, "%s\n", GIT_PACKEDREFS_HEADER)) < 0)
1054
		goto fail;
1055

1056 1057
	for (i = 0; i < git_sortedcache_entrycount(refcache); ++i) {
		struct packref *ref = git_sortedcache_entry(refcache, i);
1058
		assert(ref);
1059

1060
		if ((error = packed_find_peel(backend, ref)) < 0)
1061
			goto fail;
1062

1063
		if ((error = packed_write_ref(ref, &pack_file)) < 0)
1064
			goto fail;
1065 1066 1067 1068
	}

	/* if we've written all the references properly, we can commit
	 * the packfile to make the changes effective */
1069
	if ((error = git_filebuf_commit(&pack_file)) < 0)
1070
		goto fail;
1071 1072 1073

	/* when and only when the packfile has been properly written,
	 * we can go ahead and remove the loose refs */
1074
	if ((error = packed_remove_loose(backend)) < 0)
1075
		goto fail;
1076

1077 1078
	git_sortedcache_updated(refcache);
	git_sortedcache_wunlock(refcache);
1079 1080 1081 1082

	/* we're good now */
	return 0;

1083
fail:
1084
	git_filebuf_cleanup(&pack_file);
1085
	git_sortedcache_wunlock(refcache);
1086

1087
	return error;
1088 1089
}

1090
static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *author, const char *message);
1091 1092 1093
static int has_reflog(git_repository *repo, const char *name);

/* We only write if it's under heads/, remotes/ or notes/ or if it already has a log */
1094
static int should_write_reflog(int *write, git_repository *repo, const char *name)
1095
{
1096
	int error, logall;
1097

1098 1099
	error = git_repository__cvar(&logall, repo, GIT_CVAR_LOGALLREFUPDATES);
	if (error < 0)
1100 1101
		return error;

1102 1103 1104
	/* Defaults to the opposite of the repo being bare */
	if (logall == GIT_LOGALLREFUPDATES_UNSET)
		logall = !git_repository_is_bare(repo);
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117

	if (!logall) {
		*write = 0;
	} else if (has_reflog(repo, name)) {
		*write = 1;
	} else if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR) ||
		   !git__strcmp(name, GIT_HEAD_FILE) ||
		   !git__prefixcmp(name, GIT_REFS_REMOTES_DIR) ||
		   !git__prefixcmp(name, GIT_REFS_NOTES_DIR)) {
		*write = 1;
	} else {
		*write = 0;
	}
1118 1119 1120

	return 0;
}
1121

1122
static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const char *name,
1123 1124 1125 1126 1127 1128
	const git_oid *old_id, const char *old_target)
{
	int error = 0;
	git_reference *old_ref = NULL;

	*cmp = 0;
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
	/* It "matches" if there is no old value to compare against */
	if (!old_id && !old_target)
		return 0;

	if ((error = refdb_fs_backend__lookup(&old_ref, backend, name)) < 0)
		goto out;

	/* If the types don't match, there's no way the values do */
	if (old_id && old_ref->type != GIT_REF_OID) {
		*cmp = -1;
		goto out;
	}
	if (old_target && old_ref->type != GIT_REF_SYMBOLIC) {
		*cmp = 1;
		goto out;
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	}

	if (old_id && old_ref->type == GIT_REF_OID)
		*cmp = git_oid_cmp(old_id, &old_ref->target.oid);

	if (old_target && old_ref->type == GIT_REF_SYMBOLIC)
		*cmp = git__strcmp(old_target, old_ref->target.symbolic);

out:
	git_reference_free(old_ref);

	return error;
}

1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
/*
 * The git.git comment regarding this, for your viewing pleasure:
 *
 * Special hack: If a branch is updated directly and HEAD
 * points to it (may happen on the remote side of a push
 * for example) then logically the HEAD reflog should be
 * updated too.
 * A generic solution implies reverse symref information,
 * but finding all symrefs pointing to the given branch
 * would be rather costly for this rare event (the direct
 * update of a branch) to be worth it.  So let's cheat and
 * check with HEAD only which should cover 99% of all usage
 * scenarios (even 100% of the default ones).
 */
static int maybe_append_head(refdb_fs_backend *backend, const git_reference *ref, const git_signature *who, const char *message)
{
	int error;
1175
	git_oid old_id;
1176 1177 1178 1179 1180
	git_reference *tmp = NULL, *head = NULL, *peeled = NULL;
	const char *name;

	if (ref->type == GIT_REF_SYMBOLIC)
		return 0;
1181

1182
	/* if we can't resolve, we use {0}*40 as old id */
1183 1184
	if (git_reference_name_to_id(&old_id, backend->repo, ref->name) < 0)
		memset(&old_id, 0, sizeof(old_id));
1185

1186
	if ((error = git_reference_lookup(&head, backend->repo, GIT_HEAD_FILE)) < 0)
1187 1188
		return error;

1189 1190 1191
	if (git_reference_type(head) == GIT_REF_OID)
		goto cleanup;

1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
	if ((error = git_reference_lookup(&tmp, backend->repo, GIT_HEAD_FILE)) < 0)
		goto cleanup;

	/* Go down the symref chain until we find the branch */
	while (git_reference_type(tmp) == GIT_REF_SYMBOLIC) {
		error = git_reference_lookup(&peeled, backend->repo, git_reference_symbolic_target(tmp));
		if (error < 0)
			break;

		git_reference_free(tmp);
		tmp = peeled;
	}

	if (error == GIT_ENOTFOUND) {
		error = 0;
		name = git_reference_symbolic_target(tmp);
	} else if (error < 0) {
		goto cleanup;
	} else {
		name = git_reference_name(tmp);
	}

	if (strcmp(name, ref->name))
1215 1216
		goto cleanup;

1217 1218
	error = reflog_append(backend, head, &old_id, git_reference_target(ref), who, message);

1219
cleanup:
1220
	git_reference_free(tmp);
1221 1222 1223 1224
	git_reference_free(head);
	return error;
}

1225 1226
static int refdb_fs_backend__write(
	git_refdb_backend *_backend,
Vicent Marti committed
1227
	const git_reference *ref,
1228
	int force,
1229
	const git_signature *who,
1230
	const char *message,
1231 1232
	const git_oid *old_id,
	const char *old_target)
1233
{
1234
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1235
	git_filebuf file = GIT_FILEBUF_INIT;
1236
	int error = 0;
1237

1238
	assert(backend);
1239

1240
	if ((error = reference_path_available(backend, ref->name, NULL, force)) < 0)
Vicent Marti committed
1241 1242
		return error;

1243
	/* We need to perform the reflog append and old value check under the ref's lock */
1244
	if ((error = loose_lock(&file, backend, ref->name)) < 0)
1245 1246
		return error;

1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
	return refdb_fs_backend__write_tail(_backend, ref, &file, true, who, message, old_id, old_target);
}

static int refdb_fs_backend__write_tail(
	git_refdb_backend *_backend,
	const git_reference *ref,
	git_filebuf *file,
	int update_reflog,
	const git_signature *who,
	const char *message,
	const git_oid *old_id,
	const char *old_target)
{
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
	int error = 0, cmp = 0, should_write;
	const char *new_target = NULL;
	const git_oid *new_id = NULL;

1265
	if ((error = cmp_old_ref(&cmp, _backend, ref->name, old_id, old_target)) < 0)
1266
		goto on_error;
1267 1268 1269 1270 1271

	if (cmp) {
		giterr_set(GITERR_REFERENCE, "old reference value does not match");
		error = GIT_EMODIFIED;
		goto on_error;
1272 1273
	}

1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
	if (ref->type == GIT_REF_SYMBOLIC)
		new_target = ref->target.symbolic;
	else
		new_id = &ref->target.oid;

	error = cmp_old_ref(&cmp, _backend, ref->name, new_id, new_target);
	if (error < 0 && error != GIT_ENOTFOUND)
		goto on_error;

	/* Don't update if we have the same value */
	if (!error && !cmp) {
		error = 0;
		goto on_error; /* not really error */
	}

1289 1290
	if (update_reflog) {
		if ((error = should_write_reflog(&should_write, backend->repo, ref->name)) < 0)
1291
			goto on_error;
1292 1293 1294 1295 1296 1297 1298

		if (should_write) {
			if ((error = reflog_append(backend, ref, NULL, NULL, who, message)) < 0)
				goto on_error;
			if ((error = maybe_append_head(backend, ref, who, message)) < 0)
				goto on_error;
		}
1299 1300
	}

1301
	return loose_commit(file, ref);
1302 1303

on_error:
1304
        git_filebuf_cleanup(file);
1305
        return error;
1306 1307 1308 1309
}

static int refdb_fs_backend__delete(
	git_refdb_backend *_backend,
1310 1311
	const char *ref_name,
	const git_oid *old_id, const char *old_target)
1312
{
1313
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1314
	git_filebuf file = GIT_FILEBUF_INIT;
1315
	int error = 0;
1316

1317
	assert(backend && ref_name);
1318

1319 1320 1321
	if ((error = loose_lock(&file, backend, ref_name)) < 0)
		return error;

1322 1323 1324 1325 1326
	if ((error = refdb_reflog_fs__delete(_backend, ref_name)) < 0) {
		git_filebuf_cleanup(&file);
		return error;
	}

1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
	return refdb_fs_backend__delete_tail(_backend, &file, ref_name, old_id, old_target);
}

static int refdb_fs_backend__delete_tail(
	git_refdb_backend *_backend,
	git_filebuf *file,
	const char *ref_name,
	const git_oid *old_id, const char *old_target)
{
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
	git_buf loose_path = GIT_BUF_INIT;
	size_t pack_pos;
	int error = 0, cmp = 0;
	bool loose_deleted = 0;

1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
	error = cmp_old_ref(&cmp, _backend, ref_name, old_id, old_target);
	if (error < 0)
		goto cleanup;

	if (cmp) {
		giterr_set(GITERR_REFERENCE, "old reference value does not match");
		error = GIT_EMODIFIED;
		goto cleanup;
	}

1352
	/* If a loose reference exists, remove it from the filesystem */
1353
	if (git_buf_joinpath(&loose_path, backend->commonpath, ref_name) < 0)
1354 1355 1356
		return -1;


1357 1358 1359 1360
	error = p_unlink(loose_path.ptr);
	if (error < 0 && errno == ENOENT)
		error = 0;
	else if (error < 0)
1361
		goto cleanup;
1362 1363
	else if (error == 0)
		loose_deleted = 1;
1364

1365 1366
	if ((error = packed_reload(backend)) < 0)
		goto cleanup;
1367

1368
	/* If a packed reference exists, remove it from the packfile and repack */
1369 1370
	if ((error = git_sortedcache_wlock(backend->refcache)) < 0)
		goto cleanup;
Vicent Marti committed
1371

1372 1373
	if (!(error = git_sortedcache_lookup_index(
			&pack_pos, backend->refcache, ref_name)))
1374
		error = git_sortedcache_remove(backend->refcache, pack_pos);
1375

1376
	git_sortedcache_wunlock(backend->refcache);
1377

1378 1379 1380 1381 1382 1383
	if (error == GIT_ENOTFOUND) {
		error = loose_deleted ? 0 : ref_error_notfound(ref_name);
		goto cleanup;
	}

	error = packed_write(backend);
1384

1385
cleanup:
1386
	git_buf_dispose(&loose_path);
1387
	git_filebuf_cleanup(file);
1388 1389

	return error;
1390 1391
}

1392 1393
static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_name, const char *new_name);

Vicent Marti committed
1394 1395 1396 1397 1398
static int refdb_fs_backend__rename(
	git_reference **out,
	git_refdb_backend *_backend,
	const char *old_name,
	const char *new_name,
1399
	int force,
1400
	const git_signature *who,
1401
	const char *message)
Vicent Marti committed
1402
{
1403
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
Vicent Marti committed
1404
	git_reference *old, *new;
1405
	git_filebuf file = GIT_FILEBUF_INIT;
Vicent Marti committed
1406 1407
	int error;

1408
	assert(backend);
Vicent Marti committed
1409

1410 1411 1412
	if ((error = reference_path_available(
			backend, new_name, old_name, force)) < 0 ||
		(error = refdb_fs_backend__lookup(&old, _backend, old_name)) < 0)
Vicent Marti committed
1413 1414
		return error;

1415
	if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) {
Vicent Marti committed
1416 1417 1418 1419
		git_reference_free(old);
		return error;
	}

1420 1421 1422 1423
	new = git_reference__set_name(old, new_name);
	if (!new) {
		git_reference_free(old);
		return -1;
Vicent Marti committed
1424 1425
	}

1426
	if ((error = loose_lock(&file, backend, new->name)) < 0) {
1427 1428 1429 1430 1431 1432 1433
		git_reference_free(new);
		return error;
	}

	/* Try to rename the refog; it's ok if the old doesn't exist */
	error = refdb_reflog_fs__rename(_backend, old_name, new_name);
	if (((error == 0) || (error == GIT_ENOTFOUND)) &&
1434
	    ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) {
1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447
		git_reference_free(new);
		git_filebuf_cleanup(&file);
		return error;
	}

	if (error < 0) {
		git_reference_free(new);
		git_filebuf_cleanup(&file);
		return error;
	}


	if ((error = loose_commit(&file, new)) < 0 || out == NULL) {
Vicent Marti committed
1448
		git_reference_free(new);
1449
		return error;
Vicent Marti committed
1450 1451
	}

1452
	*out = new;
Vicent Marti committed
1453 1454 1455
	return 0;
}

1456 1457
static int refdb_fs_backend__compress(git_refdb_backend *_backend)
{
1458
	int error;
1459
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1460

1461
	assert(backend);
1462

1463 1464 1465 1466
	if ((error = packed_reload(backend)) < 0 || /* load the existing packfile */
	    (error = packed_loadloose(backend)) < 0 || /* add all the loose refs */
	    (error = packed_write(backend)) < 0) /* write back to disk */
		return error;
1467 1468 1469 1470 1471 1472

	return 0;
}

static void refdb_fs_backend__free(git_refdb_backend *_backend)
{
1473
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1474

1475
	assert(backend);
1476

1477
	git_sortedcache_free(backend->refcache);
1478
	git__free(backend->gitpath);
1479
	git__free(backend->commonpath);
1480 1481 1482
	git__free(backend);
}

1483
static char *setup_namespace(git_repository *repo, const char *in)
1484
{
1485 1486
	git_buf path = GIT_BUF_INIT;
	char *parts, *start, *end, *out = NULL;
1487

1488 1489
	if (!in)
		goto done;
1490

1491
	git_buf_puts(&path, in);
1492 1493

	/* if the repo is not namespaced, nothing else to do */
1494 1495 1496 1497
	if (repo->namespace == NULL) {
		out = git_buf_detach(&path);
		goto done;
	}
1498 1499 1500

	parts = end = git__strdup(repo->namespace);
	if (parts == NULL)
1501
		goto done;
1502

1503
	/*
1504 1505 1506 1507 1508
	 * From `man gitnamespaces`:
	 *  namespaces which include a / will expand to a hierarchy
	 *  of namespaces; for example, GIT_NAMESPACE=foo/bar will store
	 *  refs under refs/namespaces/foo/refs/namespaces/bar/
	 */
1509 1510
	while ((start = git__strsep(&end, "/")) != NULL)
		git_buf_printf(&path, "refs/namespaces/%s/", start);
1511

1512
	git_buf_printf(&path, "refs/namespaces/%s/refs", end);
Vicent Marti committed
1513
	git__free(parts);
1514 1515

	/* Make sure that the folder with the namespace exists */
1516 1517 1518
	if (git_futils_mkdir_relative(git_buf_cstr(&path), in, 0777,
			GIT_MKDIR_PATH, NULL) < 0)
		goto done;
1519

1520
	/* Return root of the namespaced gitpath, i.e. without the trailing '/refs' */
1521 1522 1523 1524
	git_buf_rtruncate_at_char(&path, '/');
	out = git_buf_detach(&path);

done:
1525
	git_buf_dispose(&path);
1526
	return out;
1527 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 1557 1558
static int reflog_alloc(git_reflog **reflog, const char *name)
{
	git_reflog *log;

	*reflog = NULL;

	log = git__calloc(1, sizeof(git_reflog));
	GITERR_CHECK_ALLOC(log);

	log->ref_name = git__strdup(name);
	GITERR_CHECK_ALLOC(log->ref_name);

	if (git_vector_init(&log->entries, 0, NULL) < 0) {
		git__free(log->ref_name);
		git__free(log);
		return -1;
	}

	*reflog = log;

	return 0;
}

static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size)
{
	const char *ptr;
	git_reflog_entry *entry;

#define seek_forward(_increase) do { \
	if (_increase >= buf_size) { \
1559
		giterr_set(GITERR_INVALID, "ran out of data while parsing reflog"); \
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
		goto fail; \
	} \
	buf += _increase; \
	buf_size -= _increase; \
	} while (0)

	while (buf_size > GIT_REFLOG_SIZE_MIN) {
		entry = git__calloc(1, sizeof(git_reflog_entry));
		GITERR_CHECK_ALLOC(entry);

1570
		entry->committer = git__calloc(1, sizeof(git_signature));
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
		GITERR_CHECK_ALLOC(entry->committer);

		if (git_oid_fromstrn(&entry->oid_old, buf, GIT_OID_HEXSZ) < 0)
			goto fail;
		seek_forward(GIT_OID_HEXSZ + 1);

		if (git_oid_fromstrn(&entry->oid_cur, buf, GIT_OID_HEXSZ) < 0)
			goto fail;
		seek_forward(GIT_OID_HEXSZ + 1);

		ptr = buf;

		/* Seek forward to the end of the signature. */
		while (*buf && *buf != '\t' && *buf != '\n')
			seek_forward(1);

		if (git_signature__parse(entry->committer, &ptr, buf + 1, NULL, *buf) < 0)
			goto fail;

		if (*buf == '\t') {
			/* We got a message. Read everything till we reach LF. */
			seek_forward(1);
			ptr = buf;

			while (*buf && *buf != '\n')
				seek_forward(1);

			entry->msg = git__strndup(ptr, buf - ptr);
			GITERR_CHECK_ALLOC(entry->msg);
		} else
			entry->msg = NULL;

		while (*buf && *buf == '\n' && buf_size > 1)
			seek_forward(1);

		if (git_vector_insert(&log->entries, entry) < 0)
			goto fail;
	}

	return 0;

#undef seek_forward

fail:
1615
	git_reflog_entry__free(entry);
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627

	return -1;
}

static int create_new_reflog_file(const char *filepath)
{
	int fd, error;

	if ((error = git_futils_mkpath2file(filepath, GIT_REFLOG_DIR_MODE)) < 0)
		return error;

	if ((fd = p_open(filepath,
1628
			O_WRONLY | O_CREAT,
1629 1630 1631 1632 1633 1634 1635 1636
			GIT_REFLOG_FILE_MODE)) < 0)
		return -1;

	return p_close(fd);
}

GIT_INLINE(int) retrieve_reflog_path(git_buf *path, git_repository *repo, const char *name)
{
1637 1638
	if (strcmp(name, GIT_HEAD_FILE) == 0)
		return git_buf_join3(path, '/', repo->gitdir, GIT_REFLOG_DIR, name);
1639
	return git_buf_join3(path, '/', repo->commondir, GIT_REFLOG_DIR, name);
1640 1641
}

1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
static int refdb_reflog_fs__ensure_log(git_refdb_backend *_backend, const char *name)
{
	refdb_fs_backend *backend;
	git_repository *repo;
	git_buf path = GIT_BUF_INIT;
	int error;

	assert(_backend && name);

	backend = (refdb_fs_backend *) _backend;
	repo = backend->repo;

	if ((error = retrieve_reflog_path(&path, repo, name)) < 0)
		return error;

1657
	error = create_new_reflog_file(git_buf_cstr(&path));
1658
	git_buf_dispose(&path);
1659 1660

	return error;
1661 1662
}

1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
static int has_reflog(git_repository *repo, const char *name)
{
	int ret = 0;
	git_buf path = GIT_BUF_INIT;

	if (retrieve_reflog_path(&path, repo, name) < 0)
		goto cleanup;

	ret = git_path_isfile(git_buf_cstr(&path));

cleanup:
1674
	git_buf_dispose(&path);
1675 1676 1677
	return ret;
}

1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688
static int refdb_reflog_fs__has_log(git_refdb_backend *_backend, const char *name)
{
	refdb_fs_backend *backend;

	assert(_backend && name);

	backend = (refdb_fs_backend *) _backend;

	return has_reflog(backend->repo, name);
}

1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727
static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, const char *name)
{
	int error = -1;
	git_buf log_path = GIT_BUF_INIT;
	git_buf log_file = GIT_BUF_INIT;
	git_reflog *log = NULL;
	git_repository *repo;
	refdb_fs_backend *backend;

	assert(out && _backend && name);

	backend = (refdb_fs_backend *) _backend;
	repo = backend->repo;

	if (reflog_alloc(&log, name) < 0)
		return -1;

	if (retrieve_reflog_path(&log_path, repo, name) < 0)
		goto cleanup;

	error = git_futils_readbuffer(&log_file, git_buf_cstr(&log_path));
	if (error < 0 && error != GIT_ENOTFOUND)
		goto cleanup;

	if ((error == GIT_ENOTFOUND) &&
		((error = create_new_reflog_file(git_buf_cstr(&log_path))) < 0))
		goto cleanup;
 
	if ((error = reflog_parse(log,
		git_buf_cstr(&log_file), git_buf_len(&log_file))) < 0)
		goto cleanup;

	*out = log;
	goto success;

cleanup:
	git_reflog_free(log);

success:
1728 1729
	git_buf_dispose(&log_file);
	git_buf_dispose(&log_path);
1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767

	return error;
}

static int serialize_reflog_entry(
	git_buf *buf,
	const git_oid *oid_old,
	const git_oid *oid_new,
	const git_signature *committer,
	const char *msg)
{
	char raw_old[GIT_OID_HEXSZ+1];
	char raw_new[GIT_OID_HEXSZ+1];

	git_oid_tostr(raw_old, GIT_OID_HEXSZ+1, oid_old);
	git_oid_tostr(raw_new, GIT_OID_HEXSZ+1, oid_new);

	git_buf_clear(buf);

	git_buf_puts(buf, raw_old);
	git_buf_putc(buf, ' ');
	git_buf_puts(buf, raw_new);

	git_signature__writebuf(buf, " ", committer);

	/* drop trailing LF */
	git_buf_rtrim(buf);

	if (msg) {
		git_buf_putc(buf, '\t');
		git_buf_puts(buf, msg);
	}

	git_buf_putc(buf, '\n');

	return git_buf_oom(buf);
}

1768 1769 1770 1771 1772 1773 1774 1775
static int lock_reflog(git_filebuf *file, refdb_fs_backend *backend, const char *refname)
{
	git_repository *repo;
	git_buf log_path = GIT_BUF_INIT;
	int error;

	repo = backend->repo;

1776
	if (!git_path_isvalid(backend->repo, refname, 0, GIT_PATH_REJECT_FILESYSTEM_DEFAULTS)) {
1777
		giterr_set(GITERR_INVALID, "invalid reference name '%s'", refname);
1778 1779 1780
		return GIT_EINVALIDSPEC;
	}

1781 1782 1783 1784 1785
	if (retrieve_reflog_path(&log_path, repo, refname) < 0)
		return -1;

	if (!git_path_isfile(git_buf_cstr(&log_path))) {
		giterr_set(GITERR_INVALID,
1786
			"log file for reference '%s' doesn't exist", refname);
1787 1788 1789 1790 1791 1792 1793
		error = -1;
		goto cleanup;
	}

	error = git_filebuf_open(file, git_buf_cstr(&log_path), 0, GIT_REFLOG_FILE_MODE);

cleanup:
1794
	git_buf_dispose(&log_path);
1795 1796 1797 1798

	return error;
}

1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811
static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflog)
{
	int error = -1;
	unsigned int i;
	git_reflog_entry *entry;
	refdb_fs_backend *backend;
	git_buf log = GIT_BUF_INIT;
	git_filebuf fbuf = GIT_FILEBUF_INIT;

	assert(_backend && reflog);

	backend = (refdb_fs_backend *) _backend;

1812
	if ((error = lock_reflog(&fbuf, backend, reflog->ref_name)) < 0)
1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
		return -1;

	git_vector_foreach(&reflog->entries, i, entry) {
		if (serialize_reflog_entry(&log, &(entry->oid_old), &(entry->oid_cur), entry->committer, entry->msg) < 0)
			goto cleanup;

		if ((error = git_filebuf_write(&fbuf, log.ptr, log.size)) < 0)
			goto cleanup;
	}

1823
	error = git_filebuf_commit(&fbuf);
1824 1825 1826 1827 1828 1829
	goto success;

cleanup:
	git_filebuf_cleanup(&fbuf);

success:
1830
	git_buf_dispose(&log);
1831

1832 1833 1834
	return error;
}

1835
/* Append to the reflog, must be called under reference lock */
1836
static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *who, const char *message)
1837
{
1838
	int error, is_symbolic, open_flags;
1839
	git_oid old_id = {{0}}, new_id = {{0}};
1840 1841 1842
	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
	git_repository *repo = backend->repo;

1843 1844 1845 1846 1847 1848
	is_symbolic = ref->type == GIT_REF_SYMBOLIC;

	/* "normal" symbolic updates do not write */
	if (is_symbolic &&
	    strcmp(ref->name, GIT_HEAD_FILE) &&
	    !(old && new))
1849 1850
		return 0;

1851 1852 1853 1854
	/* From here on is_symoblic also means that it's HEAD */

	if (old) {
		git_oid_cpy(&old_id, old);
1855
	} else {
1856
		error = git_reference_name_to_id(&old_id, repo, ref->name);
1857
		if (error < 0 && error != GIT_ENOTFOUND)
1858 1859 1860
			return error;
	}

1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
	if (new) {
		git_oid_cpy(&new_id, new);
	} else {
		if (!is_symbolic) {
			git_oid_cpy(&new_id, git_reference_target(ref));
		} else {
			error = git_reference_name_to_id(&new_id, repo, git_reference_symbolic_target(ref));
			if (error < 0 && error != GIT_ENOTFOUND)
				return error;
			/* detaching HEAD does not create an entry */
			if (error == GIT_ENOTFOUND)
				return 0;
1873

1874 1875
			giterr_clear();
		}
1876
	}
1877

1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888
	if ((error = serialize_reflog_entry(&buf, &old_id, &new_id, who, message)) < 0)
		goto cleanup;

	if ((error = retrieve_reflog_path(&path, repo, ref->name)) < 0)
		goto cleanup;

	if (((error = git_futils_mkpath2file(git_buf_cstr(&path), 0777)) < 0) &&
	    (error != GIT_EEXISTS)) {
		goto cleanup;
	}

1889 1890 1891
	/* If the new branch matches part of the namespace of a previously deleted branch,
	 * there maybe an obsolete/unused directory (or directory hierarchy) in the way.
	 */
1892
	if (git_path_isdir(git_buf_cstr(&path))) {
1893 1894 1895 1896
		if ((error = git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_SKIP_NONEMPTY)) < 0) {
			if (error == GIT_ENOTFOUND)
				error = 0;
		} else if (git_path_isdir(git_buf_cstr(&path))) {
1897 1898 1899 1900 1901 1902 1903
			giterr_set(GITERR_REFERENCE, "cannot create reflog at '%s', there are reflogs beneath that folder",
				ref->name);
			error = GIT_EDIRECTORY;
		}

		if (error != 0)
			goto cleanup;
1904 1905
	}

1906 1907
	open_flags = O_WRONLY | O_CREAT | O_APPEND;

1908
	if (backend->fsync)
1909 1910 1911
		open_flags |= O_FSYNC;

	error = git_futils_writebuffer(&buf, git_buf_cstr(&path), open_flags, GIT_REFLOG_FILE_MODE);
1912 1913

cleanup:
1914 1915
	git_buf_dispose(&buf);
	git_buf_dispose(&path);
1916

1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938
	return error;
}

static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_name, const char *new_name)
{
	int error = 0, fd;
	git_buf old_path = GIT_BUF_INIT;
	git_buf new_path = GIT_BUF_INIT;
	git_buf temp_path = GIT_BUF_INIT;
	git_buf normalized = GIT_BUF_INIT;
	git_repository *repo;
	refdb_fs_backend *backend;

	assert(_backend && old_name && new_name);

	backend = (refdb_fs_backend *) _backend;
	repo = backend->repo;

	if ((error = git_reference__normalize_name(
		&normalized, new_name, GIT_REF_FORMAT_ALLOW_ONELEVEL)) < 0)
			return error;

1939
	if (git_buf_joinpath(&temp_path, repo->gitdir, GIT_REFLOG_DIR) < 0)
1940 1941 1942 1943 1944 1945 1946 1947
		return -1;

	if (git_buf_joinpath(&old_path, git_buf_cstr(&temp_path), old_name) < 0)
		return -1;

	if (git_buf_joinpath(&new_path, git_buf_cstr(&temp_path), git_buf_cstr(&normalized)) < 0)
		return -1;

1948 1949 1950 1951 1952
	if (!git_path_exists(git_buf_cstr(&old_path))) {
		error = GIT_ENOTFOUND;
		goto cleanup;
	}

1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
	/*
	 * Move the reflog to a temporary place. This two-phase renaming is required
	 * in order to cope with funny renaming use cases when one tries to move a reference
	 * to a partially colliding namespace:
	 *  - a/b -> a/b/c
	 *  - a/b/c/d -> a/b/c
	 */
	if (git_buf_joinpath(&temp_path, git_buf_cstr(&temp_path), "temp_reflog") < 0)
		return -1;

1963
	if ((fd = git_futils_mktmp(&temp_path, git_buf_cstr(&temp_path), GIT_REFLOG_FILE_MODE)) < 0) {
1964 1965 1966 1967 1968 1969 1970
		error = -1;
		goto cleanup;
	}

	p_close(fd);

	if (p_rename(git_buf_cstr(&old_path), git_buf_cstr(&temp_path)) < 0) {
1971
		giterr_set(GITERR_OS, "failed to rename reflog for %s", new_name);
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
		error = -1;
		goto cleanup;
	}

	if (git_path_isdir(git_buf_cstr(&new_path)) && 
		(git_futils_rmdir_r(git_buf_cstr(&new_path), NULL, GIT_RMDIR_SKIP_NONEMPTY) < 0)) {
		error = -1;
		goto cleanup;
	}

	if (git_futils_mkpath2file(git_buf_cstr(&new_path), GIT_REFLOG_DIR_MODE) < 0) {
		error = -1;
		goto cleanup;
	}

	if (p_rename(git_buf_cstr(&temp_path), git_buf_cstr(&new_path)) < 0) {
1988
		giterr_set(GITERR_OS, "failed to rename reflog for %s", new_name);
1989 1990 1991 1992
		error = -1;
	}

cleanup:
1993 1994 1995 1996
	git_buf_dispose(&temp_path);
	git_buf_dispose(&old_path);
	git_buf_dispose(&new_path);
	git_buf_dispose(&normalized);
1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018

	return error;
}

static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name)
{
	int error;
	git_buf path = GIT_BUF_INIT;

	git_repository *repo;
	refdb_fs_backend *backend;

	assert(_backend && name);

	backend = (refdb_fs_backend *) _backend;
	repo = backend->repo;

	error = retrieve_reflog_path(&path, repo, name);

	if (!error && git_path_exists(path.ptr))
		error = p_unlink(path.ptr);

2019
	git_buf_dispose(&path);
2020 2021 2022 2023 2024

	return error;

}

2025 2026
int git_refdb_backend_fs(
	git_refdb_backend **backend_out,
2027
	git_repository *repository)
2028
{
2029
	int t = 0;
2030
	git_buf gitpath = GIT_BUF_INIT;
2031 2032 2033 2034 2035 2036
	refdb_fs_backend *backend;

	backend = git__calloc(1, sizeof(refdb_fs_backend));
	GITERR_CHECK_ALLOC(backend);

	backend->repo = repository;
Vicent Marti committed
2037

2038 2039
	if (repository->gitdir) {
		backend->gitpath = setup_namespace(repository, repository->gitdir);
Vicent Marti committed
2040

2041 2042 2043 2044 2045 2046 2047 2048 2049 2050
		if (backend->gitpath == NULL)
			goto fail;
	}

	if (repository->commondir) {
		backend->commonpath = setup_namespace(repository, repository->commondir);

		if (backend->commonpath == NULL)
			goto fail;
	}
2051

2052
	if (git_buf_joinpath(&gitpath, backend->commonpath, GIT_PACKEDREFS_FILE) < 0 ||
2053 2054
		git_sortedcache_new(
			&backend->refcache, offsetof(struct packref, name),
2055
			NULL, NULL, packref_cmp, git_buf_cstr(&gitpath)) < 0)
2056 2057
		goto fail;

2058
	git_buf_dispose(&gitpath);
2059

2060 2061 2062 2063 2064 2065 2066 2067
	if (!git_repository__cvar(&t, backend->repo, GIT_CVAR_IGNORECASE) && t) {
		backend->iterator_flags |= GIT_ITERATOR_IGNORE_CASE;
		backend->direach_flags  |= GIT_PATH_DIR_IGNORE_CASE;
	}
	if (!git_repository__cvar(&t, backend->repo, GIT_CVAR_PRECOMPOSE) && t) {
		backend->iterator_flags |= GIT_ITERATOR_PRECOMPOSE_UNICODE;
		backend->direach_flags  |= GIT_PATH_DIR_PRECOMPOSE_UNICODE;
	}
2068
	if ((!git_repository__cvar(&t, backend->repo, GIT_CVAR_FSYNCOBJECTFILES) && t) ||
2069
		git_repository__fsync_gitdir)
2070
		backend->fsync = 1;
2071
	backend->iterator_flags |= GIT_ITERATOR_DESCEND_SYMLINKS;
2072

2073 2074
	backend->parent.exists = &refdb_fs_backend__exists;
	backend->parent.lookup = &refdb_fs_backend__lookup;
2075
	backend->parent.iterator = &refdb_fs_backend__iterator;
2076
	backend->parent.write = &refdb_fs_backend__write;
2077
	backend->parent.del = &refdb_fs_backend__delete;
Vicent Marti committed
2078
	backend->parent.rename = &refdb_fs_backend__rename;
2079
	backend->parent.compress = &refdb_fs_backend__compress;
2080 2081
	backend->parent.lock = &refdb_fs_backend__lock;
	backend->parent.unlock = &refdb_fs_backend__unlock;
2082
	backend->parent.has_log = &refdb_reflog_fs__has_log;
2083
	backend->parent.ensure_log = &refdb_reflog_fs__ensure_log;
2084
	backend->parent.free = &refdb_fs_backend__free;
2085 2086 2087 2088
	backend->parent.reflog_read = &refdb_reflog_fs__read;
	backend->parent.reflog_write = &refdb_reflog_fs__write;
	backend->parent.reflog_rename = &refdb_reflog_fs__rename;
	backend->parent.reflog_delete = &refdb_reflog_fs__delete;
2089 2090 2091

	*backend_out = (git_refdb_backend *)backend;
	return 0;
2092 2093

fail:
2094
	git_buf_dispose(&gitpath);
2095
	git__free(backend->gitpath);
2096
	git__free(backend->commonpath);
2097 2098
	git__free(backend);
	return -1;
2099
}