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

#include "refs.h"
9

10 11 12
#include "hash.h"
#include "repository.h"
#include "fileops.h"
13
#include "filebuf.h"
14
#include "pack.h"
15
#include "reflog.h"
16
#include "refdb.h"
17

Vicent Marti committed
18 19
#include <git2/tag.h>
#include <git2/object.h>
20
#include <git2/oid.h>
21
#include <git2/branch.h>
22 23
#include <git2/refs.h>
#include <git2/refdb.h>
24
#include <git2/sys/refs.h>
25
#include <git2/signature.h>
26
#include <git2/commit.h>
Vicent Marti committed
27

28 29
bool git_reference__enable_symbolic_ref_target_validation = true;

30 31
#define DEFAULT_NESTING_LEVEL	5
#define MAX_NESTING_LEVEL		10
32

33 34 35 36
enum {
	GIT_PACKREF_HAS_PEEL = 1,
	GIT_PACKREF_WAS_LOOSE = 2
};
37

38
static git_reference *alloc_ref(const char *name)
39
{
40 41
	git_reference *ref = NULL;
	size_t namelen = strlen(name), reflen;
42

43 44 45 46
	if (!GIT_ADD_SIZET_OVERFLOW(&reflen, sizeof(git_reference), namelen) &&
		!GIT_ADD_SIZET_OVERFLOW(&reflen, reflen, 1) &&
		(ref = git__calloc(1, reflen)) != NULL)
		memcpy(ref->name, name, namelen + 1);
47 48 49 50 51

	return ref;
}

git_reference *git_reference__alloc_symbolic(
52
	const char *name, const char *target)
53
{
54
	git_reference *ref;
55

56
	assert(name && target);
57

58
	ref = alloc_ref(name);
59
	if (!ref)
60
		return NULL;
Vicent Marti committed
61

62
	ref->type = GIT_REFERENCE_SYMBOLIC;
Vicent Marti committed
63

64 65 66
	if ((ref->target.symbolic = git__strdup(target)) == NULL) {
		git__free(ref);
		return NULL;
67
	}
68

69 70 71 72 73 74 75 76 77 78
	return ref;
}

git_reference *git_reference__alloc(
	const char *name,
	const git_oid *oid,
	const git_oid *peel)
{
	git_reference *ref;

79
	assert(name && oid);
80

81
	ref = alloc_ref(name);
82 83 84
	if (!ref)
		return NULL;

85
	ref->type = GIT_REFERENCE_DIRECT;
86
	git_oid_cpy(&ref->target.oid, oid);
87 88

	if (peel != NULL)
89
		git_oid_cpy(&ref->peel, peel);
90

91
	return ref;
92
}
93

94 95 96 97
git_reference *git_reference__set_name(
	git_reference *ref, const char *name)
{
	size_t namelen = strlen(name);
98
	size_t reflen;
99 100
	git_reference *rewrite = NULL;

101 102 103
	if (!GIT_ADD_SIZET_OVERFLOW(&reflen, sizeof(git_reference), namelen) &&
		!GIT_ADD_SIZET_OVERFLOW(&reflen, reflen, 1) &&
		(rewrite = git__realloc(ref, reflen)) != NULL)
104
		memcpy(rewrite->name, name, namelen + 1);
105

106 107 108
	return rewrite;
}

109 110
int git_reference_dup(git_reference **dest, git_reference *source)
{
111
	if (source->type == GIT_REFERENCE_SYMBOLIC)
112 113 114 115
		*dest = git_reference__alloc_symbolic(source->name, source->target.symbolic);
	else
		*dest = git_reference__alloc(source->name, &source->target.oid, &source->peel);

116
	GIT_ERROR_CHECK_ALLOC(*dest);
117

118 119 120
	(*dest)->db = source->db;
	GIT_REFCOUNT_INC((*dest)->db);

121 122 123
	return 0;
}

124
void git_reference_free(git_reference *reference)
125
{
126 127
	if (reference == NULL)
		return;
128

129
	if (reference->type == GIT_REFERENCE_SYMBOLIC)
130
		git__free(reference->target.symbolic);
131

Vicent Marti committed
132 133
	if (reference->db)
		GIT_REFCOUNT_DEC(reference->db, git_refdb__free);
134 135

	git__free(reference);
136
}
137

138
int git_reference_delete(git_reference *ref)
139
{
140 141 142
	const git_oid *old_id = NULL;
	const char *old_target = NULL;

143
	if (ref->type == GIT_REFERENCE_DIRECT)
144 145 146 147 148
		old_id = &ref->target.oid;
	else
		old_target = ref->target.symbolic;

	return git_refdb_delete(ref->db, ref->name, old_id, old_target);
149 150
}

151 152 153 154 155 156 157 158 159 160 161
int git_reference_remove(git_repository *repo, const char *name)
{
	git_refdb *db;
	int error;

	if ((error = git_repository_refdb__weakptr(&db, repo)) < 0)
		return error;

	return git_refdb_delete(db, name, NULL, NULL);
}

162
int git_reference_lookup(git_reference **ref_out,
163
	git_repository *repo, const char *name)
164
{
165 166 167
	return git_reference_lookup_resolved(ref_out, repo, name, 0);
}

168
int git_reference_name_to_id(
169 170 171 172 173 174 175 176
	git_oid *out, git_repository *repo, const char *name)
{
	int error;
	git_reference *ref;

	if ((error = git_reference_lookup_resolved(&ref, repo, name, -1)) < 0)
		return error;

177
	git_oid_cpy(out, git_reference_target(ref));
178 179 180 181
	git_reference_free(ref);
	return 0;
}

182
static int reference_normalize_for_repo(
183
	git_refname_t out,
184
	git_repository *repo,
185 186
	const char *name,
	bool validate)
