/*

 * 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"

#include "filebuf.h"

#include "pack.h"

#include "reflog.h"

#include "refdb.h"

#include "refdb_fs.h"

#include "iterator.h"

#include "sortedcache.h"

#include "signature.h"

#include <git2/tag.h>

#include <git2/object.h>

#include <git2/refdb.h>

#include <git2/branch.h>

#include <git2/sys/refdb_backend.h>

#include <git2/sys/refs.h>

#include <git2/sys/reflog.h>

#define DEFAULT_NESTING_LEVEL	5

#define MAX_NESTING_LEVEL		10

enum {

	PACKREF_HAS_PEEL = 1,

	PACKREF_WAS_LOOSE = 2,

	PACKREF_CANNOT_PEEL = 4,

	PACKREF_SHADOWED = 8,

};

enum {

	PEELING_NONE = 0,

	PEELING_STANDARD,

	PEELING_FULL

};

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;

	/* path to git directory */

	char *gitpath;

	/* path to common objects' directory */

	char *commonpath;

	git_sortedcache *refcache;

	int peeling_mode;

	git_iterator_flag_t iterator_flags;

	uint32_t direach_flags;

	int fsync;

} refdb_fs_backend;

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

static int packref_cmp(const void *a_, const void *b_)

{

	const struct packref *a = a_, *b = b_;

	return strcmp(a->name, b->name);

}

static int packed_reload(refdb_fs_backend *backend)

{

	int error;

	git_buf packedrefs = GIT_BUF_INIT;

	char *scan, *eof, *eol;

	if (!backend->gitpath)

		return 0;

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

	/*

	 * 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.

	 */

	if (error <= 0) {

		if (error == GIT_ENOTFOUND) {

			git_sortedcache_clear(backend->refcache, true);

			giterr_clear();

			error = 0;

		}

		return error;

	}

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

	git_sortedcache_clear(backend->refcache, false);

	scan = (char *)packedrefs.ptr;

	eof  = scan + packedrefs.size;

	backend->peeling_mode = PEELING_NONE;

	if (*scan == '#') {

		static const char *traits_header = "# pack-refs with: ";

		if (git__prefixcmp(scan, traits_header) == 0) {

			scan += strlen(traits_header);

			eol = strchr(scan, '\n');

			if (!eol)

				goto parse_failed;

			*eol = '\0';

			if (strstr(scan, " fully-peeled ") != NULL) {

				backend->peeling_mode = PEELING_FULL;

			} else if (strstr(scan, " peeled ") != NULL) {

				backend->peeling_mode = PEELING_STANDARD;

			}

			scan = eol + 1;

		}

	}

	while (scan < eof && *scan == '#') {

		if (!(eol = strchr(scan, '\n')))

			goto parse_failed;

		scan = eol + 1;

	}

	while (scan < eof) {

		struct packref *ref;

		git_oid oid;

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

		if (git_oid_fromstr(&oid, scan) < 0)

			goto parse_failed;

		scan += GIT_OID_HEXSZ;

		if (*scan++ != ' ')

			goto parse_failed;

		if (!(eol = strchr(scan, '\n')))

			goto parse_failed;

		*eol = '\0';

		if (eol[-1] == '\r')

			eol[-1] = '\0';

		if (git_sortedcache_upsert((void **)&ref, backend->refcache, scan) < 0)

			goto parse_failed;

		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;

	}

	git_sortedcache_wunlock(backend->refcache);

	git_buf_free(&packedrefs);

	return 0;

parse_failed:

	giterr_set(GITERR_REFERENCE, "corrupted packed references file");

	git_sortedcache_clear(backend->refcache, false);

	git_sortedcache_wunlock(backend->refcache);

	git_buf_free(&packedrefs);

	return -1;

}

static int loose_parse_oid(

	git_oid *oid, const char *filename, git_buf *file_content)

{

	const char *str = git_buf_cstr(file_content);

	if (git_buf_len(file_content) < GIT_OID_HEXSZ)

		goto corrupted;

	/* we need to get 40 OID characters from the file */

	if (git_oid_fromstr(oid, str) < 0)

		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:

	giterr_set(GITERR_REFERENCE, "corrupted loose reference file: %s", filename);

	return -1;

}

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)

