refs.c 30.9 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_REF_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 85
	if (!ref)
		return NULL;

	ref->type = GIT_REF_OID;
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 111 112 113 114 115 116 117 118 119 120
int git_reference_dup(git_reference **dest, git_reference *source)
{
	if (source->type == GIT_REF_SYMBOLIC)
		*dest = git_reference__alloc_symbolic(source->name, source->target.symbolic);
	else
		*dest = git_reference__alloc(source->name, &source->target.oid, &source->peel);

	GITERR_CHECK_ALLOC(*dest);

	return 0;
}

121
void git_reference_free(git_reference *reference)
122
{
123 124
	if (reference == NULL)
		return;
125

126
	if (reference->type == GIT_REF_SYMBOLIC)
127
		git__free(reference->target.symbolic);
128

Vicent Marti committed
129 130
	if (reference->db)
		GIT_REFCOUNT_DEC(reference->db, git_refdb__free);
131 132

	git__free(reference);
133
}
134

135
int git_reference_delete(git_reference *ref)
136
{
137 138 139 140 141 142 143 144 145
	const git_oid *old_id = NULL;
	const char *old_target = NULL;

	if (ref->type == GIT_REF_OID)
		old_id = &ref->target.oid;
	else
		old_target = ref->target.symbolic;

	return git_refdb_delete(ref->db, ref->name, old_id, old_target);
146 147
}

148 149 150 151 152 153 154 155 156 157 158
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);
}

159
int git_reference_lookup(git_reference **ref_out,
160
	git_repository *repo, const char *name)
161
{
162 163 164
	return git_reference_lookup_resolved(ref_out, repo, name, 0);
}

165
int git_reference_name_to_id(
166 167 168 169 170 171 172 173
	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;

174
	git_oid_cpy(out, git_reference_target(ref));
175 176 177 178
	git_reference_free(ref);
	return 0;
}

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

	if (!git_repository__cvar(&precompose, repo, GIT_CVAR_PRECOMPOSE) &&
		precompose)
		flags |= GIT_REF_FORMAT__PRECOMPOSE_UNICODE;

192 193
	if (!validate)
		flags |= GIT_REF_FORMAT__VALIDATION_DISABLE;
194

195
	return git_reference_normalize_name(out, GIT_REFNAME_MAX, name, flags);
196 197
}

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

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

212
	*ref_out = NULL;
213

214 215 216 217
	if (max_nesting > MAX_NESTING_LEVEL)
		max_nesting = MAX_NESTING_LEVEL;
	else if (max_nesting < 0)
		max_nesting = DEFAULT_NESTING_LEVEL;
218

219
	scan_type = GIT_REF_SYMBOLIC;
220

221
	if ((error = reference_normalize_for_repo(scan_name, repo, name, true)) < 0)
222
		return error;
223

224
	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
225
		return error;
226 227

	for (nesting = max_nesting;
228
		 nesting >= 0 && scan_type == GIT_REF_SYMBOLIC;
229 230
		 nesting--)
	{
231
		if (nesting != max_nesting) {
232
			strncpy(scan_name, ref->target.symbolic, sizeof(scan_name));
233 234
			git_reference_free(ref);
		}
235

236 237
		if ((error = git_refdb_lookup(&ref, refdb, scan_name)) < 0)
			return error;
238

239
		scan_type = ref->type;
240 241
	}

242
	if (scan_type != GIT_REF_OID && max_nesting != 0) {
243
		giterr_set(GITERR_REFERENCE,
244
			"cannot resolve reference (>%u levels deep)", max_nesting);
245
		git_reference_free(ref);
246 247 248
		return -1;
	}

249
	*ref_out = ref;
250
	return 0;
251 252
}

253 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
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:
281 282
	git__free(name);
	git_buf_free(&reference);
283 284 285 286

	return error;
}

287 288 289 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
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 */
		giterr_set(GITERR_REFERENCE,
340
			"could not use '%s' as valid reference name", git_buf_cstr(&name));
341 342
	}

343 344 345
	if (error == GIT_ENOTFOUND)
		giterr_set(GITERR_REFERENCE, "no reference found for shorthand '%s'", refname);