187 188
{
	int precompose;
189
	unsigned int flags = GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL;
190 191 192

	if (!git_repository__cvar(&precompose, repo, GIT_CVAR_PRECOMPOSE) &&
		precompose)
193
		flags |= GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE;
194

195
	if (!validate)
196
		flags |= GIT_REFERENCE_FORMAT__VALIDATION_DISABLE;
197

198
	return git_reference_normalize_name(out, GIT_REFNAME_MAX, name, flags);
199 200
}

201 202 203 204 205 206
int git_reference_lookup_resolved(
	git_reference **ref_out,
	git_repository *repo,
	const char *name,
	int max_nesting)
{
207
	git_refname_t scan_name;
208
	git_reference_t scan_type;
209 210 211
	int error = 0, nesting;
	git_reference *ref = NULL;
	git_refdb *refdb;
212 213

	assert(ref_out && repo && name);
214

215
	*ref_out = NULL;
216

217 218 219 220
	if (max_nesting > MAX_NESTING_LEVEL)
		max_nesting = MAX_NESTING_LEVEL;
	else if (max_nesting < 0)
		max_nesting = DEFAULT_NESTING_LEVEL;
221

222
	scan_type = GIT_REFERENCE_SYMBOLIC;
223

224
	if ((error = reference_normalize_for_repo(scan_name, repo, name, true)) < 0)
225
		return error;
226

227
	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
228
		return error;
229 230

	for (nesting = max_nesting;
231
		 nesting >= 0 && scan_type == GIT_REFERENCE_SYMBOLIC;
232 233
		 nesting--)
	{
234
		if (nesting != max_nesting) {
235
			strncpy(scan_name, ref->target.symbolic, sizeof(scan_name));
236 237
			git_reference_free(ref);
		}
238

239 240
		if ((error = git_refdb_lookup(&ref, refdb, scan_name)) < 0)
			return error;
241

242
		scan_type = ref->type;
243 244
	}

245
	if (scan_type != GIT_REFERENCE_DIRECT && max_nesting != 0) {
246
		git_error_set(GIT_ERROR_REFERENCE,
247
			"cannot resolve reference (>%u levels deep)", max_nesting);
248
		git_reference_free(ref);
249 250 251
		return -1;
	}

252
	*ref_out = ref;
253
	return 0;
254 255
}

256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
int git_reference__read_head(
	git_reference **out,
	git_repository *repo,
	const char *path)
{
	git_buf reference = GIT_BUF_INIT;
	char *name = NULL;
	int error;

	if ((error = git_futils_readbuffer(&reference, path)) < 0)
		goto out;
	git_buf_rtrim(&reference);

	if (git__strncmp(reference.ptr, GIT_SYMREF, strlen(GIT_SYMREF)) == 0) {
		git_buf_consume(&reference, reference.ptr + strlen(GIT_SYMREF));

		name = git_path_basename(path);

		if ((*out = git_reference__alloc_symbolic(name, reference.ptr)) == NULL) {
			error = -1;
			goto out;
		}
	} else {
		if ((error = git_reference_lookup(out, repo, reference.ptr)) < 0)
			goto out;
	}

out:
284
	git__free(name);
285
	git_buf_dispose(&reference);
286 287 288 289

	return error;
}

290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
int git_reference_dwim(git_reference **out, git_repository *repo, const char *refname)
{
	int error = 0, i;
	bool fallbackmode = true, foundvalid = false;
	git_reference *ref;
	git_buf refnamebuf = GIT_BUF_INIT, name = GIT_BUF_INIT;

	static const char* formatters[] = {
		"%s",
		GIT_REFS_DIR "%s",
		GIT_REFS_TAGS_DIR "%s",
		GIT_REFS_HEADS_DIR "%s",
		GIT_REFS_REMOTES_DIR "%s",
		GIT_REFS_REMOTES_DIR "%s/" GIT_HEAD_FILE,
		NULL
	};

	if (*refname)
		git_buf_puts(&name, refname);
	else {
		git_buf_puts(&name, GIT_HEAD_FILE);
		fallbackmode = false;
	}

	for (i = 0; formatters[i] && (fallbackmode || i == 0); i++) {

		git_buf_clear(&refnamebuf);

		if ((error = git_buf_printf(&refnamebuf, formatters[i], git_buf_cstr(&name))) < 0)
			goto cleanup;

		if (!git_reference_is_valid_name(git_buf_cstr(&refnamebuf))) {
			error = GIT_EINVALIDSPEC;
			continue;
		}
		foundvalid = true;

		error = git_reference_lookup_resolved(&ref, repo, git_buf_cstr(&refnamebuf), -1);

		if (!error) {
			*out = ref;
			error = 0;
			goto cleanup;
		}

		if (error != GIT_ENOTFOUND)
			goto cleanup;
	}

cleanup:
	if (error && !foundvalid) {
		/* never found a valid reference name */
342
		git_error_set(GIT_ERROR_REFERENCE,
343
			"could not use '%s' as valid reference name", git_buf_cstr(&name));
344 345
	}

346
	if (error == GIT_ENOTFOUND)
347
		git_error_set(GIT_ERROR_REFERENCE, "no reference found for shorthand '%s'", refname);
348

349 350
	git_buf_dispose(&name);
	git_buf_dispose(&refnamebuf);
351 352 353
	return error;
}

354 355 356
/**
 * Getters
 */
357
git_reference_t git_reference_type(const git_reference *ref)
Vicent Marti committed
358 359
{
	assert(ref);
360
	return ref->type;
Vicent Marti committed
361 362
}

363
const char *git_reference_name(const git_reference *ref)
Vicent Marti committed
364 365
{
	assert(ref);
366
	return ref->name;
Vicent Marti committed
367 368
}

