refdb_fs.c 52.7 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
	if (error <= 0) {
		if (error == GIT_ENOTFOUND) {
			git_sortedcache_clear(backend->refcache, true);
97
			git_error_clear();
98 99 100
			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
	git_error_set(GIT_ERROR_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
	git_error_set(GIT_ERROR_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
		git_error_clear();
246 247
		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
		/* Race with the filesystem, ignore it */
		if (error == GIT_ENOTFOUND) {
286
			git_error_clear();
287 288 289 290 291
			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
		git_error_set(GIT_ERROR_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
	git_error_set(GIT_ERROR_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
		git_error_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

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

599
		git_error_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
		git_error_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

	iter = git__calloc(1, sizeof(refdb_fs_iter));
682
	GIT_ERROR_CHECK_ALLOC(iter);
683

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

		if (exists) {
746
			git_error_set(GIT_ERROR_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);
760
			git_error_set(GIT_ERROR_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
		git_error_set(GIT_ERROR_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
	if (error == GIT_EDIRECTORY)
804
		git_error_set(GIT_ERROR_REFERENCE, "cannot lock ref '%s', there are refs beneath that folder", name);
805

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
	if (ref->type == GIT_REFERENCE_DIRECT) {
815
		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_REFERENCE_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
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));
835
	GIT_ERROR_CHECK_ALLOC(lock);
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

	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
		return 0;

	/*
	 * Find the tagged object in the repository
	 */
897
	if (git_object_lookup(&object, backend->repo, &ref->oid, GIT_OBJECT_ANY) < 0)
898 899 900 901 902 903 904
		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.
	 */
905
	if (git_object_type(object) == GIT_OBJECT_TAG) {
906 907 908 909 910 911
		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
			git_error_set(GIT_ERROR_REFERENCE, "failed to lock loose reference '%s'", ref->name);
995
			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
static int has_reflog(git_repository *repo, const char *name);

1093
static int should_write_reflog(int *write, git_repository *repo, const char *name)
1094
{
1095
	int error, logall;
1096

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

1101 1102 1103
	/* Defaults to the opposite of the repo being bare */
	if (logall == GIT_LOGALLREFUPDATES_UNSET)
		logall = !git_repository_is_bare(repo);
1104

1105 1106 1107
	*write = 0;
	switch (logall) {
	case GIT_LOGALLREFUPDATES_FALSE:
1108
		*write = 0;
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
		break;

	case GIT_LOGALLREFUPDATES_TRUE:
		/* Only write if it already has a log,
		 * or if it's under heads/, remotes/ or notes/
		 */
		*write = has_reflog(repo, name) ||
			!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);
		break;

	case GIT_LOGALLREFUPDATES_ALWAYS:
1123
		*write = 1;
1124
		break;
1125
	}
1126 1127 1128

	return 0;
}
1129

1130
static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const char *name,
1131 1132 1133 1134 1135 1136
	const git_oid *old_id, const char *old_target)
{
	int error = 0;
	git_reference *old_ref = NULL;

	*cmp = 0;
1137 1138 1139 1140 1141 1142 1143 1144
	/* 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 */
1145
	if (old_id && old_ref->type != GIT_REFERENCE_DIRECT) {
1146 1147 1148
		*cmp = -1;
		goto out;
	}
1149
	if (old_target && old_ref->type != GIT_REFERENCE_SYMBOLIC) {
1150 1151
		*cmp = 1;
		goto out;
1152 1153
	}

1154
	if (old_id && old_ref->type == GIT_REFERENCE_DIRECT)
1155 1156
		*cmp = git_oid_cmp(old_id, &old_ref->target.oid);

1157
	if (old_target && old_ref->type == GIT_REFERENCE_SYMBOLIC)
1158 1159 1160 1161 1162 1163 1164 1165
		*cmp = git__strcmp(old_target, old_ref->target.symbolic);

out:
	git_reference_free(old_ref);

	return error;
}

1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182
/*
 * 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;
1183
	git_oid old_id;
1184 1185 1186
	git_reference *tmp = NULL, *head = NULL, *peeled = NULL;
	const char *name;

1187
	if (ref->type == GIT_REFERENCE_SYMBOLIC)
1188
		return 0;
1189

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

1194
	if ((error = git_reference_lookup(&head, backend->repo, GIT_HEAD_FILE)) < 0)
1195 1196
		return error;

1197
	if (git_reference_type(head) == GIT_REFERENCE_DIRECT)
1198 1199
		goto cleanup;

1200 1201 1202 1203
	if ((error = git_reference_lookup(&tmp, backend->repo, GIT_HEAD_FILE)) < 0)
		goto cleanup;

	/* Go down the symref chain until we find the branch */
1204
	while (git_reference_type(tmp) == GIT_REFERENCE_SYMBOLIC) {
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
		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))
1223 1224
		goto cleanup;

1225 1226
	error = reflog_append(backend, head, &old_id, git_reference_target(ref), who, message);

1227
cleanup:
1228
	git_reference_free(tmp);
1229 1230 1231 1232
	git_reference_free(head);
	return error;
}

1233 1234
static int refdb_fs_backend__write(
	git_refdb_backend *_backend,
Vicent Marti committed
1235
	const git_reference *ref,
1236
	int force,
1237
	const git_signature *who,
1238
	const char *message,
1239 1240
	const git_oid *old_id,
	const char *old_target)
1241
{
1242
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1243
	git_filebuf file = GIT_FILEBUF_INIT;
1244
	int error = 0;
1245

1246
	assert(backend);
1247

1248
	if ((error = reference_path_available(backend, ref->name, NULL, force)) < 0)
Vicent Marti committed
1249 1250
		return error;

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

1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
	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;

1273
	if ((error = cmp_old_ref(&cmp, _backend, ref->name, old_id, old_target)) < 0)
1274
		goto on_error;
1275 1276

	if (cmp) {
1277
		git_error_set(GIT_ERROR_REFERENCE, "old reference value does not match");
1278 1279
		error = GIT_EMODIFIED;
		goto on_error;
1280 1281
	}

1282
	if (ref->type == GIT_REFERENCE_SYMBOLIC)
1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
		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 */
	}

1297 1298
	if (update_reflog) {
		if ((error = should_write_reflog(&should_write, backend->repo, ref->name)) < 0)
1299
			goto on_error;
1300 1301 1302 1303 1304 1305 1306

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

1309
	return loose_commit(file, ref);
1310 1311

on_error:
1312
        git_filebuf_cleanup(file);
1313
        return error;
1314 1315
}

1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352
static void refdb_fs_backend__try_delete_empty_ref_hierarchie(
	refdb_fs_backend *backend,
	const char *ref_name,
	bool reflog)
{
	git_buf relative_path = GIT_BUF_INIT;
	git_buf base_path = GIT_BUF_INIT;
	size_t commonlen;

	assert(backend && ref_name);

	if (git_buf_sets(&relative_path, ref_name) < 0)
		goto cleanup;

	git_path_squash_slashes(&relative_path);
	if ((commonlen = git_path_common_dirlen("refs/heads/", git_buf_cstr(&relative_path))) == strlen("refs/heads/") ||
		(commonlen = git_path_common_dirlen("refs/tags/", git_buf_cstr(&relative_path))) == strlen("refs/tags/") ||
		(commonlen = git_path_common_dirlen("refs/remotes/", git_buf_cstr(&relative_path))) == strlen("refs/remotes/")) {

		git_buf_truncate(&relative_path, commonlen);

		if (reflog) {
			if (git_buf_join3(&base_path, '/', backend->commonpath, GIT_REFLOG_DIR, git_buf_cstr(&relative_path)) < 0)
				goto cleanup;
		} else {
			if (git_buf_joinpath(&base_path, backend->commonpath, git_buf_cstr(&relative_path)) < 0)
				goto cleanup;
		}

		git_futils_rmdir_r(ref_name + commonlen, git_buf_cstr(&base_path), GIT_RMDIR_EMPTY_PARENTS | GIT_RMDIR_SKIP_ROOT);
	}

cleanup:
	git_buf_dispose(&relative_path);
	git_buf_dispose(&base_path);
}

1353 1354
static int refdb_fs_backend__delete(
	git_refdb_backend *_backend,
1355 1356
	const char *ref_name,
	const git_oid *old_id, const char *old_target)
1357
{
1358
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1359
	git_filebuf file = GIT_FILEBUF_INIT;
1360
	int error = 0;
1361

1362
	assert(backend && ref_name);
1363

1364 1365 1366
	if ((error = loose_lock(&file, backend, ref_name)) < 0)
		return error;

1367 1368 1369 1370 1371
	if ((error = refdb_reflog_fs__delete(_backend, ref_name)) < 0) {
		git_filebuf_cleanup(&file);
		return error;
	}

1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
	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;

1387 1388 1389 1390 1391
	error = cmp_old_ref(&cmp, _backend, ref_name, old_id, old_target);
	if (error < 0)
		goto cleanup;

	if (cmp) {
1392
		git_error_set(GIT_ERROR_REFERENCE, "old reference value does not match");
1393 1394 1395 1396
		error = GIT_EMODIFIED;
		goto cleanup;
	}

1397
	/* If a loose reference exists, remove it from the filesystem */
1398
	if (git_buf_joinpath(&loose_path, backend->commonpath, ref_name) < 0)
1399 1400 1401
		return -1;


1402 1403 1404 1405
	error = p_unlink(loose_path.ptr);
	if (error < 0 && errno == ENOENT)
		error = 0;
	else if (error < 0)
1406
		goto cleanup;
1407 1408
	else if (error == 0)
		loose_deleted = 1;
1409

1410 1411
	if ((error = packed_reload(backend)) < 0)
		goto cleanup;
1412

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

1417 1418
	if (!(error = git_sortedcache_lookup_index(
			&pack_pos, backend->refcache, ref_name)))
1419
		error = git_sortedcache_remove(backend->refcache, pack_pos);
1420

1421
	git_sortedcache_wunlock(backend->refcache);
1422

1423 1424 1425 1426 1427 1428
	if (error == GIT_ENOTFOUND) {
		error = loose_deleted ? 0 : ref_error_notfound(ref_name);
		goto cleanup;
	}

	error = packed_write(backend);
1429

1430
cleanup:
1431
	git_buf_dispose(&loose_path);
1432
	git_filebuf_cleanup(file);
1433 1434
	if (loose_deleted)
		refdb_fs_backend__try_delete_empty_ref_hierarchie(backend, ref_name, false);
1435
	return error;
1436 1437
}

1438 1439
static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_name, const char *new_name);

Vicent Marti committed
1440 1441 1442 1443 1444
static int refdb_fs_backend__rename(
	git_reference **out,
	git_refdb_backend *_backend,
	const char *old_name,
	const char *new_name,
1445
	int force,
1446
	const git_signature *who,
1447
	const char *message)
Vicent Marti committed
1448
{
1449
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
Vicent Marti committed
1450
	git_reference *old, *new;
1451
	git_filebuf file = GIT_FILEBUF_INIT;
Vicent Marti committed
1452 1453
	int error;

1454
	assert(backend);
Vicent Marti committed
1455

1456 1457 1458
	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
1459 1460
		return error;

1461
	if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) {
Vicent Marti committed
1462 1463 1464 1465
		git_reference_free(old);
		return error;
	}

1466 1467 1468 1469
	new = git_reference__set_name(old, new_name);
	if (!new) {
		git_reference_free(old);
		return -1;
Vicent Marti committed
1470 1471
	}

1472
	if ((error = loose_lock(&file, backend, new->name)) < 0) {
1473 1474 1475 1476 1477 1478 1479
		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)) &&
1480
	    ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) {
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
		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
1494
		git_reference_free(new);
1495
		return error;
Vicent Marti committed
1496 1497
	}

1498
	*out = new;
Vicent Marti committed
1499 1500 1501
	return 0;
}

1502 1503
static int refdb_fs_backend__compress(git_refdb_backend *_backend)
{
1504
	int error;
1505
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1506

1507
	assert(backend);
1508

1509 1510 1511 1512
	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;
1513 1514 1515 1516 1517 1518

	return 0;
}

static void refdb_fs_backend__free(git_refdb_backend *_backend)
{
1519
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1520

1521
	assert(backend);
1522

1523
	git_sortedcache_free(backend->refcache);
1524
	git__free(backend->gitpath);
1525
	git__free(backend->commonpath);
1526 1527 1528
	git__free(backend);
}

1529
static char *setup_namespace(git_repository *repo, const char *in)
1530
{
1531 1532
	git_buf path = GIT_BUF_INIT;
	char *parts, *start, *end, *out = NULL;
1533

1534 1535
	if (!in)
		goto done;
1536

1537
	git_buf_puts(&path, in);
1538 1539

	/* if the repo is not namespaced, nothing else to do */
1540 1541 1542 1543
	if (repo->namespace == NULL) {
		out = git_buf_detach(&path);
		goto done;
	}
1544 1545 1546

	parts = end = git__strdup(repo->namespace);
	if (parts == NULL)
1547
		goto done;
1548

1549
	/*
1550 1551 1552 1553 1554
	 * 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/
	 */
1555 1556
	while ((start = git__strsep(&end, "/")) != NULL)
		git_buf_printf(&path, "refs/namespaces/%s/", start);
1557

1558
	git_buf_printf(&path, "refs/namespaces/%s/refs", end);
Vicent Marti committed
1559
	git__free(parts);
1560 1561

	/* Make sure that the folder with the namespace exists */
1562 1563 1564
	if (git_futils_mkdir_relative(git_buf_cstr(&path), in, 0777,
			GIT_MKDIR_PATH, NULL) < 0)
		goto done;
1565

1566
	/* Return root of the namespaced gitpath, i.e. without the trailing '/refs' */
1567 1568 1569 1570
	git_buf_rtruncate_at_char(&path, '/');
	out = git_buf_detach(&path);

done:
1571
	git_buf_dispose(&path);
1572
	return out;
1573 1574
}

1575 1576 1577 1578 1579 1580 1581
static int reflog_alloc(git_reflog **reflog, const char *name)
{
	git_reflog *log;

	*reflog = NULL;

	log = git__calloc(1, sizeof(git_reflog));
1582
	GIT_ERROR_CHECK_ALLOC(log);
1583 1584

	log->ref_name = git__strdup(name);
1585
	GIT_ERROR_CHECK_ALLOC(log->ref_name);
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604

	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) { \
1605
		git_error_set(GIT_ERROR_INVALID, "ran out of data while parsing reflog"); \
1606 1607 1608 1609 1610 1611 1612 1613
		goto fail; \
	} \
	buf += _increase; \
	buf_size -= _increase; \
	} while (0)

	while (buf_size > GIT_REFLOG_SIZE_MIN) {
		entry = git__calloc(1, sizeof(git_reflog_entry));
1614
		GIT_ERROR_CHECK_ALLOC(entry);
1615

1616
		entry->committer = git__calloc(1, sizeof(git_signature));
1617
		GIT_ERROR_CHECK_ALLOC(entry->committer);
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644

		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);
1645
			GIT_ERROR_CHECK_ALLOC(entry->msg);
1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
		} 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:
1661
	git_reflog_entry__free(entry);
1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673

	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,
1674
			O_WRONLY | O_CREAT,
1675 1676 1677 1678 1679 1680 1681 1682
			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)
{
1683 1684
	if (strcmp(name, GIT_HEAD_FILE) == 0)
		return git_buf_join3(path, '/', repo->gitdir, GIT_REFLOG_DIR, name);
1685
	return git_buf_join3(path, '/', repo->commondir, GIT_REFLOG_DIR, name);
1686 1687
}

1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702
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;

1703
	error = create_new_reflog_file(git_buf_cstr(&path));
1704
	git_buf_dispose(&path);
1705 1706

	return error;
1707 1708
}

1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
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:
1720
	git_buf_dispose(&path);
1721 1722 1723
	return ret;
}

1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
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);
}

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

1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773
	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:
1774 1775
	git_buf_dispose(&log_file);
	git_buf_dispose(&log_path);
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813

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

1814 1815 1816 1817 1818 1819 1820 1821
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;

1822
	if (!git_path_isvalid(backend->repo, refname, 0, GIT_PATH_REJECT_FILESYSTEM_DEFAULTS)) {
1823
		git_error_set(GIT_ERROR_INVALID, "invalid reference name '%s'", refname);
1824 1825 1826
		return GIT_EINVALIDSPEC;
	}