346 347 348 349 350
	git_buf_free(&name);
	git_buf_free(&refnamebuf);
	return error;
}

351 352 353
/**
 * Getters
 */
354
git_ref_t git_reference_type(const git_reference *ref)
Vicent Marti committed
355 356
{
	assert(ref);
357
	return ref->type;
Vicent Marti committed
358 359
}

360
const char *git_reference_name(const git_reference *ref)
Vicent Marti committed
361 362
{
	assert(ref);
363
	return ref->name;
Vicent Marti committed
364 365
}

366
git_repository *git_reference_owner(const git_reference *ref)
367
{
368
	assert(ref);
369
	return ref->db->repo;
370 371
}

372
const git_oid *git_reference_target(const git_reference *ref)
Vicent Marti committed
373 374 375
{
	assert(ref);

376
	if (ref->type != GIT_REF_OID)
Vicent Marti committed
377 378
		return NULL;

379
	return &ref->target.oid;
380 381 382 383 384 385
}

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

386
	if (ref->type != GIT_REF_OID || git_oid_iszero(&ref->peel))
387 388
		return NULL;

389
	return &ref->peel;
Vicent Marti committed
390 391
}

392
const char *git_reference_symbolic_target(const git_reference *ref)
393
{
394
	assert(ref);
395

396
	if (ref->type != GIT_REF_SYMBOLIC)
397 398
		return NULL;

399
	return ref->target.symbolic;
400 401
}

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

419
	assert(repo && name);
420
	assert(symbolic || signature);
421

422 423 424
	if (ref_out)
		*ref_out = NULL;

425
	error = reference_normalize_for_repo(normalized, repo, name, true);
Vicent Marti committed
426 427 428 429 430
	if (error < 0)
		return error;

	error = git_repository_refdb__weakptr(&refdb, repo);
	if (error < 0)
431
		return error;
432 433 434

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

436
		if (!git_object__is_valid(repo, oid, GIT_OBJ_ANY)) {
437
			giterr_set(GITERR_REFERENCE,
438
				"target OID for the reference doesn't exist on the repository");
439 440 441
			return -1;
		}

442
		ref = git_reference__alloc(normalized, oid, NULL);
443
	} else {
444
		git_refname_t normalized_target;
445

446 447
		error = reference_normalize_for_repo(normalized_target, repo,
			symbolic, git_reference__enable_symbolic_ref_target_validation);
448 449

		if (error < 0)
450 451
			return error;

452
		ref = git_reference__alloc_symbolic(normalized, normalized_target);
453
	}
454

455
	GITERR_CHECK_ALLOC(ref);
456

457
	if ((error = git_refdb_write(refdb, ref, force, signature, log_message, old_id, old_target)) < 0) {
458
		git_reference_free(ref);
459
		return error;
460
	}
461

462
	if (ref_out == NULL)
463
		git_reference_free(ref);
464
	else
465
		*ref_out = ref;
466

467
	return 0;
468 469
}

470 471 472 473 474 475 476 477 478
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;
}

479
int git_reference__log_signature(git_signature **out, git_repository *repo)
480
{
481
	int error;
482
	git_signature *who;
483

484 485
	if(((error = configured_ident(&who, repo)) < 0) &&
	   ((error = git_signature_default(&who, repo)) < 0) &&
486
	   ((error = git_signature_now(&who, "unknown", "unknown")) < 0))
487
		return error;
488

489 490
	*out = who;
	return 0;
491 492
}

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

502
{
503 504
	int error;
	git_signature *who = NULL;
505

506
	assert(id);
507

508 509
	if ((error = git_reference__log_signature(&who, repo)) < 0)
		return error;
510 511

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

514 515
	git_signature_free(who);
	return error;
516
}
517

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

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

	assert(target);

543 544
	if ((error = git_reference__log_signature(&who, repo)) < 0)
		return error;
545

546
	error = reference__create(
547
		ref_out, repo, name, NULL, target, force, who, log_message, NULL, old_target);
548 549 550

	git_signature_free(who);
	return error;
551 552
}

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