369
git_repository *git_reference_owner(const git_reference *ref)
370
{
371
	assert(ref);
372
	return ref->db->repo;
373 374
}

375
const git_oid *git_reference_target(const git_reference *ref)
Vicent Marti committed
376 377 378
{
	assert(ref);

379
	if (ref->type != GIT_REFERENCE_DIRECT)
Vicent Marti committed
380 381
		return NULL;

382
	return &ref->target.oid;
383 384 385 386 387 388
}

const git_oid *git_reference_target_peel(const git_reference *ref)
{
	assert(ref);

389
	if (ref->type != GIT_REFERENCE_DIRECT || git_oid_iszero(&ref->peel))
390 391
		return NULL;

392
	return &ref->peel;
Vicent Marti committed
393 394
}

395
const char *git_reference_symbolic_target(const git_reference *ref)
396
{
397
	assert(ref);
398

399
	if (ref->type != GIT_REFERENCE_SYMBOLIC)
400 401
		return NULL;

402
	return ref->target.symbolic;
403 404
}

405
static int reference__create(
406 407 408
	git_reference **ref_out,
	git_repository *repo,
	const char *name,
409 410
	const git_oid *oid,
	const char *symbolic,
411 412
	int force,
	const git_signature *signature,
413
	const char *log_message,
414 415
	const git_oid *old_id,
	const char *old_target)
416
{
417
	git_refname_t normalized;
418
	git_refdb *refdb;
419
	git_reference *ref = NULL;
420
	int error = 0;
421

422
	assert(repo && name);
423
	assert(symbolic || signature);
424

425 426 427
	if (ref_out)
		*ref_out = NULL;

428
	error = reference_normalize_for_repo(normalized, repo, name, true);
Vicent Marti committed
429 430 431 432 433
	if (error < 0)
		return error;

	error = git_repository_refdb__weakptr(&refdb, repo);
	if (error < 0)
434
		return error;
435 436 437

	if (oid != NULL) {
		assert(symbolic == NULL);
438

439
		if (!git_object__is_valid(repo, oid, GIT_OBJECT_ANY)) {
440
			git_error_set(GIT_ERROR_REFERENCE,
441
				"target OID for the reference doesn't exist on the repository");
442 443 444
			return -1;
		}

445
		ref = git_reference__alloc(normalized, oid, NULL);
446
	} else {
447
		git_refname_t normalized_target;
448

449 450
		error = reference_normalize_for_repo(normalized_target, repo,
			symbolic, git_reference__enable_symbolic_ref_target_validation);
451 452

		if (error < 0)
453 454
			return error;

455
		ref = git_reference__alloc_symbolic(normalized, normalized_target);
456
	}
457

458
	GIT_ERROR_CHECK_ALLOC(ref);
459

460
	if ((error = git_refdb_write(refdb, ref, force, signature, log_message, old_id, old_target)) < 0) {
461
		git_reference_free(ref);
462
		return error;
463
	}
464

465
	if (ref_out == NULL)
466
		git_reference_free(ref);
467
	else
468
		*ref_out = ref;
469

470
	return 0;
471 472
}

473 474 475 476 477 478 479 480 481
int configured_ident(git_signature **out, const git_repository *repo)
{
	if (repo->ident_name && repo->ident_email)
		return git_signature_now(out, repo->ident_name, repo->ident_email);

	/* if not configured let us fall-through to the next method  */
	return -1;
}

482
int git_reference__log_signature(git_signature **out, git_repository *repo)
483
{
484
	int error;
485
	git_signature *who;
486

487 488
	if(((error = configured_ident(&who, repo)) < 0) &&
	   ((error = git_signature_default(&who, repo)) < 0) &&
489
	   ((error = git_signature_now(&who, "unknown", "unknown")) < 0))
490
		return error;
491

492 493
	*out = who;
	return 0;
494 495
}

496
int git_reference_create_matching(
497 498 499 500 501
	git_reference **ref_out,
	git_repository *repo,
	const char *name,
	const git_oid *id,
	int force,
502 503
	const git_oid *old_id,
	const char *log_message)
504

505
{
506 507
	int error;
	git_signature *who = NULL;
508

509
	assert(id);
510

511 512
	if ((error = git_reference__log_signature(&who, repo)) < 0)
		return error;
513 514

	error = reference__create(
515
		ref_out, repo, name, id, NULL, force, who, log_message, old_id, NULL);
Vicent Marti committed
516

517 518
	git_signature_free(who);
	return error;
519
}
520

521 522 523 524 525 526 527 528
int git_reference_create(
	git_reference **ref_out,
	git_repository *repo,
	const char *name,
	const git_oid *id,
	int force,
	const char *log_message)
{
529
        return git_reference_create_matching(ref_out, repo, name, id, force, NULL, log_message);
530 531
}

532
int git_reference_symbolic_create_matching(
533 534 535 536 537
	git_reference **ref_out,
	git_repository *repo,
	const char *name,
	const char *target,
	int force,
538 539
	const char *old_target,
	const char *log_message)
540
{
541 542 543 544 545
	int error;
	git_signature *who = NULL;

	assert(target);

546 547
	if ((error = git_reference__log_signature(&who, repo)) < 0)
		return error;
548

549
	error = reference__create(
550
		ref_out, repo, name, NULL, target, force, who, log_message, NULL, old_target);
551 552 553

	git_signature_free(who);
	return error;
554 555
}

556 557 558 559 560 561 562 563
int git_reference_symbolic_create(
	git_reference **ref_out,
	git_repository *repo,
	const char *name,
	const char *target,
	int force,
	const char *log_message)
{
564
	return git_reference_symbolic_create_matching(ref_out, repo, name, target, force, NULL, log_message);
565 566
}