1827 1828 1829 1830
	if (retrieve_reflog_path(&log_path, repo, refname) < 0)
		return -1;

	if (!git_path_isfile(git_buf_cstr(&log_path))) {
1831
		git_error_set(GIT_ERROR_INVALID,
1832
			"log file for reference '%s' doesn't exist", refname);
1833 1834 1835 1836 1837 1838 1839
		error = -1;
		goto cleanup;
	}

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

cleanup:
1840
	git_buf_dispose(&log_path);
1841 1842 1843 1844

	return error;
}

1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857
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;

1858
	if ((error = lock_reflog(&fbuf, backend, reflog->ref_name)) < 0)
1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
		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;
	}

1869
	error = git_filebuf_commit(&fbuf);
1870 1871 1872 1873 1874 1875
	goto success;

cleanup:
	git_filebuf_cleanup(&fbuf);

success:
1876
	git_buf_dispose(&log);
1877

1878 1879 1880
	return error;
}

1881
/* Append to the reflog, must be called under reference lock */
1882
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)
1883
{
1884
	int error, is_symbolic, open_flags;
1885
	git_oid old_id = {{0}}, new_id = {{0}};
1886 1887 1888
	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
	git_repository *repo = backend->repo;

1889
	is_symbolic = ref->type == GIT_REFERENCE_SYMBOLIC;
1890 1891 1892 1893 1894

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

1897 1898 1899 1900
	/* From here on is_symoblic also means that it's HEAD */

	if (old) {
		git_oid_cpy(&old_id, old);
1901
	} else {
1902
		error = git_reference_name_to_id(&old_id, repo, ref->name);
1903
		if (error < 0 && error != GIT_ENOTFOUND)
1904 1905 1906
			return error;
	}

1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
	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;
1919

1920
			git_error_clear();
1921
		}