564 565 566 567
static int ensure_is_an_updatable_direct_reference(git_reference *ref)
{
	if (ref->type == GIT_REF_OID)
		return 0;
568

569
	giterr_set(GITERR_REFERENCE, "cannot set OID on symbolic reference");
570
	return -1;
571
}
572

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

	assert(out && ref && id);

584 585
	repo = ref->db->repo;

586 587 588
	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
		return error;

589
	return git_reference_create_matching(out, repo, ref->name, id, 1, &ref->target.oid, log_message);
590 591
}

592 593 594 595 596
static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
{
	if (ref->type == GIT_REF_SYMBOLIC)
		return 0;

597
	giterr_set(GITERR_REFERENCE, "cannot set symbolic target on a direct reference");
598 599 600
	return -1;
}

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

609
	assert(out && ref && target);
610

611 612
	if ((error = ensure_is_an_updatable_symbolic_reference(ref)) < 0)
		return error;
613

614
	return git_reference_symbolic_create_matching(
615
		out, ref->db->repo, ref->name, target, 1, ref->target.symbolic, log_message);
Vicent Marti committed
616 617
}

618 619 620 621 622 623 624 625
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;
626
	git_reference *head = NULL;
627
	char *gitdir = NULL;
628 629 630 631 632 633
	int error;

	if ((error = git_reference__read_head(&head, repo, path)) < 0) {
		giterr_set(GITERR_REFERENCE, "could not read HEAD when renaming references");
		goto out;
	}
634

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

	if (git_reference_type(head) != GIT_REF_SYMBOLIC ||
	    git__strcmp(head->target.symbolic, data->old_name) != 0) {
		error = 0;
		goto out;
	}
645 646 647 648 649 650 651 652 653 654 655 656 657 658

	/* Update HEAD it was pointing to the reference being renamed */
	if ((error = git_repository_create_head(gitdir, data->new_name)) < 0) {
		giterr_set(GITERR_REFERENCE, "failed to update HEAD after renaming reference");
		goto out;
	}

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

	return error;
}

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

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

669 670
	repo = git_reference_owner(ref);

671
	if ((error = reference_normalize_for_repo(
672
		normalized, repo, new_name, true)) < 0)
673
		return error;
674

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

679 680
	should_head_be_updated = (error > 0);

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

