refdb_fs.c 47.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * 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.
 */

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

#include <git2/tag.h>
#include <git2/object.h>
#include <git2/refdb.h>
24
#include <git2/branch.h>
25
#include <git2/sys/refdb_backend.h>
26
#include <git2/sys/refs.h>
27
#include <git2/sys/reflog.h>
28

29
GIT__USE_STRMAP
30 31 32 33 34

#define DEFAULT_NESTING_LEVEL	5
#define MAX_NESTING_LEVEL		10

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

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

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;
Vicent Marti committed
58
	char *path;
59

60
	git_sortedcache *refcache;
61
	int peeling_mode;
62 63
	git_iterator_flag_t iterator_flags;
	uint32_t direach_flags;
64 65
} refdb_fs_backend;

66 67
static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name);

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

74
static int packed_reload(refdb_fs_backend *backend)
75
{
76 77 78
	int error;
	git_buf packedrefs = GIT_BUF_INIT;
	char *scan, *eof, *eol;
79

80
	if (!backend->path)
81 82
		return 0;

83
	error = git_sortedcache_lockandload(backend->refcache, &packedrefs);
84 85

	/*
86 87 88 89
	 * 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.
90
	 */
91 92 93 94 95 96 97
	if (error <= 0) {
		if (error == GIT_ENOTFOUND) {
			git_sortedcache_clear(backend->refcache, true);
			giterr_clear();
			error = 0;
		}
		return error;
98 99
	}

100
	/* At this point, refresh the packed refs from the loaded buffer. */
101

102
	git_sortedcache_clear(backend->refcache, false);
103

104 105
	scan = (char *)packedrefs.ptr;
	eof  = scan + packedrefs.size;
106

107 108
	backend->peeling_mode = PEELING_NONE;

109
	if (*scan == '#') {
nulltoken committed
110
		static const char *traits_header = "# pack-refs with: ";
111

112 113 114
		if (git__prefixcmp(scan, traits_header) == 0) {
			scan += strlen(traits_header);
			eol = strchr(scan, '\n');
115

116
			if (!eol)
117
				goto parse_failed;
118
			*eol = '\0';
119

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

126
			scan = eol + 1;
127 128 129
		}
	}

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

136 137 138 139 140
	while (scan < eof) {
		struct packref *ref;
		git_oid oid;

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

142
		if (git_oid_fromstr(&oid, scan) < 0)
143
			goto parse_failed;
144
		scan += GIT_OID_HEXSZ;
145

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

154
		if (git_sortedcache_upsert((void **)&ref, backend->refcache, scan) < 0)
155
			goto parse_failed;
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
		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;
180 181
	}

182
	git_sortedcache_wunlock(backend->refcache);
183 184
	git_buf_free(&packedrefs);

185 186 187
	return 0;

parse_failed:
188 189 190
	giterr_set(GITERR_REFERENCE, "Corrupted packed references file");

	git_sortedcache_clear(backend->refcache, false);
191
	git_sortedcache_wunlock(backend->refcache);
192 193
	git_buf_free(&packedrefs);

194 195 196
	return -1;
}

197 198
static int loose_parse_oid(
	git_oid *oid, const char *filename, git_buf *file_content)
199
{
200
	const char *str = git_buf_cstr(file_content);
201

202
	if (git_buf_len(file_content) < GIT_OID_HEXSZ)
203 204 205
		goto corrupted;

	/* we need to get 40 OID characters from the file */
206
	if (git_oid_fromstr(oid, str) < 0)
207 208 209 210 211 212 213 214
		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:
Vicent Marti committed
215
	giterr_set(GITERR_REFERENCE, "Corrupted loose reference file: %s", filename);
216 217 218
	return -1;
}

219 220 221 222 223 224 225 226 227 228 229 230 231
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)
		git_buf_free(buf);

	return error;
}

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

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

246
	/* skip symbolic refs */
247 248
	if (!git__prefixcmp(git_buf_cstr(&ref_file), GIT_SYMREF))
		goto done;
249

250 251 252
	/* parse OID from file */
	if ((error = loose_parse_oid(&oid, name, &ref_file)) < 0)
		goto done;
253

254
	git_sortedcache_wlock(backend->refcache);
255

256 257
	if (!(error = git_sortedcache_upsert(
			(void **)&ref, backend->refcache, name))) {
258

259 260
		git_oid_cpy(&ref->oid, &oid);
		ref->flags = PACKREF_WAS_LOOSE;
261 262
	}

263
	git_sortedcache_wunlock(backend->refcache);
264