{

	int error = 0;

	git_buf ref_file = GIT_BUF_INIT;

	struct packref *ref = NULL;

	git_oid oid;

	/* if we fail to load the loose reference, assume someone changed

	 * the filesystem under us and skip it...

	 */

	if (loose_readbuffer(&ref_file, backend->gitpath, name) < 0) {

		giterr_clear();

		goto done;

	}

	/* skip symbolic refs */

	if (!git__prefixcmp(git_buf_cstr(&ref_file), GIT_SYMREF))

		goto done;

	/* parse OID from file */

	if ((error = loose_parse_oid(&oid, name, &ref_file)) < 0)

		goto done;

	git_sortedcache_wlock(backend->refcache);

	if (!(error = git_sortedcache_upsert(

			(void **)&ref, backend->refcache, name))) {

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

		ref->flags = PACKREF_WAS_LOOSE;

	}

	git_sortedcache_wunlock(backend->refcache);

done:

	git_buf_free(&ref_file);

	return error;

}

static int _dirent_loose_load(void *payload, git_buf *full_path)

{

	refdb_fs_backend *backend = payload;

	const char *file_path;

	if (git__suffixcmp(full_path->ptr, ".lock") == 0)

		return 0;

	if (git_path_isdir(full_path->ptr)) {

		int error = git_path_direach(

			full_path, backend->direach_flags, _dirent_loose_load, backend);

		/* Race with the filesystem, ignore it */

		if (error == GIT_ENOTFOUND) {

			giterr_clear();

			return 0;

		}

		return error;

	}

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

	return loose_lookup_to_packfile(backend, file_path);

}

/*

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

{

	int error;

	git_buf refs_path = GIT_BUF_INIT;

	if (git_buf_joinpath(&refs_path, backend->gitpath, 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

	 */

	error = git_path_direach(

		&refs_path, backend->direach_flags, _dirent_loose_load, backend);

	git_buf_free(&refs_path);

	return error;

}

static int refdb_fs_backend__exists(

	int *exists,

	git_refdb_backend *_backend,

	const char *ref_name)

{

	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;

	git_buf ref_path = GIT_BUF_INIT;

	int error;

	assert(backend);

	if ((error = packed_reload(backend)) < 0 ||

		(error = git_buf_joinpath(&ref_path, backend->gitpath, ref_name)) < 0)

		return error;

	*exists = git_path_isfile(ref_path.ptr) ||

		(git_sortedcache_lookup(backend->refcache, ref_name) != NULL);

	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;

}

/*

 * Returns whether a reference is stored per worktree or not.

 * Per-worktree references are:

 *

 * - all pseudorefs, e.g. HEAD and MERGE_HEAD

 * - all references stored inside of "refs/bisect/"

 */

static bool is_per_worktree_ref(const char *ref_name)

{

	return git__prefixcmp(ref_name, "refs/") != 0 ||

	    git__prefixcmp(ref_name, "refs/bisect/") == 0;

}

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;

	const char *ref_dir;

	if (out)

		*out = NULL;

	if (is_per_worktree_ref(ref_name))

		ref_dir = backend->gitpath;

	else

		ref_dir = backend->commonpath;

	if ((error = loose_readbuffer(&ref_file, ref_dir, ref_name)) < 0)

		/* cannot read loose ref file - gah */;

	else if (git__prefixcmp(git_buf_cstr(&ref_file), GIT_SYMREF) == 0) {

		const char *target;

		git_buf_rtrim(&ref_file);

		if (!(target = loose_parse_symbolic(&ref_file)))

			error = -1;

		else if (out != NULL)

			*out = git_reference__alloc_symbolic(ref_name, target);

	} else {

		git_oid oid;

		if (!(error = loose_parse_oid(&oid, ref_name, &ref_file)) &&

			out != NULL)

			*out = git_reference__alloc(ref_name, &oid, NULL);

	}

	git_buf_free(&ref_file);

	return error;

}

static int ref_error_notfound(const char *name)

{

	giterr_set(GITERR_REFERENCE, "reference '%s' not found", name);

	return GIT_ENOTFOUND;

}

static int packed_lookup(

	git_reference **out,

	refdb_fs_backend *backend,

	const char *ref_name)

{

	int error = 0;

	struct packref *entry;

	if ((error = packed_reload(backend)) < 0)

		return error;

	if (git_sortedcache_rlock(backend->refcache) < 0)

		return -1;

	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;

	}

	git_sortedcache_runlock(backend->refcache);

	return error;

}

static int refdb_fs_backend__lookup(

	git_reference **out,

	git_refdb_backend *_backend,

	const char *ref_name)