567 568
static int ensure_is_an_updatable_direct_reference(git_reference *ref)
{
569
	if (ref->type == GIT_REFERENCE_DIRECT)
570
		return 0;
571

572
	git_error_set(GIT_ERROR_REFERENCE, "cannot set OID on symbolic reference");
573
	return -1;
574
}
575

576
int git_reference_set_target(
577 578
	git_reference **out,
	git_reference *ref,
579
	const git_oid *id,
580
	const char *log_message)
581 582
{
	int error;
583
	git_repository *repo;
584 585 586

	assert(out && ref && id);

587 588
	repo = ref->db->repo;

589 590 591
	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
		return error;

592
	return git_reference_create_matching(out, repo, ref->name, id, 1, &ref->target.oid, log_message);
593 594
}

595 596
static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
{
597
	if (ref->type == GIT_REFERENCE_SYMBOLIC)
598 599
		return 0;

600
	git_error_set(GIT_ERROR_REFERENCE, "cannot set symbolic target on a direct reference");
601 602 603
	return -1;
}

604 605 606
int git_reference_symbolic_set_target(
	git_reference **out,
	git_reference *ref,
607 608
	const char *target,
	const char *log_message)
Vicent Marti committed
609
{
610 611
	int error;

612
	assert(out && ref && target);
613

614 615
	if ((error = ensure_is_an_updatable_symbolic_reference(ref)) < 0)
		return error;
616

617
	return git_reference_symbolic_create_matching(
618
		out, ref->db->repo, ref->name, target, 1, ref->target.symbolic, log_message);
Vicent Marti committed
619 620
}

621 622 623 624 625 626 627 628
typedef struct {
    const char *old_name;
    git_refname_t new_name;
} rename_cb_data;

static int update_wt_heads(git_repository *repo, const char *path, void *payload)
{
	rename_cb_data *data = (rename_cb_data *) payload;
629
	git_reference *head = NULL;
630
	char *gitdir = NULL;
631 632 633
	int error;

	if ((error = git_reference__read_head(&head, repo, path)) < 0) {
634
		git_error_set(GIT_ERROR_REFERENCE, "could not read HEAD when renaming references");
635 636
		goto out;
	}
637

638 639
	if ((gitdir = git_path_dirname(path)) == NULL) {
		error = -1;
640
		goto out;
641 642
	}

643
	if (git_reference_type(head) != GIT_REFERENCE_SYMBOLIC ||
644 645 646 647
	    git__strcmp(head->target.symbolic, data->old_name) != 0) {
		error = 0;
		goto out;
	}
648 649 650

	/* Update HEAD it was pointing to the reference being renamed */
	if ((error = git_repository_create_head(gitdir, data->new_name)) < 0) {
651
		git_error_set(GIT_ERROR_REFERENCE, "failed to update HEAD after renaming reference");
652 653 654 655 656 657 658 659 660 661
		goto out;
	}

out:
	git_reference_free(head);
	git__free(gitdir);

	return error;
}

662 663
static int reference__rename(git_reference **out, git_reference *ref, const char *new_name, int force,
				 const git_signature *signature, const char *message)
664
{
665
	git_repository *repo;
666
	git_refname_t normalized;
667
	bool should_head_be_updated = false;
668
	int error = 0;
669 670

	assert(ref && new_name && signature);
671

672 673
	repo = git_reference_owner(ref);

674
	if ((error = reference_normalize_for_repo(
675
		normalized, repo, new_name, true)) < 0)
676
		return error;
677

678
	/* Check if we have to update HEAD. */
679
	if ((error = git_branch_is_head(ref)) < 0)
Vicent Marti committed
680
		return error;
681

682 683
	should_head_be_updated = (error > 0);

684
	if ((error = git_refdb_rename(out, ref->db, ref->name, normalized, force, signature, message)) < 0)
Vicent Marti committed
685
		return error;
686

687 688 689 690 691 692 693 694 695
	/* Update HEAD if it was pointing to the reference being renamed */
	if (should_head_be_updated) {
		error = git_repository_set_head(ref->db->repo, normalized);
	} else {
		rename_cb_data payload;
		payload.old_name = ref->name;
		memcpy(&payload.new_name, &normalized, sizeof(normalized));

		error = git_repository_foreach_head(repo, update_wt_heads, &payload);
696 697
	}

698
	return error;
699 700
}

701

702 703 704 705
int git_reference_rename(
	git_reference **out,
	git_reference *ref,
	const char *new_name,
706 707
	int force,
	const char *log_message)
708
{
709
	git_signature *who;
710
	int error;
711

712 713
	assert(out && ref);

714
	if ((error = git_reference__log_signature(&who, ref->db->repo)) < 0)
Vicent Marti committed
715
		return error;
716

717
	error = reference__rename(out, ref, new_name, force, who, log_message);
718
	git_signature_free(who);
719 720 721 722

	return error;
}

723
int git_reference_resolve(git_reference **ref_out, const git_reference *ref)
Vicent Marti committed
724
{
725
	switch (git_reference_type(ref)) {
726
	case GIT_REFERENCE_DIRECT:
727
		return git_reference_lookup(ref_out, ref->db->repo, ref->name);
728

729
	case GIT_REFERENCE_SYMBOLIC:
730 731 732
		return git_reference_lookup_resolved(ref_out, ref->db->repo, ref->target.symbolic, -1);

	default:
733
		git_error_set(GIT_ERROR_REFERENCE, "invalid reference");
734 735
		return -1;
	}
Vicent Marti committed
736 737
}

738 739
int git_reference_foreach(
	git_repository *repo,
740
	git_reference_foreach_cb callback,
741
	void *payload)