265
done:
266
	git_buf_free(&ref_file);
267
	return error;
268 269
}

270
static int _dirent_loose_load(void *payload, git_buf *full_path)
271
{
272
	refdb_fs_backend *backend = payload;
273 274
	const char *file_path;

275 276 277
	if (git__suffixcmp(full_path->ptr, ".lock") == 0)
		return 0;

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

		return error;
	}
289

290
	file_path = full_path->ptr + strlen(backend->path);
291

292
	return loose_lookup_to_packfile(backend, file_path);
293 294 295 296 297 298 299 300 301 302
}

/*
 * 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)
{
303
	int error;
304 305 306 307 308 309 310 311 312 313
	git_buf refs_path = GIT_BUF_INIT;

	if (git_buf_joinpath(&refs_path, backend->path, GIT_REFS_DIR) < 0)
		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
	 */
314
	error = git_path_direach(
315
		&refs_path, backend->direach_flags, _dirent_loose_load, backend);
316

317 318
	git_buf_free(&refs_path);

319
	return error;
320 321 322 323 324 325 326
}

static int refdb_fs_backend__exists(
	int *exists,
	git_refdb_backend *_backend,
	const char *ref_name)
{
327
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
328 329
	git_buf ref_path = GIT_BUF_INIT;

330
	assert(backend);
331

332 333
	if (packed_reload(backend) < 0 ||
		git_buf_joinpath(&ref_path, backend->path, ref_name) < 0)
334 335
		return -1;

336
	*exists = git_path_isfile(ref_path.ptr) ||
337
		(git_sortedcache_lookup(backend->refcache, ref_name) != NULL);
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371

	git_buf_free(&ref_path);
	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) {
		giterr_set(GITERR_REFERENCE, "Corrupted loose reference file");
		return NULL;
	}

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

	return refname_start;
}

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;

372 373 374
	if (out)
		*out = NULL;

375 376 377 378
	if ((error = loose_readbuffer(&ref_file, backend->path, ref_name)) < 0)
		/* cannot read loose ref file - gah */;
	else if (git__prefixcmp(git_buf_cstr(&ref_file), GIT_SYMREF) == 0) {
		const char *target;
379 380 381

		git_buf_rtrim(&ref_file);

382
		if (!(target = loose_parse_symbolic(&ref_file)))
383
			error = -1;
384
		else if (out != NULL)
385
			*out = git_reference__alloc_symbolic(ref_name, target);
386
	} else {
387
		git_oid oid;
388

389 390
		if (!(error = loose_parse_oid(&oid, ref_name, &ref_file)) &&
			out != NULL)
391
			*out = git_reference__alloc(ref_name, &oid, NULL);
392 393 394 395 396 397
	}

	git_buf_free(&ref_file);
	return error;
}

398
static int ref_error_notfound(const char *name)
399
{
400 401
	giterr_set(GITERR_REFERENCE, "Reference '%s' not found", name);
	return GIT_ENOTFOUND;
402 403 404 405 406 407 408 409
}

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

412
	if (packed_reload(backend) < 0)
413
		return -1;
414

415 416
	if (git_sortedcache_rlock(backend->refcache) < 0)
		return -1;
417 418 419 420 421 422 423 424 425 426

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

427 428
	git_sortedcache_runlock(backend->refcache);

429
	return error;
430 431 432 433 434 435 436
}

static int refdb_fs_backend__lookup(
	git_reference **out,
	git_refdb_backend *_backend,
	const char *ref_name)
{
437 438
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
	int error;
439

440
	assert(backend);
441

442
	if (!(error = loose_lookup(out, backend, ref_name)))
443 444 445 446
		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 */
447
	if (error == GIT_ENOTFOUND) {
448
		giterr_clear();
449
		error = packed_lookup(out, backend, ref_name);
450 451
	}

452
	return error;
453 454
}

455 456
typedef struct {
	git_reference_iterator parent;
457

458
	char *glob;
459 460

	git_pool pool;
461
	git_vector loose;
462

463
	git_sortedcache *cache;
464 465
	size_t loose_pos;
	size_t packed_pos;
466 467 468
} refdb_fs_iter;

static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)
469
{
470
	refdb_fs_iter *iter = (refdb_fs_iter *) _iter;
471 472

	git_vector_free(&iter->loose);
473
	git_pool_clear(&iter->pool);
474
	git_sortedcache_free(iter->cache);
475 476
	git__free(iter);
}
477