684 685 686 687 688 689 690 691 692
	/* 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);
693 694
	}

695
	return error;
696 697
}

698

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

709
	if ((error = git_reference__log_signature(&who, ref->db->repo)) < 0)
Vicent Marti committed
710
		return error;
711

712
	error = reference__rename(out, ref, new_name, force, who, log_message);
713
	git_signature_free(who);
714 715 716 717

	return error;
}

718
int git_reference_resolve(git_reference **ref_out, const git_reference *ref)
Vicent Marti committed
719
{
720 721
	switch (git_reference_type(ref)) {
	case GIT_REF_OID:
722
		return git_reference_lookup(ref_out, ref->db->repo, ref->name);
723

724 725 726 727
	case GIT_REF_SYMBOLIC:
		return git_reference_lookup_resolved(ref_out, ref->db->repo, ref->target.symbolic, -1);

	default:
728
		giterr_set(GITERR_REFERENCE, "invalid reference");
729 730
		return -1;
	}
Vicent Marti committed
731 732
}

733 734
int git_reference_foreach(
	git_repository *repo,
735
	git_reference_foreach_cb callback,
736
	void *payload)
737
{
738
	git_reference_iterator *iter;
739
	git_reference *ref;
740 741
	int error;

742 743
	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
		return error;
744

745 746
	while (!(error = git_reference_next(&ref, iter))) {
		if ((error = callback(ref, payload)) != 0) {
747
			giterr_set_after_callback(error);
748 749 750
			break;
		}
	}
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765

	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;
766 767
	int error;

768 769
	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
		return error;
770

771 772
	while (!(error = git_reference_next_name(&refname, iter))) {
		if ((error = callback(refname, payload)) != 0) {
773
			giterr_set_after_callback(error);
774 775 776
			break;
		}
	}
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794

	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;

795 796
	if ((error = git_reference_iterator_glob_new(&iter, repo, glob)) < 0)
		return error;
797

798 799
	while (!(error = git_reference_next_name(&refname, iter))) {
		if ((error = callback(refname, payload)) != 0) {
800
			giterr_set_after_callback(error);
801 802 803
			break;
		}
	}
804 805 806 807 808 809

	if (error == GIT_ITEROVER)
		error = 0;

	git_reference_iterator_free(iter);
	return error;
810 811
}

812 813 814 815 816 817 818
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;

819
	return git_refdb_iterator(out, refdb, NULL);
820 821
}

822 823
int git_reference_iterator_glob_new(
	git_reference_iterator **out, git_repository *repo, const char *glob)
824
{
825
	git_refdb *refdb;
826

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

830
	return git_refdb_iterator(out, refdb, glob);
831 832
}

Vicent Marti committed
833
int git_reference_next(git_reference **out, git_reference_iterator *iter)
834
{
835 836 837 838 839 840
	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);
841 842 843 844
}

void git_reference_iterator_free(git_reference_iterator *iter)
{
845 846 847
	if (iter == NULL)
		return;

848
	git_refdb_iterator_free(iter);
849 850
}

851
static int cb__reflist_add(const char *ref, void *data)
852
{
853 854 855
	char *name = git__strdup(ref);
	GITERR_CHECK_ALLOC(name);
	return git_vector_insert((git_vector *)data, name);
856 857
}

858
int git_reference_list(
859
	git_strarray *array,
860
	git_repository *repo)
861 862 863 864 865 866 867 868
{
	git_vector ref_list;

	assert(array && repo);

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

869
	if (git_vector_init(&ref_list, 8, NULL) < 0)
870
		return -1;
871

872
	if (git_reference_foreach_name(
873
			repo, &cb__reflist_add, (void *)&ref_list) < 0) {
874
		git_vector_free(&ref_list);
875
		return -1;
876 877
	}

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

880
	return 0;
881
}
Vicent Marti committed
882

883
static int is_valid_ref_char(char ch)
884
{
885
	if ((unsigned) ch <= ' ')
886
		return 0;
887 888 889 890 891 892 893 894

	switch (ch) {
	case '~':
	case '^':
	case ':':
	case '\\':
	case '?':
	case '[':
895
	case '*':
896
		return 0;
897
	default:
898
		return 1;
899 900 901
	}
}

902
static int ensure_segment_validity(const char *name)
903
{
904 905
	const char *current = name;
	char prev = '\0';
906 907
	const int lock_len = (int)strlen(GIT_FILELOCK_EXTENSION);
	int segment_len;
908

909 910
	if (*current == '.')
		return -1; /* Refname starts with "." */
911

912 913 914
	for (current = name; ; current++) {
		if (*current == '\0' || *current == '/')
			break;
915

916 917
		if (!is_valid_ref_char(*current))
			return -1; /* Illegal character in refname */
918

919 920
		if (prev == '.' && *current == '.')
			return -1; /* Refname contains ".." */
921

922 923
		if (prev == '@' && *current == '{')
			return -1; /* Refname contains "@{" */
924

925 926
		prev = *current;
	}
927

928 929
	segment_len = (int)(current - name);

930
	/* A refname component can not end with ".lock" */
931
	if (segment_len >= lock_len &&
932
		!memcmp(current - lock_len, GIT_FILELOCK_EXTENSION, lock_len))
933 934
			return -1;

935
	return segment_len;
936
}
937

938
static bool is_all_caps_and_underscore(const char *name, size_t len)
939
{
940
	size_t i;
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957
	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;
}

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

#ifdef GIT_USE_ICONV
971
	git_path_iconv_t ic = GIT_PATH_ICONV_INIT;
972
#endif
973

974
	assert(name);
975

976
	process_flags = flags;
977 978
	current = (char *)name;

979
	if (validate && *current == '/')
980 981
		goto cleanup;

982 983
	if (normalize)
		git_buf_clear(buf);
984