742
{
743
	git_reference_iterator *iter;
744
	git_reference *ref;
745 746
	int error;

747 748
	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
		return error;
749

750 751
	while (!(error = git_reference_next(&ref, iter))) {
		if ((error = callback(ref, payload)) != 0) {
752
			git_error_set_after_callback(error);
753 754 755
			break;
		}
	}
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770

	if (error == GIT_ITEROVER)
		error = 0;

	git_reference_iterator_free(iter);
	return error;
}

int git_reference_foreach_name(
	git_repository *repo,
	git_reference_foreach_name_cb callback,
	void *payload)
{
	git_reference_iterator *iter;
	const char *refname;
771 772
	int error;

773 774
	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
		return error;
775

776 777
	while (!(error = git_reference_next_name(&refname, iter))) {
		if ((error = callback(refname, payload)) != 0) {
778
			git_error_set_after_callback(error);
779 780 781
			break;
		}
	}
782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799

	if (error == GIT_ITEROVER)
		error = 0;

	git_reference_iterator_free(iter);
	return error;
}

int git_reference_foreach_glob(
	git_repository *repo,
	const char *glob,
	git_reference_foreach_name_cb callback,
	void *payload)
{
	git_reference_iterator *iter;
	const char *refname;
	int error;

800 801
	if ((error = git_reference_iterator_glob_new(&iter, repo, glob)) < 0)
		return error;
802

803 804
	while (!(error = git_reference_next_name(&refname, iter))) {
		if ((error = callback(refname, payload)) != 0) {
805
			git_error_set_after_callback(error);
806 807 808
			break;
		}
	}
809 810 811 812 813 814

	if (error == GIT_ITEROVER)
		error = 0;

	git_reference_iterator_free(iter);
	return error;
815 816
}

817 818 819 820 821 822 823
int git_reference_iterator_new(git_reference_iterator **out, git_repository *repo)
{
	git_refdb *refdb;

	if (git_repository_refdb__weakptr(&refdb, repo) < 0)
		return -1;

824
	return git_refdb_iterator(out, refdb, NULL);
825 826
}

827 828
int git_reference_iterator_glob_new(
	git_reference_iterator **out, git_repository *repo, const char *glob)
829
{
830
	git_refdb *refdb;
831

832 833 834
	if (git_repository_refdb__weakptr(&refdb, repo) < 0)
		return -1;

835
	return git_refdb_iterator(out, refdb, glob);
836 837
}

Vicent Marti committed
838
int git_reference_next(git_reference **out, git_reference_iterator *iter)
839
{
840 841 842 843 844 845
	return git_refdb_iterator_next(out, iter);
}

int git_reference_next_name(const char **out, git_reference_iterator *iter)
{
	return git_refdb_iterator_next_name(out, iter);
846 847 848 849
}

void git_reference_iterator_free(git_reference_iterator *iter)
{
850 851 852
	if (iter == NULL)
		return;

853
	git_refdb_iterator_free(iter);
854 855
}

856
static int cb__reflist_add(const char *ref, void *data)
857
{
858
	char *name = git__strdup(ref);
859
	GIT_ERROR_CHECK_ALLOC(name);
860
	return git_vector_insert((git_vector *)data, name);
861 862
}

863
int git_reference_list(
864
	git_strarray *array,
865
	git_repository *repo)
866 867 868 869 870 871 872 873
{
	git_vector ref_list;

	assert(array && repo);

	array->strings = NULL;
	array->count = 0;

874
	if (git_vector_init(&ref_list, 8, NULL) < 0)
875
		return -1;
876

877
	if (git_reference_foreach_name(
878
			repo, &cb__reflist_add, (void *)&ref_list) < 0) {
879
		git_vector_free(&ref_list);
880
		return -1;
881 882
	}

883 884
	array->strings = (char **)git_vector_detach(&array->count, NULL, &ref_list);

885
	return 0;
886
}
Vicent Marti committed
887

888
static int is_valid_ref_char(char ch)
889
{
890
	if ((unsigned) ch <= ' ')
891
		return 0;
892 893 894 895 896 897 898 899

	switch (ch) {
	case '~':
	case '^':
	case ':':
	case '\\':
	case '?':
	case '[':
900
	case '*':
901
		return 0;
902
	default:
903
		return 1;
904 905 906
	}
}

907
static int ensure_segment_validity(const char *name)
908
{
909 910
	const char *current = name;
	char prev = '\0';
911 912
	const int lock_len = (int)strlen(GIT_FILELOCK_EXTENSION);
	int segment_len;
913

914 915
	if (*current == '.')
		return -1; /* Refname starts with "." */
916

917 918 919
	for (current = name; ; current++) {
		if (*current == '\0' || *current == '/')
			break;
920

921 922
		if (!is_valid_ref_char(*current))
			return -1; /* Illegal character in refname */
923

924 925
		if (prev == '.' && *current == '.')
			return -1; /* Refname contains ".." */
926

927 928
		if (prev == '@' && *current == '{')
			return -1; /* Refname contains "@{" */
929

930 931
		prev = *current;
	}
932

933 934
	segment_len = (int)(current - name);

935
	/* A refname component can not end with ".lock" */
936
	if (segment_len >= lock_len &&
937
		!memcmp(current - lock_len, GIT_FILELOCK_EXTENSION, lock_len))
938 939
			return -1;

940
	return segment_len;
941
}
942

943
static bool is_all_caps_and_underscore(const char *name, size_t len)
944
{
945
	size_t i;
946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
	char c;

	assert(name && len > 0);

	for (i = 0; i < len; i++)
	{
		c = name[i];
		if ((c < 'A' || c > 'Z') && c != '_')
			return false;
	}

	if (*name == '_' || name[len - 1] == '_')
		return false;

	return true;
}