478
static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter)
479
{
480
	int error = 0;
481
	git_buf path = GIT_BUF_INIT;
482
	git_iterator *fsit = NULL;
483
	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
484
	const git_index_entry *entry = NULL;
485

486 487 488
	if (!backend->path) /* do nothing if no path for loose refs */
		return 0;

489 490
	fsit_opts.flags = backend->iterator_flags;

491
	if ((error = git_buf_printf(&path, "%s/refs", backend->path)) < 0 ||
492
		(error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {
493 494 495
		git_buf_free(&path);
		return error;
	}
496

497
	error = git_buf_sets(&path, GIT_REFS_DIR);
498

499
	while (!error && !git_iterator_advance(&entry, fsit)) {
500
		const char *ref_name;
501
		struct packref *ref;
502
		char *ref_dup;
503

504 505 506
		git_buf_truncate(&path, strlen(GIT_REFS_DIR));
		git_buf_puts(&path, entry->path);
		ref_name = git_buf_cstr(&path);
507

508
		if (git__suffixcmp(ref_name, ".lock") == 0 ||
509
			(iter->glob && p_fnmatch(iter->glob, ref_name, 0) != 0))
510
			continue;
511

512
		git_sortedcache_rlock(backend->refcache);
513 514
		ref = git_sortedcache_lookup(backend->refcache, ref_name);
		if (ref)
515
			ref->flags |= PACKREF_SHADOWED;
516
		git_sortedcache_runlock(backend->refcache);
517

518 519
		ref_dup = git_pool_strdup(&iter->pool, ref_name);
		if (!ref_dup)
520
			error = -1;
521 522
		else
			error = git_vector_insert(&iter->loose, ref_dup);
523
	}
524

525 526
	git_iterator_free(fsit);
	git_buf_free(&path);
527

528
	return error;
529 530
}

531 532
static int refdb_fs_backend__iterator_next(
	git_reference **out, git_reference_iterator *_iter)
533
{
534
	int error = GIT_ITEROVER;
535
	refdb_fs_iter *iter = (refdb_fs_iter *)_iter;
536
	refdb_fs_backend *backend = (refdb_fs_backend *)iter->parent.db->backend;
537
	struct packref *ref;
538

Vicent Marti committed
539
	while (iter->loose_pos < iter->loose.length) {
540
		const char *path = git_vector_get(&iter->loose, iter->loose_pos++);
Vicent Marti committed
541 542 543 544 545

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

		giterr_clear();
546
	}
547

548 549 550 551
	if (!iter->cache) {
		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
			return error;
	}
552

553 554 555
	error = GIT_ITEROVER;
	while (iter->packed_pos < git_sortedcache_entrycount(iter->cache)) {
		ref = git_sortedcache_entry(iter->cache, iter->packed_pos++);
556 557
		if (!ref) /* stop now if another thread deleted refs and we past end */
			break;
558 559 560 561 562

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

Vicent Marti committed
564
		*out = git_reference__alloc(ref->name, &ref->oid, &ref->peel);
565 566
		error = (*out != NULL) ? 0 : -1;
		break;
567 568
	}

569
	return error;
570 571
}

572 573 574
static int refdb_fs_backend__iterator_next_name(
	const char **out, git_reference_iterator *_iter)
{
575
	int error = GIT_ITEROVER;
576 577
	refdb_fs_iter *iter = (refdb_fs_iter *)_iter;
	refdb_fs_backend *backend = (refdb_fs_backend *)iter->parent.db->backend;
578
	struct packref *ref;
579 580 581 582

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

583 584 585
		if (loose_lookup(NULL, backend, path) == 0) {
			*out = path;
			return 0;
586 587
		}

588
		giterr_clear();
589 590
	}

591 592 593 594
	if (!iter->cache) {
		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
			return error;
	}
595

596 597 598
	error = GIT_ITEROVER;
	while (iter->packed_pos < git_sortedcache_entrycount(iter->cache)) {
		ref = git_sortedcache_entry(iter->cache, iter->packed_pos++);
599 600
		if (!ref) /* stop now if another thread deleted refs and we past end */
			break;
601 602 603

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

607 608 609
		*out = ref->name;
		error = 0;
		break;
610 611
	}

612
	return error;
613 614 615 616 617 618
}

static int refdb_fs_backend__iterator(
	git_reference_iterator **out, git_refdb_backend *_backend, const char *glob)
{
	refdb_fs_iter *iter;
619
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
620

621
	assert(backend);
622

623
	if (packed_reload(backend) < 0)
624 625 626 627 628
		return -1;

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

629 630 631
	git_pool_init(&iter->pool, 1);

	if (git_vector_init(&iter->loose, 8, NULL) < 0)
632 633 634 635 636
		goto fail;

	if (glob != NULL &&
		(iter->glob = git_pool_strdup(&iter->pool, glob)) == NULL)
		goto fail;
637 638 639 640 641

	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;

642 643
	if (iter_load_loose_paths(backend, iter) < 0)
		goto fail;
644 645 646

	*out = (git_reference_iterator *)iter;
	return 0;
647 648 649 650

fail:
	refdb_fs_backend__iterator_free((git_reference_iterator *)iter);
	return -1;
651 652
}

Vicent Marti committed
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
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)
{
676
	size_t i;
Vicent Marti committed
677

678
	if (packed_reload(backend) < 0)
Vicent Marti committed
679 680 681 682 683
		return -1;

	if (!force) {
		int exists;

684 685
		if (refdb_fs_backend__exists(
				&exists, (git_refdb_backend *)backend, new_ref) < 0)
Vicent Marti committed
686 687 688 689 690
			return -1;

		if (exists) {
			giterr_set(GITERR_REFERENCE,
				"Failed to write reference '%s': a reference with "
691
				"that name already exists.", new_ref);
Vicent Marti committed
692 693 694 695
			return GIT_EEXISTS;
		}
	}

696
	git_sortedcache_rlock(backend->refcache);
697 698

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

701 702
		if (ref && !ref_is_available(old_ref, new_ref, ref->name)) {
			git_sortedcache_runlock(backend->refcache);
Vicent Marti committed
703
			giterr_set(GITERR_REFERENCE,
704
				"Path to reference '%s' collides with existing one", new_ref);
Vicent Marti committed
705 706
			return -1;
		}
707
	}