985
#ifdef GIT_USE_ICONV
986 987 988 989 990
	if ((flags & GIT_REF_FORMAT__PRECOMPOSE_UNICODE) != 0) {
		size_t namelen = strlen(current);
		if ((error = git_path_iconv_init_precompose(&ic)) < 0 ||
			(error = git_path_iconv(&ic, &current, &namelen)) < 0)
			goto cleanup;
991
		error = GIT_EINVALIDSPEC;
992
	}
993
#endif
994

995 996 997 998 999 1000 1001
	if (!validate) {
		git_buf_sets(buf, current);

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

1002 1003 1004
	while (true) {
		segment_len = ensure_segment_validity(current);
		if (segment_len < 0) {
1005
			if ((process_flags & GIT_REF_FORMAT_REFSPEC_PATTERN) &&
1006 1007 1008
					current[0] == '*' &&
					(current[1] == '\0' || current[1] == '/')) {
				/* Accept one wildcard as a full refname component. */
1009
				process_flags &= ~GIT_REF_FORMAT_REFSPEC_PATTERN;
1010 1011 1012 1013
				segment_len = 1;
			} else
				goto cleanup;
		}
1014

1015
		if (segment_len > 0) {
1016
			if (normalize) {
1017
				size_t cur_len = git_buf_len(buf);
1018

1019
				git_buf_joinpath(buf, git_buf_cstr(buf), current);
1020
				git_buf_truncate(buf,
1021
					cur_len + segment_len + (segments_count ? 1 : 0));
1022

1023 1024
				if (git_buf_oom(buf)) {
					error = -1;
1025
					goto cleanup;
1026
				}
1027
			}
1028

1029
			segments_count++;
1030
		}
1031

1032 1033
		/* No empty segment is allowed when not normalizing */
		if (segment_len == 0 && !normalize)
1034
			goto cleanup;
1035

1036 1037
		if (current[segment_len] == '\0')
			break;
1038

1039
		current += segment_len + 1;
1040
	}
1041

1042
	/* A refname can not be empty */
1043
	if (segment_len == 0 && segments_count == 0)
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
		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;

1054 1055 1056 1057
	if ((segments_count == 1 ) && !(flags & GIT_REF_FORMAT_ALLOW_ONELEVEL))
		goto cleanup;

	if ((segments_count == 1 ) &&
1058
	    !(flags & GIT_REF_FORMAT_REFSPEC_SHORTHAND) &&
1059
		!(is_all_caps_and_underscore(name, (size_t)segment_len) ||
1060 1061 1062 1063 1064 1065
			((flags & GIT_REF_FORMAT_REFSPEC_PATTERN) && !strcmp("*", name))))
			goto cleanup;

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

1067
	error = 0;
1068

1069
cleanup:
1070
	if (error == GIT_EINVALIDSPEC)
1071 1072
		giterr_set(
			GITERR_REFERENCE,
1073
			"the given reference name '%s' is not valid", name);
1074

1075 1076 1077
	if (error && normalize)
		git_buf_free(buf);

1078
#ifdef GIT_USE_ICONV
1079
	git_path_iconv_clear(&ic);
1080
#endif
1081

1082 1083
	return error;
}
1084

1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
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) {
		giterr_set(
1099
		GITERR_REFERENCE,
1100
		"the provided buffer is too short to hold the normalization of '%s'", name);
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
		error = GIT_EBUFS;
		goto cleanup;
	}

	git_buf_copy_cstr(buffer_out, buffer_size, &buf);

	error = 0;

cleanup:
	git_buf_free(&buf);
	return error;
1112
}
1113

1114 1115
#define GIT_REF_TYPEMASK (GIT_REF_OID | GIT_REF_SYMBOLIC)

Jacques Germishuys committed
1116 1117 1118
int git_reference_cmp(
	const git_reference *ref1,
	const git_reference *ref2)