963
/* Inspired from https://github.com/git/git/blob/f06d47e7e0d9db709ee204ed13a8a7486149f494/refs.c#L36-100 */
964 965 966 967 968
int git_reference__normalize_name(
	git_buf *buf,
	const char *name,
	unsigned int flags)
{
969
	const char *current;
970
	int segment_len, segments_count = 0, error = GIT_EINVALIDSPEC;
971 972
	unsigned int process_flags;
	bool normalize = (buf != NULL);
973
	bool validate = (flags & GIT_REFERENCE_FORMAT__VALIDATION_DISABLE) == 0;
974 975

#ifdef GIT_USE_ICONV
976
	git_path_iconv_t ic = GIT_PATH_ICONV_INIT;
977
#endif
978

979
	assert(name);
980

981
	process_flags = flags;
982 983
	current = (char *)name;

984
	if (validate && *current == '/')
985 986
		goto cleanup;

987 988
	if (normalize)
		git_buf_clear(buf);
989

990
#ifdef GIT_USE_ICONV
991
	if ((flags & GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE) != 0) {
992 993 994 995
		size_t namelen = strlen(current);
		if ((error = git_path_iconv_init_precompose(&ic)) < 0 ||
			(error = git_path_iconv(&ic, &current, &namelen)) < 0)
			goto cleanup;
996
		error = GIT_EINVALIDSPEC;
997
	}
998
#endif
999

1000 1001 1002 1003 1004 1005 1006
	if (!validate) {
		git_buf_sets(buf, current);

		error = git_buf_oom(buf) ? -1 : 0;
		goto cleanup;
	}

1007 1008 1009
	while (true) {
		segment_len = ensure_segment_validity(current);
		if (segment_len < 0) {
1010
			if ((process_flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN) &&
1011 1012 1013
					current[0] == '*' &&
					(current[1] == '\0' || current[1] == '/')) {
				/* Accept one wildcard as a full refname component. */
1014
				process_flags &= ~GIT_REFERENCE_FORMAT_REFSPEC_PATTERN;
1015 1016 1017 1018
				segment_len = 1;
			} else
				goto cleanup;
		}
1019

1020
		if (segment_len > 0) {
1021
			if (normalize) {
1022
				size_t cur_len = git_buf_len(buf);
1023

1024
				git_buf_joinpath(buf, git_buf_cstr(buf), current);
1025
				git_buf_truncate(buf,
1026
					cur_len + segment_len + (segments_count ? 1 : 0));
1027

1028 1029
				if (git_buf_oom(buf)) {
					error = -1;
1030
					goto cleanup;
1031
				}
1032
			}
1033

1034
			segments_count++;
1035
		}
1036

1037 1038
		/* No empty segment is allowed when not normalizing */
		if (segment_len == 0 && !normalize)
1039
			goto cleanup;
1040

1041 1042
		if (current[segment_len] == '\0')
			break;
1043

1044
		current += segment_len + 1;
1045
	}
1046

1047
	/* A refname can not be empty */
1048
	if (segment_len == 0 && segments_count == 0)
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
		goto cleanup;

	/* A refname can not end with "." */
	if (current[segment_len - 1] == '.')
		goto cleanup;

	/* A refname can not end with "/" */
	if (current[segment_len - 1] == '/')
		goto cleanup;

1059
	if ((segments_count == 1 ) && !(flags & GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL))
1060 1061 1062
		goto cleanup;

	if ((segments_count == 1 ) &&
1063
	    !(flags & GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND) &&
1064
		!(is_all_caps_and_underscore(name, (size_t)segment_len) ||
1065
			((flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN) && !strcmp("*", name))))
1066 1067 1068 1069 1070
			goto cleanup;

	if ((segments_count > 1)
		&& (is_all_caps_and_underscore(name, strchr(name, '/') - name)))
			goto cleanup;
1071

1072
	error = 0;
1073

1074
cleanup:
1075
	if (error == GIT_EINVALIDSPEC)
1076 1077
		git_error_set(
			GIT_ERROR_REFERENCE,
1078
			"the given reference name '%s' is not valid", name);
1079

1080
	if (error && normalize)
1081
		git_buf_dispose(buf);
1082

1083
#ifdef GIT_USE_ICONV
1084
	git_path_iconv_clear(&ic);
1085
#endif
1086

1087 1088
	return error;
}
1089

1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
int git_reference_normalize_name(
	char *buffer_out,
	size_t buffer_size,
	const char *name,
	unsigned int flags)
{
	git_buf buf = GIT_BUF_INIT;
	int error;

	if ((error = git_reference__normalize_name(&buf, name, flags)) < 0)
		goto cleanup;

	if (git_buf_len(&buf) > buffer_size - 1) {
1103 1104
		git_error_set(
		GIT_ERROR_REFERENCE,
1105
		"the provided buffer is too short to hold the normalization of '%s'", name);
1106 1107 1108 1109 1110 1111 1112 1113 1114
		error = GIT_EBUFS;
		goto cleanup;
	}

	git_buf_copy_cstr(buffer_out, buffer_size, &buf);

	error = 0;

cleanup:
1115
	git_buf_dispose(&buf);
1116
	return error;
1117
}
1118

1119
#define GIT_REFERENCE_TYPEMASK (GIT_REFERENCE_DIRECT | GIT_REFERENCE_SYMBOLIC)
1120

Jacques Germishuys committed
1121 1122 1123
int git_reference_cmp(
	const git_reference *ref1,
	const git_reference *ref2)
1124
{
1125
	git_reference_t type1, type2;
1126 1127
	assert(ref1 && ref2);

1128 1129 1130
	type1 = git_reference_type(ref1);
	type2 = git_reference_type(ref2);

1131
	/* let's put symbolic refs before OIDs */
1132
	if (type1 != type2)
1133
		return (type1 == GIT_REFERENCE_SYMBOLIC) ? -1 : 1;
1134

1135
	if (type1 == GIT_REFERENCE_SYMBOLIC)
1136 1137
		return strcmp(ref1->target.symbolic, ref2->target.symbolic);

1138
	return git_oid__cmp(&ref1->target.oid, &ref2->target.oid);
1139 1140
}