1922
	}
1923

1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
	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;
	}

1935 1936 1937
	/* 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.
	 */
1938
	if (git_path_isdir(git_buf_cstr(&path))) {
1939 1940 1941 1942
		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))) {
1943
			git_error_set(GIT_ERROR_REFERENCE, "cannot create reflog at '%s', there are reflogs beneath that folder",
1944 1945 1946 1947 1948 1949
				ref->name);
			error = GIT_EDIRECTORY;
		}

		if (error != 0)
			goto cleanup;
1950 1951
	}

1952 1953
	open_flags = O_WRONLY | O_CREAT | O_APPEND;

1954
	if (backend->fsync)
1955 1956 1957
		open_flags |= O_FSYNC;

	error = git_futils_writebuffer(&buf, git_buf_cstr(&path), open_flags, GIT_REFLOG_FILE_MODE);
1958 1959

cleanup:
1960 1961
	git_buf_dispose(&buf);
	git_buf_dispose(&path);
1962

1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981
	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(
1982
		&normalized, new_name, GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL)) < 0)
1983 1984
			return error;

1985
	if (git_buf_joinpath(&temp_path, repo->gitdir, GIT_REFLOG_DIR) < 0)
1986 1987 1988 1989 1990 1991 1992 1993
		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;

1994 1995 1996 1997 1998
	if (!git_path_exists(git_buf_cstr(&old_path))) {
		error = GIT_ENOTFOUND;
		goto cleanup;
	}