1119
{
1120
	git_ref_t type1, type2;
1121 1122
	assert(ref1 && ref2);

1123 1124 1125
	type1 = git_reference_type(ref1);
	type2 = git_reference_type(ref2);

1126
	/* let's put symbolic refs before OIDs */
1127 1128
	if (type1 != type2)
		return (type1 == GIT_REF_SYMBOLIC) ? -1 : 1;
1129

1130
	if (type1 == GIT_REF_SYMBOLIC)
1131 1132
		return strcmp(ref1->target.symbolic, ref2->target.symbolic);

1133
	return git_oid__cmp(&ref1->target.oid, &ref2->target.oid);
1134 1135
}

1136 1137 1138 1139 1140
/**
 * 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
1141 1142
{
	git_reference *ref;
1143
	int error = 0;
nulltoken committed
1144

1145
	if (nesting > MAX_NESTING_LEVEL) {
1146
		giterr_set(GITERR_REFERENCE, "reference chain too deep (%d)", nesting);
1147
		return GIT_ENOTFOUND;
1148
	}
1149

1150 1151 1152
	/* 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;
1153
		return error;
1154
	}
1155

1156 1157 1158
	if (git_reference_type(ref) == GIT_REF_OID) {
		*out = ref;
		error = 0;
1159
	} else {
1160
		error = get_terminal(out, repo, git_reference_symbolic_target(ref), nesting + 1);
Edward Thomson committed
1161 1162 1163
		if (error == GIT_ENOTFOUND && !*out)
			*out = ref;
		else
1164
			git_reference_free(ref);
nulltoken committed
1165
	}
1166

1167
	return error;
nulltoken committed
1168
}
1169

1170 1171 1172 1173 1174 1175 1176 1177
/*
 * 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,
1178
	const git_oid *oid,
1179
	const git_signature *sig,
1180
	const char *log_message)
1181
{
1182
	git_reference *ref = NULL, *ref2 = NULL;
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
	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) {
		assert(git_reference_type(ref) == GIT_REF_SYMBOLIC);
		giterr_clear();
1197
		error = reference__create(&ref2, repo, ref->target.symbolic, oid, NULL, 0, to_use,
1198 1199 1200
					  log_message, NULL, NULL);
	} else if (error == GIT_ENOTFOUND) {
		giterr_clear();
1201
		error = reference__create(&ref2, repo, ref_name, oid, NULL, 0, to_use,
1202 1203 1204
					  log_message, NULL, NULL);
	}  else if (error == 0) {
		assert(git_reference_type(ref) == GIT_REF_OID);
1205
		error = reference__create(&ref2, repo, ref->name, oid, NULL, 1, to_use,
1206 1207 1208
					  log_message, &ref->target.oid, NULL);
	}

1209 1210
	git_reference_free(ref2);
	git_reference_free(ref);
1211 1212
	git_signature_free(who);
	return error;
1213 1214
}

1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
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 "";
}

1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
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;
1237
	const git_signature *who;
1238 1239 1240 1241 1242
	int error;

	if ((error = git_commit_lookup(&commit, repo, id)) < 0 ||
		(error = git_buf_printf(&reflog_msg, "%s%s: %s",
			operation ? operation : "commit",
1243
			commit_type(commit),
1244 1245 1246
			git_commit_summary(commit))) < 0)
		goto done;

1247 1248 1249 1250 1251 1252 1253 1254 1255
	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);
	}
1256 1257
	else
		error = git_reference__update_terminal(
1258
			repo, ref_name, id, who, git_buf_cstr(&reflog_msg));
1259 1260 1261 1262 1263 1264 1265 1266

done:
	git_reference_free(ref_new);
	git_buf_free(&reflog_msg);
	git_commit_free(commit);
	return error;
}

1267
int git_reference_has_log(git_repository *repo, const char *refname)
1268
{
1269 1270
	int error;
	git_refdb *refdb;
1271

1272
	assert(repo && refname);
1273

1274 1275
	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
		return error;
1276

1277
	return git_refdb_has_log(refdb, refname);
1278
}
1279

1280 1281 1282 1283 1284 1285 1286 1287 1288
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;
1289

1290
	return git_refdb_ensure_log(refdb, refname);
1291
}
1292

1293 1294 1295 1296 1297
int git_reference__is_branch(const char *ref_name)
{
	return git__prefixcmp(ref_name, GIT_REFS_HEADS_DIR) == 0;
}

1298
int git_reference_is_branch(const git_reference *ref)
1299 1300
{
	assert(ref);
1301
	return git_reference__is_branch(ref->name);
1302
}
1303

1304 1305 1306 1307 1308
int git_reference__is_remote(const char *ref_name)
{
	return git__prefixcmp(ref_name, GIT_REFS_REMOTES_DIR) == 0;
}

Jacques Germishuys committed
1309
int git_reference_is_remote(const git_reference *ref)
1310 1311
{
	assert(ref);
1312
	return git_reference__is_remote(ref->name);
1313
}
1314

1315 1316 1317 1318 1319
int git_reference__is_tag(const char *ref_name)
{
	return git__prefixcmp(ref_name, GIT_REFS_TAGS_DIR) == 0;
}

Jacques Germishuys committed
1320
int git_reference_is_tag(const git_reference *ref)
1321 1322 1323 1324 1325
{
	assert(ref);
	return git_reference__is_tag(ref->name);
}

1326 1327 1328 1329 1330
int git_reference__is_note(const char *ref_name)
{
	return git__prefixcmp(ref_name, GIT_REFS_NOTES_DIR) == 0;
}

Jacques Germishuys committed
1331
int git_reference_is_note(const git_reference *ref)
1332 1333 1334 1335 1336
{
	assert(ref);
	return git_reference__is_note(ref->name);
}

1337 1338 1339 1340
static int peel_error(int error, git_reference *ref, const char* msg)
{
	giterr_set(
		GITERR_INVALID,
1341
		"the reference '%s' cannot be peeled - %s", git_reference_name(ref), msg);
1342 1343 1344 1345
	return error;
}

int git_reference_peel(
1346 1347 1348
	git_object **peeled,
	git_reference *ref,
	git_otype target_type)
1349 1350 1351 1352 1353 1354 1355
{
	git_reference *resolved = NULL;
	git_object *target = NULL;
	int error;

	assert(ref);

1356 1357 1358 1359 1360 1361 1362
	if (ref->type == GIT_REF_OID) {
		resolved = ref;
	} else {
		if ((error = git_reference_resolve(&resolved, ref)) < 0)
			return peel_error(error, ref, "Cannot resolve reference");
	}

1363 1364 1365 1366 1367 1368 1369
	/*
	 * 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.
	 */
	if (target_type != GIT_OBJ_TAG && !git_oid_iszero(&resolved->peel)) {
1370
		error = git_object_lookup(&target,
1371
			git_reference_owner(ref), &resolved->peel, GIT_OBJ_ANY);
1372 1373
	} else {
		error = git_object_lookup(&target,
1374
			git_reference_owner(ref), &resolved->target.oid, GIT_OBJ_ANY);
1375
	}