708

709
	git_sortedcache_runlock(backend->refcache);
Vicent Marti committed
710 711
	return 0;
}
712

713
static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char *name)
714
{
715
	int error;
716 717
	git_buf ref_path = GIT_BUF_INIT;

718
	assert(file && backend && name);
719

720
	if (!git_path_isvalid(backend->repo, name, GIT_PATH_REJECT_FILESYSTEM_DEFAULTS)) {
721 722 723 724
		giterr_set(GITERR_INVALID, "Invalid reference name '%s'.", name);
		return GIT_EINVALIDSPEC;
	}

725 726 727
	/* Remove a possibly existing empty directory hierarchy
	 * which name would collide with the reference name
	 */
728
	if (git_futils_rmdir_r(name, backend->path, GIT_RMDIR_SKIP_NONEMPTY) < 0)
729 730
		return -1;

731
	if (git_buf_joinpath(&ref_path, backend->path, name) < 0)
732 733
		return -1;

734
	error = git_filebuf_open(file, ref_path.ptr, GIT_FILEBUF_FORCE, GIT_REFS_FILE_MODE);
735

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

739
	git_buf_free(&ref_path);
740
	return error;
741
}
742

743 744
static int loose_commit(git_filebuf *file, const git_reference *ref)
{
745 746
	assert(file && ref);

747 748
	if (ref->type == GIT_REF_OID) {
		char oid[GIT_OID_HEXSZ + 1];
749
		git_oid_nfmt(oid, sizeof(oid), &ref->target.oid);
750

751
		git_filebuf_printf(file, "%s\n", oid);
752
	} else if (ref->type == GIT_REF_SYMBOLIC) {
753
		git_filebuf_printf(file, GIT_SYMREF "%s\n", ref->target.symbolic);
754 755 756 757
	} else {
		assert(0); /* don't let this happen */
	}

758
	return git_filebuf_commit(file);
759 760
}

761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
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;
}

812 813 814 815 816 817 818 819 820 821 822 823
/*
 * 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;

824
	if (ref->flags & PACKREF_HAS_PEEL || ref->flags & PACKREF_CANNOT_PEEL)
825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
		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));
845
		ref->flags |= PACKREF_HAS_PEEL;
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863

		/*
		 * 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];
864
	git_oid_nfmt(oid, sizeof(oid), &ref->oid);
865 866 867 868 869 870 871 872 873 874 875

	/*
	 * 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`.
	 */