1999 2000 2001 2002 2003 2004 2005 2006 2007 2008
	/*
	 * 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;

2009
	if ((fd = git_futils_mktmp(&temp_path, git_buf_cstr(&temp_path), GIT_REFLOG_FILE_MODE)) < 0) {
2010 2011 2012 2013 2014 2015 2016
		error = -1;
		goto cleanup;
	}

	p_close(fd);

	if (p_rename(git_buf_cstr(&old_path), git_buf_cstr(&temp_path)) < 0) {
2017
		git_error_set(GIT_ERROR_OS, "failed to rename reflog for %s", new_name);
2018 2019 2020 2021
		error = -1;
		goto cleanup;
	}

2022
	if (git_path_isdir(git_buf_cstr(&new_path)) &&
2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
		(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) {
2034
		git_error_set(GIT_ERROR_OS, "failed to rename reflog for %s", new_name);
2035 2036 2037 2038
		error = -1;
	}

cleanup:
2039 2040 2041 2042
	git_buf_dispose(&temp_path);
	git_buf_dispose(&old_path);
	git_buf_dispose(&new_path);
	git_buf_dispose(&normalized);
2043 2044 2045 2046 2047 2048

	return error;
}

static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name)
{
2049
	refdb_fs_backend *backend = (refdb_fs_backend *) _backend;
2050
	git_buf path = GIT_BUF_INIT;
2051
	int error;
2052 2053 2054

	assert(_backend && name);

2055 2056
	if ((error = retrieve_reflog_path(&path, backend->repo, name)) < 0)
		goto out;
2057

2058 2059
	if (!git_path_exists(path.ptr))
		goto out;
2060

2061 2062
	if ((error = p_unlink(path.ptr)) < 0)
		goto out;
2063

2064 2065 2066
	refdb_fs_backend__try_delete_empty_ref_hierarchie(backend, name, true);

out:
2067
	git_buf_dispose(&path);
2068 2069 2070 2071

	return error;
}

2072 2073
int git_refdb_backend_fs(
	git_refdb_backend **backend_out,
2074
	git_repository *repository)
2075
{
2076
	int t = 0;
2077
	git_buf gitpath = GIT_BUF_INIT;
2078 2079 2080
	refdb_fs_backend *backend;

	backend = git__calloc(1, sizeof(refdb_fs_backend));
2081
	GIT_ERROR_CHECK_ALLOC(backend);
2082 2083

	backend->repo = repository;
Vicent Marti committed
2084

2085 2086
	if (repository->gitdir) {
		backend->gitpath = setup_namespace(repository, repository->gitdir);
Vicent Marti committed
2087

2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
		if (backend->gitpath == NULL)
			goto fail;
	}

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

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

2099
	if (git_buf_joinpath(&gitpath, backend->commonpath, GIT_PACKEDREFS_FILE) < 0 ||
2100 2101
		git_sortedcache_new(
			&backend->refcache, offsetof(struct packref, name),
2102
			NULL, NULL, packref_cmp, git_buf_cstr(&gitpath)) < 0)
2103 2104
		goto fail;

2105
	git_buf_dispose(&gitpath);
2106

2107 2108 2109 2110 2111 2112 2113 2114
	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;
	}
2115
	if ((!git_repository__cvar(&t, backend->repo, GIT_CVAR_FSYNCOBJECTFILES) && t) ||
2116
		git_repository__fsync_gitdir)
2117
		backend->fsync = 1;
2118
	backend->iterator_flags |= GIT_ITERATOR_DESCEND_SYMLINKS;
2119

2120 2121
	backend->parent.exists = &refdb_fs_backend__exists;
	backend->parent.lookup = &refdb_fs_backend__lookup;
2122
	backend->parent.iterator = &refdb_fs_backend__iterator;
2123
	backend->parent.write = &refdb_fs_backend__write;
2124
	backend->parent.del = &refdb_fs_backend__delete;
Vicent Marti committed
2125
	backend->parent.rename = &refdb_fs_backend__rename;
2126
	backend->parent.compress = &refdb_fs_backend__compress;
2127 2128
	backend->parent.lock = &refdb_fs_backend__lock;
	backend->parent.unlock = &refdb_fs_backend__unlock;
2129
	backend->parent.has_log = &refdb_reflog_fs__has_log;
2130
	backend->parent.ensure_log = &refdb_reflog_fs__ensure_log;
2131
	backend->parent.free = &refdb_fs_backend__free;
2132 2133 2134 2135
	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;
2136 2137 2138

	*backend_out = (git_refdb_backend *)backend;
	return 0;
2139 2140

fail:
2141
	git_buf_dispose(&gitpath);
2142
	git__free(backend->gitpath);
2143
	git__free(backend->commonpath);
2144 2145
	git__free(backend);
	return -1;
2146
}