1141 1142 1143 1144 1145
/**
 * Get the end of a chain of references. If the final one is not
 * found, we return the reference just before that.
 */
static int get_terminal(git_reference **out, git_repository *repo, const char *ref_name, int nesting)
nulltoken committed
1146 1147
{
	git_reference *ref;
1148
	int error = 0;
nulltoken committed
1149

1150
	if (nesting > MAX_NESTING_LEVEL) {
1151
		git_error_set(GIT_ERROR_REFERENCE, "reference chain too deep (%d)", nesting);
1152
		return GIT_ENOTFOUND;
1153
	}
1154

1155 1156 1157
	/* set to NULL to let the caller know that they're at the end of the chain */
	if ((error = git_reference_lookup(&ref, repo, ref_name)) < 0) {
		*out = NULL;
1158
		return error;
1159
	}
1160

1161
	if (git_reference_type(ref) == GIT_REFERENCE_DIRECT) {
1162 1163
		*out = ref;
		error = 0;
1164
	} else {
1165
		error = get_terminal(out, repo, git_reference_symbolic_target(ref), nesting + 1);
Edward Thomson committed
1166 1167 1168
		if (error == GIT_ENOTFOUND && !*out)
			*out = ref;
		else
1169
			git_reference_free(ref);
nulltoken committed
1170
	}
1171

1172
	return error;
nulltoken committed
1173
}
1174

1175 1176 1177 1178 1179 1180 1181 1182
/*
 * Starting with the reference given by `ref_name`, follows symbolic
 * references until a direct reference is found and updated the OID
 * on that direct reference to `oid`.
 */
int git_reference__update_terminal(
	git_repository *repo,
	const char *ref_name,
1183
	const git_oid *oid,
1184
	const git_signature *sig,
1185
	const char *log_message)
1186
{
1187
	git_reference *ref = NULL, *ref2 = NULL;
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
	git_signature *who = NULL;
	const git_signature *to_use;
	int error = 0;

	if (!sig && (error = git_reference__log_signature(&who, repo)) < 0)
		return error;

	to_use = sig ? sig : who;
	error = get_terminal(&ref, repo, ref_name, 0);

	/* found a dangling symref */
	if (error == GIT_ENOTFOUND && ref) {
1200
		assert(git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC);
1201
		git_error_clear();
1202
		error = reference__create(&ref2, repo, ref->target.symbolic, oid, NULL, 0, to_use,
1203 1204
					  log_message, NULL, NULL);
	} else if (error == GIT_ENOTFOUND) {
1205
		git_error_clear();
1206
		error = reference__create(&ref2, repo, ref_name, oid, NULL, 0, to_use,
1207 1208
					  log_message, NULL, NULL);
	}  else if (error == 0) {
1209
		assert(git_reference_type(ref) == GIT_REFERENCE_DIRECT);
1210
		error = reference__create(&ref2, repo, ref->name, oid, NULL, 1, to_use,
1211 1212 1213
					  log_message, &ref->target.oid, NULL);
	}

1214 1215
	git_reference_free(ref2);
	git_reference_free(ref);
1216 1217
	git_signature_free(who);
	return error;
1218 1219
}

1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231
static const char *commit_type(const git_commit *commit)
{
	unsigned int count = git_commit_parentcount(commit);

	if (count >= 2)
		return " (merge)";
	else if (count == 0)
		return " (initial)";
	else
		return "";
}

1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
int git_reference__update_for_commit(
	git_repository *repo,
	git_reference *ref,
	const char *ref_name,
	const git_oid *id,
	const char *operation)
{
	git_reference *ref_new = NULL;
	git_commit *commit = NULL;
	git_buf reflog_msg = GIT_BUF_INIT;
1242
	const git_signature *who;
1243 1244 1245 1246 1247
	int error;

	if ((error = git_commit_lookup(&commit, repo, id)) < 0 ||
		(error = git_buf_printf(&reflog_msg, "%s%s: %s",
			operation ? operation : "commit",
1248
			commit_type(commit),
1249 1250 1251
			git_commit_summary(commit))) < 0)
		goto done;

1252 1253 1254 1255 1256 1257 1258 1259 1260
	who = git_commit_committer(commit);

	if (ref) {
		if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
			return error;

		error = reference__create(&ref_new, repo, ref->name, id, NULL, 1, who,
					  git_buf_cstr(&reflog_msg), &ref->target.oid, NULL);
	}
1261 1262
	else
		error = git_reference__update_terminal(
1263
			repo, ref_name, id, who, git_buf_cstr(&reflog_msg));
1264 1265 1266

done:
	git_reference_free(ref_new);
1267
	git_buf_dispose(&reflog_msg);
1268 1269 1270 1271
	git_commit_free(commit);
	return error;
}

1272
int git_reference_has_log(git_repository *repo, const char *refname)
1273
{
1274 1275
	int error;
	git_refdb *refdb;
1276

1277
	assert(repo && refname);
1278

1279 1280
	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
		return error;
1281

1282
	return git_refdb_has_log(refdb, refname);
1283
}
1284

1285 1286 1287 1288 1289 1290 1291 1292 1293
int git_reference_ensure_log(git_repository *repo, const char *refname)
{
	int error;
	git_refdb *refdb;

	assert(repo && refname);

	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
		return error;
1294

1295
	return git_refdb_ensure_log(refdb, refname);
1296
}
1297