876
	if (ref->flags & PACKREF_HAS_PEEL) {
877
		char peel[GIT_OID_HEXSZ + 1];
878
		git_oid_nfmt(peel, sizeof(peel), &ref->peel);
879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900

		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.
 */
901
static int packed_remove_loose(refdb_fs_backend *backend)
902
{
903
	size_t i;
904 905 906
	git_buf full_path = GIT_BUF_INIT;
	int failed = 0;

907 908 909 910
	/* 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);
911

912
		if (!ref || !(ref->flags & PACKREF_WAS_LOOSE))
913 914 915 916 917
			continue;

		if (git_buf_joinpath(&full_path, backend->path, ref->name) < 0)
			return -1; /* critical; do not try to recover on oom */

918
		if (git_path_exists(full_path.ptr) && p_unlink(full_path.ptr) < 0) {
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
			if (failed)
				continue;

			giterr_set(GITERR_REFERENCE,
				"Failed to remove loose reference '%s' after packing: %s",
				full_path.ptr, strerror(errno));
			failed = 1;
		}

		/*
		 * if we fail to remove a single file, this is *not* good,
		 * but we should keep going and remove as many as possible.
		 * After we've removed as many files as possible, we return
		 * the error code anyway.
		 */
	}

	git_buf_free(&full_path);
	return failed ? -1 : 0;
}

/*
 * Write all the contents in the in-memory packfile to disk.
 */
static int packed_write(refdb_fs_backend *backend)
{
945
	git_sortedcache *refcache = backend->refcache;
946
	git_filebuf pack_file = GIT_FILEBUF_INIT;
947
	size_t i;
948

949
	/* lock the cache to updates while we do this */
950
	if (git_sortedcache_wlock(refcache) < 0)
951 952
		return -1;

953
	/* Open the file! */
954
	if (git_filebuf_open(&pack_file, git_sortedcache_path(refcache), 0, GIT_PACKEDREFS_FILE_MODE) < 0)
955
		goto fail;
956 957 958 959 960

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

963 964
	for (i = 0; i < git_sortedcache_entrycount(refcache); ++i) {
		struct packref *ref = git_sortedcache_entry(refcache, i);
965
		assert(ref);
966 967

		if (packed_find_peel(backend, ref) < 0)
968
			goto fail;
969 970

		if (packed_write_ref(ref, &pack_file) < 0)
971
			goto fail;
972 973 974 975
	}

	/* if we've written all the references properly, we can commit
	 * the packfile to make the changes effective */
976
	if (git_filebuf_commit(&pack_file) < 0)
977
		goto fail;
978 979 980

	/* when and only when the packfile has been properly written,
	 * we can go ahead and remove the loose refs */
981
	if (packed_remove_loose(backend) < 0)
982
		goto fail;
983

984 985
	git_sortedcache_updated(refcache);
	git_sortedcache_wunlock(refcache);
986 987 988 989

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

990
fail:
991
	git_filebuf_cleanup(&pack_file);
992
	git_sortedcache_wunlock(refcache);
993 994 995 996

	return -1;
}

997
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);
998 999 1000
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 */
1001
static int should_write_reflog(int *write, git_repository *repo, const char *name)
1002
{
1003
	int error, logall;
1004

1005 1006
	error = git_repository__cvar(&logall, repo, GIT_CVAR_LOGALLREFUPDATES);
	if (error < 0)
1007 1008
		return error;

1009 1010 1011
	/* Defaults to the opposite of the repo being bare */
	if (logall == GIT_LOGALLREFUPDATES_UNSET)
		logall = !git_repository_is_bare(repo);
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024

	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;
	}
1025 1026 1027

	return 0;
}
1028

1029
static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const char *name,
1030 1031 1032 1033 1034 1035
	const git_oid *old_id, const char *old_target)
{
	int error = 0;
	git_reference *old_ref = NULL;

	*cmp = 0;
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
	/* 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;
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
	}

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

1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
/*
 * 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;
1082
	git_oid old_id = {{0}};
1083 1084 1085 1086 1087
	git_reference *tmp = NULL, *head = NULL, *peeled = NULL;
	const char *name;

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

1089 1090
	/* if we can't resolve, we use {0}*40 as old id */
	git_reference_name_to_id(&old_id, backend->repo, ref->name);
1091

1092
	if ((error = git_reference_lookup(&head, backend->repo, GIT_HEAD_FILE)) < 0)
1093 1094
		return error;

1095 1096 1097
	if (git_reference_type(head) == GIT_REF_OID)
		goto cleanup;

1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
	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))
1121 1122
		goto cleanup;

1123 1124
	error = reflog_append(backend, head, &old_id, git_reference_target(ref), who, message);

1125
cleanup:
1126
	git_reference_free(tmp);
1127 1128 1129 1130
	git_reference_free(head);
	return error;
}