1376

1377
	if (error < 0) {
1378 1379 1380
		peel_error(error, ref, "Cannot retrieve reference target");
		goto cleanup;
	}
1381

1382
	if (target_type == GIT_OBJ_ANY && git_object_type(target) != GIT_OBJ_TAG)
1383
		error = git_object_dup(peeled, target);
1384
	else
1385 1386 1387 1388
		error = git_object_peel(peeled, target, target_type);

cleanup:
	git_object_free(target);
1389 1390 1391 1392

	if (resolved != ref)
		git_reference_free(resolved);

1393 1394
	return error;
}
1395

1396
int git_reference__is_valid_name(const char *refname, unsigned int flags)
1397
{
1398 1399 1400 1401
	if (git_reference__normalize_name(NULL, refname, flags) < 0) {
		giterr_clear();
		return false;
	}
nulltoken committed
1402

1403
	return true;
1404 1405
}

1406
int git_reference_is_valid_name(const char *refname)
1407
{
1408
	return git_reference__is_valid_name(refname, GIT_REF_FORMAT_ALLOW_ONELEVEL);
1409
}
1410

1411
const char *git_reference__shorthand(const char *name)
1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424
{
	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;
}
1425 1426 1427 1428 1429

const char *git_reference_shorthand(const git_reference *ref)
{
	return git_reference__shorthand(ref->name);
}