{

	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;

	int error;

	assert(backend);

	if (!(error = loose_lookup(out, backend, ref_name)))

		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 */

	if (error == GIT_ENOTFOUND) {

		giterr_clear();

		error = packed_lookup(out, backend, ref_name);

	}

	return error;

}

typedef struct {

	git_reference_iterator parent;

	char *glob;

	git_pool pool;

	git_vector loose;

	git_sortedcache *cache;

	size_t loose_pos;

	size_t packed_pos;

} refdb_fs_iter;

static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)

{

	refdb_fs_iter *iter = (refdb_fs_iter *) _iter;

	git_vector_free(&iter->loose);

	git_pool_clear(&iter->pool);

	git_sortedcache_free(iter->cache);

	git__free(iter);

}

static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter)

{

	int error = 0;

	git_buf path = GIT_BUF_INIT;

	git_iterator *fsit = NULL;

	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;

	const git_index_entry *entry = NULL;

	if (!backend->commonpath) /* do nothing if no commonpath for loose refs */

		return 0;

	fsit_opts.flags = backend->iterator_flags;

	if ((error = git_buf_printf(&path, "%s/refs", backend->commonpath)) < 0 ||

		(error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {

		git_buf_free(&path);

		return error;

	}

	error = git_buf_sets(&path, GIT_REFS_DIR);

	while (!error && !git_iterator_advance(&entry, fsit)) {

		const char *ref_name;

		struct packref *ref;

		char *ref_dup;

		git_buf_truncate(&path, strlen(GIT_REFS_DIR));

		git_buf_puts(&path, entry->path);

		ref_name = git_buf_cstr(&path);

		if (git__suffixcmp(ref_name, ".lock") == 0 ||

			(iter->glob && p_fnmatch(iter->glob, ref_name, 0) != 0))

			continue;

		git_sortedcache_rlock(backend->refcache);

		ref = git_sortedcache_lookup(backend->refcache, ref_name);

		if (ref)

			ref->flags |= PACKREF_SHADOWED;

		git_sortedcache_runlock(backend->refcache);

		ref_dup = git_pool_strdup(&iter->pool, ref_name);

		if (!ref_dup)

			error = -1;

		else

			error = git_vector_insert(&iter->loose, ref_dup);

	}

	git_iterator_free(fsit);

	git_buf_free(&path);

	return error;

}

static int refdb_fs_backend__iterator_next(

	git_reference **out, git_reference_iterator *_iter)

{

	int error = GIT_ITEROVER;

	refdb_fs_iter *iter = (refdb_fs_iter *)_iter;

	refdb_fs_backend *backend = (refdb_fs_backend *)iter->parent.db->backend;

	struct packref *ref;

	while (iter->loose_pos < iter->loose.length) {

		const char *path = git_vector_get(&iter->loose, iter->loose_pos++);

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

			return 0;

		giterr_clear();

	}

	if (!iter->cache) {

		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)

			return error;

	}

	error = GIT_ITEROVER;

	while (iter->packed_pos < git_sortedcache_entrycount(iter->cache)) {

		ref = git_sortedcache_entry(iter->cache, iter->packed_pos++);

		if (!ref) /* stop now if another thread deleted refs and we past end */

			break;

		if (ref->flags & PACKREF_SHADOWED)

			continue;

		if (iter->glob && p_fnmatch(iter->glob, ref->name, 0) != 0)

			continue;

		*out = git_reference__alloc(ref->name, &ref->oid, &ref->peel);

		error = (*out != NULL) ? 0 : -1;

		break;

	}

	return error;

}

static int refdb_fs_backend__iterator_next_name(

	const char **out, git_reference_iterator *_iter)

{

	int error = GIT_ITEROVER;

	refdb_fs_iter *iter = (refdb_fs_iter *)_iter;

	refdb_fs_backend *backend = (refdb_fs_backend *)iter->parent.db->backend;

	struct packref *ref;

	while (iter->loose_pos < iter->loose.length) {

		const char *path = git_vector_get(&iter->loose, iter->loose_pos++);

		if (loose_lookup(NULL, backend, path) == 0) {

			*out = path;

			return 0;

		}

		giterr_clear();

	}

	if (!iter->cache) {

		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)

			return error;

	}

	error = GIT_ITEROVER;

	while (iter->packed_pos < git_sortedcache_entrycount(iter->cache)) {

		ref = git_sortedcache_entry(iter->cache, iter->packed_pos++);

		if (!ref) /* stop now if another thread deleted refs and we past end */

			break;

		if (ref->flags & PACKREF_SHADOWED)

			continue;

		if (iter->glob && p_fnmatch(iter->glob, ref->name, 0) != 0)

			continue;

		*out = ref->name;

		error = 0;

		break;

	}

	return error;

}