1131 1132
static int refdb_fs_backend__write(
	git_refdb_backend *_backend,
Vicent Marti committed
1133
	const git_reference *ref,
1134
	int force,
1135
	const git_signature *who,
1136
	const char *message,
1137 1138
	const git_oid *old_id,
	const char *old_target)
1139
{
1140
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1141
	git_filebuf file = GIT_FILEBUF_INIT;
1142
	int error = 0;
1143

1144
	assert(backend);
1145

Vicent Marti committed
1146 1147 1148 1149
	error = reference_path_available(backend, ref->name, NULL, force);
	if (error < 0)
		return error;

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

1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
	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;

1172
	if ((error = cmp_old_ref(&cmp, _backend, ref->name, old_id, old_target)) < 0)
1173
		goto on_error;
1174 1175 1176 1177 1178

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

1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
	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 */
	}

1196 1197
	if (update_reflog) {
		if ((error = should_write_reflog(&should_write, backend->repo, ref->name)) < 0)
1198
			goto on_error;
1199 1200 1201 1202 1203 1204 1205

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

1208
	return loose_commit(file, ref);
1209 1210

on_error:
1211
        git_filebuf_cleanup(file);
1212
        return error;
1213 1214 1215 1216
}

static int refdb_fs_backend__delete(
	git_refdb_backend *_backend,
1217 1218
	const char *ref_name,
	const git_oid *old_id, const char *old_target)
1219
{
1220
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1221
	git_filebuf file = GIT_FILEBUF_INIT;
1222
	int error = 0;
1223

1224
	assert(backend && ref_name);
1225

1226 1227 1228
	if ((error = loose_lock(&file, backend, ref_name)) < 0)
		return error;

1229 1230 1231 1232 1233
	if ((error = refdb_reflog_fs__delete(_backend, ref_name)) < 0) {
		git_filebuf_cleanup(&file);
		return error;
	}

1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
	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;

1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
	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;
	}

1259
	/* If a loose reference exists, remove it from the filesystem */
Vicent Marti committed
1260
	if (git_buf_joinpath(&loose_path, backend->path, ref_name) < 0)
1261 1262 1263 1264 1265 1266
		return -1;

	if (git_path_isfile(loose_path.ptr)) {
		error = p_unlink(loose_path.ptr);
		loose_deleted = 1;
	}
1267

1268 1269 1270
	git_buf_free(&loose_path);

	if (error != 0)
1271
		goto cleanup;
1272

1273 1274
	if ((error = packed_reload(backend)) < 0)
		goto cleanup;
1275

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

1280 1281
	if (!(error = git_sortedcache_lookup_index(
			&pack_pos, backend->refcache, ref_name)))
1282
		error = git_sortedcache_remove(backend->refcache, pack_pos);
1283

1284
	git_sortedcache_wunlock(backend->refcache);
1285

1286 1287 1288 1289 1290 1291
	if (error == GIT_ENOTFOUND) {
		error = loose_deleted ? 0 : ref_error_notfound(ref_name);
		goto cleanup;
	}

	error = packed_write(backend);
1292

1293
cleanup:
1294
	git_filebuf_cleanup(file);
1295 1296

	return error;
1297 1298
}

1299 1300
static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_name, const char *new_name);

Vicent Marti committed
1301 1302 1303 1304 1305
static int refdb_fs_backend__rename(
	git_reference **out,
	git_refdb_backend *_backend,
	const char *old_name,
	const char *new_name,
1306
	int force,
1307
	const git_signature *who,
1308
	const char *message)
Vicent Marti committed
1309
{
1310
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
Vicent Marti committed
1311
	git_reference *old, *new;
1312
	git_filebuf file = GIT_FILEBUF_INIT;
Vicent Marti committed
1313 1314
	int error;

1315
	assert(backend);
Vicent Marti committed
1316

1317 1318 1319
	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
1320 1321
		return error;

1322
	if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) {
Vicent Marti committed
1323 1324 1325 1326
		git_reference_free(old);
		return error;
	}

1327 1328 1329 1330
	new = git_reference__set_name(old, new_name);
	if (!new) {
		git_reference_free(old);
		return -1;
Vicent Marti committed
1331 1332
	}

1333
	if ((error = loose_lock(&file, backend, new->name)) < 0) {
1334 1335 1336 1337 1338 1339 1340
		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)) &&
1341
	    ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) {
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
		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
1355
		git_reference_free(new);
1356
		return error;
Vicent Marti committed
1357 1358
	}

1359
	*out = new;
Vicent Marti committed
1360 1361 1362
	return 0;
}