1298 1299 1300 1301 1302
int git_reference__is_branch(const char *ref_name)
{
	return git__prefixcmp(ref_name, GIT_REFS_HEADS_DIR) == 0;
}

1303
int git_reference_is_branch(const git_reference *ref)
1304 1305
{
	assert(ref);
1306
	return git_reference__is_branch(ref->name);
1307
}
1308

1309 1310 1311 1312 1313
int git_reference__is_remote(const char *ref_name)
{
	return git__prefixcmp(ref_name, GIT_REFS_REMOTES_DIR) == 0;
}

Jacques Germishuys committed
1314
int git_reference_is_remote(const git_reference *ref)
1315 1316
{
	assert(ref);
1317
	return git_reference__is_remote(ref->name);
1318
}
1319

1320 1321 1322 1323 1324
int git_reference__is_tag(const char *ref_name)
{
	return git__prefixcmp(ref_name, GIT_REFS_TAGS_DIR) == 0;
}

Jacques Germishuys committed
1325
int git_reference_is_tag(const git_reference *ref)
1326 1327 1328 1329 1330
{
	assert(ref);
	return git_reference__is_tag(ref->name);
}

1331 1332 1333 1334 1335
int git_reference__is_note(const char *ref_name)
{
	return git__prefixcmp(ref_name, GIT_REFS_NOTES_DIR) == 0;
}

Jacques Germishuys committed
1336
int git_reference_is_note(const git_reference *ref)
1337 1338 1339 1340 1341
{
	assert(ref);
	return git_reference__is_note(ref->name);
}

1342
static int peel_error(int error, const git_reference *ref, const char* msg)
1343
{
1344 1345
	git_error_set(
		GIT_ERROR_INVALID,
1346
		"the reference '%s' cannot be peeled - %s", git_reference_name(ref), msg);
1347 1348 1349 1350
	return error;
}

int git_reference_peel(
1351
	git_object **peeled,
1352
	const git_reference *ref,
1353
	git_object_t target_type)
1354
{
1355 1356
	const git_reference *resolved = NULL;
	git_reference *allocated = NULL;
1357 1358 1359 1360 1361
	git_object *target = NULL;
	int error;

	assert(ref);

1362
	if (ref->type == GIT_REFERENCE_DIRECT) {
1363 1364
		resolved = ref;
	} else {
1365
		if ((error = git_reference_resolve(&allocated, ref)) < 0)
1366
			return peel_error(error, ref, "Cannot resolve reference");
1367 1368

		resolved = allocated;
1369 1370
	}

1371 1372 1373 1374 1375 1376
	/*
	 * If we try to peel an object to a tag, we cannot use
	 * the fully peeled object, as that will always resolve
	 * to a commit. So we only want to use the peeled value
	 * if it is not zero and the target is not a tag.
	 */
1377
	if (target_type != GIT_OBJECT_TAG && !git_oid_iszero(&resolved->peel)) {
1378
		error = git_object_lookup(&target,
1379
			git_reference_owner(ref), &resolved->peel, GIT_OBJECT_ANY);
1380 1381
	} else {
		error = git_object_lookup(&target,
1382
			git_reference_owner(ref), &resolved->target.oid, GIT_OBJECT_ANY);
1383
	}
1384

1385
	if (error < 0) {
1386 1387 1388
		peel_error(error, ref, "Cannot retrieve reference target");
		goto cleanup;
	}
1389

1390
	if (target_type == GIT_OBJECT_ANY && git_object_type(target) != GIT_OBJECT_TAG)
1391
		error = git_object_dup(peeled, target);
1392
	else
1393 1394 1395 1396
		error = git_object_peel(peeled, target, target_type);

cleanup:
	git_object_free(target);
1397
	git_reference_free(allocated);
1398

1399 1400
	return error;
}
1401

1402
int git_reference__is_valid_name(const char *refname, unsigned int flags)
1403
{
1404
	if (git_reference__normalize_name(NULL, refname, flags) < 0) {
1405
		git_error_clear();
1406 1407
		return false;
	}
nulltoken committed
1408

1409
	return true;
1410 1411
}

1412
int git_reference_is_valid_name(const char *refname)
1413
{
1414
	return git_reference__is_valid_name(refname, GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL);
1415
}
1416

1417
const char *git_reference__shorthand(const char *name)
1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
{
	if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR))
		return name + strlen(GIT_REFS_HEADS_DIR);
	else if (!git__prefixcmp(name, GIT_REFS_TAGS_DIR))
		return name + strlen(GIT_REFS_TAGS_DIR);
	else if (!git__prefixcmp(name, GIT_REFS_REMOTES_DIR))
		return name + strlen(GIT_REFS_REMOTES_DIR);
	else if (!git__prefixcmp(name, GIT_REFS_DIR))
		return name + strlen(GIT_REFS_DIR);

	/* No shorthands are avaiable, so just return the name */
	return name;
}
1431 1432 1433 1434 1435

const char *git_reference_shorthand(const git_reference *ref)
{
	return git_reference__shorthand(ref->name);
}
1436 1437 1438 1439 1440 1441 1442

int git_reference__is_unborn_head(bool *unborn, const git_reference *ref, git_repository *repo)
{
	int error;
	git_reference *tmp_ref;
	assert(unborn && ref && repo);

1443
	if (ref->type == GIT_REFERENCE_DIRECT) {
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
		*unborn = 0;
		return 0;
	}

	error = git_reference_lookup_resolved(&tmp_ref, repo, ref->name, -1);
	git_reference_free(tmp_ref);

	if (error != 0 && error != GIT_ENOTFOUND)
		return error;
	else if (error == GIT_ENOTFOUND && git__strcmp(ref->name, GIT_HEAD_FILE) == 0)
		*unborn = true;
	else
		*unborn = false;

	return 0;
}