static int refdb_fs_backend__iterator(

	git_reference_iterator **out, git_refdb_backend *_backend, const char *glob)

{

	int error;

	refdb_fs_iter *iter;

	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;

	assert(backend);

	if ((error = packed_reload(backend)) < 0)

		return error;

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

	GITERR_CHECK_ALLOC(iter);

	git_pool_init(&iter->pool, 1);

	if (git_vector_init(&iter->loose, 8, NULL) < 0)

		goto fail;

	if (glob != NULL &&

		(iter->glob = git_pool_strdup(&iter->pool, glob)) == NULL)

		goto fail;

	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;

	if (iter_load_loose_paths(backend, iter) < 0)

		goto fail;

	*out = (git_reference_iterator *)iter;

	return 0;

fail:

	refdb_fs_backend__iterator_free((git_reference_iterator *)iter);

	return -1;

}

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)

{

	size_t i;

	int error;

	if ((error = packed_reload(backend)) < 0)

		return error;

	if (!force) {

		int exists;

		if ((error = refdb_fs_backend__exists(

			&exists, (git_refdb_backend *)backend, new_ref)) < 0) {

			return error;

		}

		if (exists) {

			giterr_set(GITERR_REFERENCE,

				"failed to write reference '%s': a reference with "

				"that name already exists.", new_ref);

			return GIT_EEXISTS;

		}

	}

	git_sortedcache_rlock(backend->refcache);

	for (i = 0; i < git_sortedcache_entrycount(backend->refcache); ++i) {

		struct packref *ref = git_sortedcache_entry(backend->refcache, i);

		if (ref && !ref_is_available(old_ref, new_ref, ref->name)) {

			git_sortedcache_runlock(backend->refcache);

			giterr_set(GITERR_REFERENCE,

				"path to reference '%s' collides with existing one", new_ref);

			return -1;

		}

	}

	git_sortedcache_runlock(backend->refcache);

	return 0;

}

static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char *name)

{

	int error, filebuf_flags;

	git_buf ref_path = GIT_BUF_INIT;

	const char *basedir;

	assert(file && backend && name);

	if (!git_path_isvalid(backend->repo, name, 0, GIT_PATH_REJECT_FILESYSTEM_DEFAULTS)) {

		giterr_set(GITERR_INVALID, "invalid reference name '%s'", name);

		return GIT_EINVALIDSPEC;

	}

	if (is_per_worktree_ref(name))

		basedir = backend->gitpath;

	else

		basedir = backend->commonpath;

	/* Remove a possibly existing empty directory hierarchy

	 * which name would collide with the reference name

	 */

	if ((error = git_futils_rmdir_r(name, basedir, GIT_RMDIR_SKIP_NONEMPTY)) < 0)

		return error;

	if (git_buf_joinpath(&ref_path, basedir, name) < 0)

		return -1;

	filebuf_flags = GIT_FILEBUF_FORCE;

	if (backend->fsync)

		filebuf_flags |= GIT_FILEBUF_FSYNC;

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

	if (error == GIT_EDIRECTORY)

		giterr_set(GITERR_REFERENCE, "cannot lock ref '%s', there are refs beneath that folder", name);

	git_buf_free(&ref_path);

	return error;

}

static int loose_commit(git_filebuf *file, const git_reference *ref)

{

	assert(file && ref);

	if (ref->type == GIT_REF_OID) {

		char oid[GIT_OID_HEXSZ + 1];

		git_oid_nfmt(oid, sizeof(oid), &ref->target.oid);

		git_filebuf_printf(file, "%s\n", oid);

	} else if (ref->type == GIT_REF_SYMBOLIC) {

		git_filebuf_printf(file, GIT_SYMREF "%s\n", ref->target.symbolic);

	} else {

		assert(0); /* don't let this happen */

	}

	return git_filebuf_commit(file);

}

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;

}

/*

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

	if (ref->flags & PACKREF_HAS_PEEL || ref->flags & PACKREF_CANNOT_PEEL)

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

		ref->flags |= PACKREF_HAS_PEEL;