1363 1364
static int refdb_fs_backend__compress(git_refdb_backend *_backend)
{
1365
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1366

1367
	assert(backend);
1368

1369
	if (packed_reload(backend) < 0 || /* load the existing packfile */
1370 1371 1372 1373 1374 1375 1376 1377 1378
		packed_loadloose(backend) < 0 || /* add all the loose refs */
		packed_write(backend) < 0) /* write back to disk */
		return -1;

	return 0;
}

static void refdb_fs_backend__free(git_refdb_backend *_backend)
{
1379
	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
1380

1381
	assert(backend);
1382

1383
	git_sortedcache_free(backend->refcache);
Vicent Marti committed
1384
	git__free(backend->path);
1385 1386 1387
	git__free(backend);
}

1388 1389
static int setup_namespace(git_buf *path, git_repository *repo)
{
nulltoken committed
1390
	char *parts, *start, *end;
1391

1392 1393 1394 1395
	/* Not all repositories have a path */
	if (repo->path_repository == NULL)
		return 0;

1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
	/* Load the path to the repo first */
	git_buf_puts(path, repo->path_repository);

	/* if the repo is not namespaced, nothing else to do */
	if (repo->namespace == NULL)
		return 0;

	parts = end = git__strdup(repo->namespace);
	if (parts == NULL)
		return -1;

1407
	/*
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
	 * 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/
	 */
	while ((start = git__strsep(&end, "/")) != NULL) {
		git_buf_printf(path, "refs/namespaces/%s/", start);
	}

	git_buf_printf(path, "refs/namespaces/%s/refs", end);
Vicent Marti committed
1418
	git__free(parts);
1419 1420

	/* Make sure that the folder with the namespace exists */
1421 1422
	if (git_futils_mkdir_relative(git_buf_cstr(path), repo->path_repository,
			0777, GIT_MKDIR_PATH, NULL) < 0)
1423 1424
		return -1;

1425
	/* Return root of the namespaced path, i.e. without the trailing '/refs' */
1426 1427 1428 1429
	git_buf_rtruncate_at_char(path, '/');
	return 0;
}

1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
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) { \
		giterr_set(GITERR_INVALID, "Ran out of data while parsing reflog"); \
		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);

1471
		entry->committer = git__calloc(1, sizeof(git_signature));
1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
		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:
1516
	git_reflog_entry__free(entry);
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528

	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,
1529
			O_WRONLY | O_CREAT,
1530 1531 1532 1533 1534 1535 1536 1537
			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)
{
1538
	return git_buf_join3(path, '/', repo->path_repository, GIT_REFLOG_DIR, name);
1539 1540
}

1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
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;

1556 1557 1558 1559
	error = create_new_reflog_file(git_buf_cstr(&path));
	git_buf_free(&path);

	return error;
1560 1561
}

1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
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:
	git_buf_free(&path);
	return ret;
}

1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587
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);
}

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 1615 1616 1617 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 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
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:
	git_buf_free(&log_file);
	git_buf_free(&log_path);

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

1667 1668 1669 1670 1671 1672 1673 1674
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;

1675
	if (!git_path_isvalid(backend->repo, refname, GIT_PATH_REJECT_FILESYSTEM_DEFAULTS)) {
1676 1677 1678 1679
		giterr_set(GITERR_INVALID, "Invalid reference name '%s'.", refname);
		return GIT_EINVALIDSPEC;
	}

1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697
	if (retrieve_reflog_path(&log_path, repo, refname) < 0)
		return -1;

	if (!git_path_isfile(git_buf_cstr(&log_path))) {
		giterr_set(GITERR_INVALID,
			"Log file for reference '%s' doesn't exist.", refname);
		error = -1;
		goto cleanup;
	}

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

cleanup:
	git_buf_free(&log_path);

	return error;
}

1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710
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;

1711
	if ((error = lock_reflog(&fbuf, backend, reflog->ref_name)) < 0)
1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
		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;
	}

1722
	error = git_filebuf_commit(&fbuf);
1723 1724 1725 1726 1727 1728 1729
	goto success;

cleanup:
	git_filebuf_cleanup(&fbuf);

success:
	git_buf_free(&log);
1730

1731 1732 1733
	return error;
}

1734
/* Append to the reflog, must be called under reference lock */
1735
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)
1736
{
1737
	int error, is_symbolic;
1738
	git_oid old_id = {{0}}, new_id = {{0}};
1739 1740 1741
	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
	git_repository *repo = backend->repo;

1742 1743 1744 1745 1746 1747
	is_symbolic = ref->type == GIT_REF_SYMBOLIC;

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

1750 1751 1752 1753
	/* From here on is_symoblic also means that it's HEAD */

	if (old) {
		git_oid_cpy(&old_id, old);
1754
	} else {
1755
		error = git_reference_name_to_id(&old_id, repo, ref->name);
1756
		if (error < 0 && error != GIT_ENOTFOUND)
1757 1758 1759
			return error;
	}

1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771
	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;
1772

1773 1774
			giterr_clear();
		}
1775
	}
1776

1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
	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;
	}

1788 1789 1790
	/* 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.
	 */
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
	if (git_path_isdir(git_buf_cstr(&path))) {
		if ((git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_SKIP_NONEMPTY) < 0))
			error = -1;
		else if (git_path_isdir(git_buf_cstr(&path))) {
			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;
1802 1803
	}

1804 1805 1806 1807 1808 1809
	error = git_futils_writebuffer(&buf, git_buf_cstr(&path), O_WRONLY|O_CREAT|O_APPEND, GIT_REFLOG_FILE_MODE);

cleanup:
	git_buf_free(&buf);
	git_buf_free(&path);

1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
	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;

	if (git_buf_joinpath(&temp_path, repo->path_repository, GIT_REFLOG_DIR) < 0)
		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;

1841 1842 1843 1844 1845
	if (!git_path_exists(git_buf_cstr(&old_path))) {
		error = GIT_ENOTFOUND;
		goto cleanup;
	}

1846 1847 1848 1849 1850 1851 1852 1853 1854 1855
	/*
	 * 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;

1856
	if ((fd = git_futils_mktmp(&temp_path, git_buf_cstr(&temp_path), GIT_REFLOG_FILE_MODE)) < 0) {
1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917
		error = -1;
		goto cleanup;
	}

	p_close(fd);

	if (p_rename(git_buf_cstr(&old_path), git_buf_cstr(&temp_path)) < 0) {
		giterr_set(GITERR_OS, "Failed to rename reflog for %s", new_name);
		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) {
		giterr_set(GITERR_OS, "Failed to rename reflog for %s", new_name);
		error = -1;
	}

cleanup:
	git_buf_free(&temp_path);
	git_buf_free(&old_path);
	git_buf_free(&new_path);
	git_buf_free(&normalized);

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

	git_buf_free(&path);

	return error;

}

1918 1919
int git_refdb_backend_fs(
	git_refdb_backend **backend_out,
1920
	git_repository *repository)
1921
{
1922
	int t = 0;
Vicent Marti committed
1923
	git_buf path = GIT_BUF_INIT;
1924 1925 1926 1927 1928 1929
	refdb_fs_backend *backend;

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

	backend->repo = repository;
Vicent Marti committed
1930

1931 1932
	if (setup_namespace(&path, repository) < 0)
		goto fail;
Vicent Marti committed
1933 1934

	backend->path = git_buf_detach(&path);
1935

1936 1937 1938 1939 1940 1941 1942 1943
	if (git_buf_joinpath(&path, backend->path, GIT_PACKEDREFS_FILE) < 0 ||
		git_sortedcache_new(
			&backend->refcache, offsetof(struct packref, name),
			NULL, NULL, packref_cmp, git_buf_cstr(&path)) < 0)
		goto fail;

	git_buf_free(&path);

1944 1945 1946 1947 1948 1949 1950 1951 1952
	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;
	}

1953 1954
	backend->parent.exists = &refdb_fs_backend__exists;
	backend->parent.lookup = &refdb_fs_backend__lookup;
1955
	backend->parent.iterator = &refdb_fs_backend__iterator;
1956
	backend->parent.write = &refdb_fs_backend__write;
1957
	backend->parent.del = &refdb_fs_backend__delete;
Vicent Marti committed
1958
	backend->parent.rename = &refdb_fs_backend__rename;
1959
	backend->parent.compress = &refdb_fs_backend__compress;
1960 1961
	backend->parent.lock = &refdb_fs_backend__lock;
	backend->parent.unlock = &refdb_fs_backend__unlock;
1962
	backend->parent.has_log = &refdb_reflog_fs__has_log;
1963
	backend->parent.ensure_log = &refdb_reflog_fs__ensure_log;
1964
	backend->parent.free = &refdb_fs_backend__free;
1965 1966 1967 1968
	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;
1969 1970 1971

	*backend_out = (git_refdb_backend *)backend;
	return 0;
1972 1973 1974 1975 1976 1977

fail:
	git_buf_free(&path);
	git__free(backend->path);
	git__free(backend);
	return -1;
1978
}