2 * Copyright (C) 2009-2012 the libgit2 contributors
4 * This file is part of libgit2, distributed under the GNU GPL v2 with
5 * a Linking Exception. For full terms see the included COPYING file.
10 #include "repository.h"
16 #include <git2/object.h>
18 #include <git2/branch.h>
22 #define DEFAULT_NESTING_LEVEL 5
23 #define MAX_NESTING_LEVEL 10
26 GIT_PACKREF_HAS_PEEL
= 1,
27 GIT_PACKREF_WAS_LOOSE
= 2
34 char name
[GIT_FLEX_ARRAY
];
37 static int reference_read(
38 git_buf
*file_content
,
40 const char *repo_path
,
45 static int loose_parse_symbolic(git_reference
*ref
, git_buf
*file_content
);
46 static int loose_parse_oid(git_oid
*ref
, git_buf
*file_content
);
47 static int loose_lookup(git_reference
*ref
);
48 static int loose_lookup_to_packfile(struct packref
**ref_out
,
49 git_repository
*repo
, const char *name
);
50 static int loose_write(git_reference
*ref
);
53 static int packed_parse_peel(struct packref
*tag_ref
,
54 const char **buffer_out
, const char *buffer_end
);
55 static int packed_parse_oid(struct packref
**ref_out
,
56 const char **buffer_out
, const char *buffer_end
);
57 static int packed_load(git_repository
*repo
);
58 static int packed_loadloose(git_repository
*repository
);
59 static int packed_write_ref(struct packref
*ref
, git_filebuf
*file
);
60 static int packed_find_peel(git_repository
*repo
, struct packref
*ref
);
61 static int packed_remove_loose(git_repository
*repo
, git_vector
*packing_list
);
62 static int packed_sort(const void *a
, const void *b
);
63 static int packed_lookup(git_reference
*ref
);
64 static int packed_write(git_repository
*repo
);
66 /* internal helpers */
67 static int reference_path_available(git_repository
*repo
,
68 const char *ref
, const char *old_ref
);
69 static int reference_delete(git_reference
*ref
);
70 static int reference_lookup(git_reference
*ref
);
72 void git_reference_free(git_reference
*reference
)
74 if (reference
== NULL
)
77 git__free(reference
->name
);
78 reference
->name
= NULL
;
80 if (reference
->flags
& GIT_REF_SYMBOLIC
) {
81 git__free(reference
->target
.symbolic
);
82 reference
->target
.symbolic
= NULL
;
88 static int reference_alloc(
89 git_reference
**ref_out
,
93 git_reference
*reference
= NULL
;
95 assert(ref_out
&& repo
&& name
);
97 reference
= git__malloc(sizeof(git_reference
));
98 GITERR_CHECK_ALLOC(reference
);
100 memset(reference
, 0x0, sizeof(git_reference
));
101 reference
->owner
= repo
;
103 reference
->name
= git__strdup(name
);
104 GITERR_CHECK_ALLOC(reference
->name
);
106 *ref_out
= reference
;
110 static int reference_read(
111 git_buf
*file_content
,
113 const char *repo_path
,
114 const char *ref_name
,
117 git_buf path
= GIT_BUF_INIT
;
120 assert(file_content
&& repo_path
&& ref_name
);
122 /* Determine the full path of the file */
123 if (git_buf_joinpath(&path
, repo_path
, ref_name
) < 0)
126 result
= git_futils_readbuffer_updated(
127 file_content
, path
.ptr
, mtime
, NULL
, updated
);
133 static int loose_parse_symbolic(git_reference
*ref
, git_buf
*file_content
)
135 const unsigned int header_len
= (unsigned int)strlen(GIT_SYMREF
);
136 const char *refname_start
;
138 refname_start
= (const char *)file_content
->ptr
;
140 if (git_buf_len(file_content
) < header_len
+ 1) {
141 giterr_set(GITERR_REFERENCE
, "Corrupted loose reference file");
146 * Assume we have already checked for the header
147 * before calling this function
149 refname_start
+= header_len
;
151 ref
->target
.symbolic
= git__strdup(refname_start
);
152 GITERR_CHECK_ALLOC(ref
->target
.symbolic
);
157 static int loose_parse_oid(git_oid
*oid
, git_buf
*file_content
)
162 len
= git_buf_len(file_content
);
163 if (len
< GIT_OID_HEXSZ
)
166 /* str is guranteed to be zero-terminated */
167 str
= git_buf_cstr(file_content
);
169 /* If the file is longer than 40 chars, the 41st must be a space */
170 if (git_oid_fromstr(oid
, git_buf_cstr(file_content
)) < 0)
173 /* If the file is longer than 40 chars, the 41st must be a space */
174 str
+= GIT_OID_HEXSZ
;
175 if (*str
== '\0' || git__isspace(*str
))
179 giterr_set(GITERR_REFERENCE
, "Corrupted loose reference file");
183 static git_ref_t
loose_guess_rtype(const git_buf
*full_path
)
185 git_buf ref_file
= GIT_BUF_INIT
;
188 type
= GIT_REF_INVALID
;
190 if (git_futils_readbuffer(&ref_file
, full_path
->ptr
) == 0) {
191 if (git__prefixcmp((const char *)(ref_file
.ptr
), GIT_SYMREF
) == 0)
192 type
= GIT_REF_SYMBOLIC
;
197 git_buf_free(&ref_file
);
201 static int loose_lookup(git_reference
*ref
)
204 git_buf ref_file
= GIT_BUF_INIT
;
206 result
= reference_read(&ref_file
, &ref
->mtime
,
207 ref
->owner
->path_repository
, ref
->name
, &updated
);
215 if (ref
->flags
& GIT_REF_SYMBOLIC
) {
216 git__free(ref
->target
.symbolic
);
217 ref
->target
.symbolic
= NULL
;
222 if (git__prefixcmp((const char *)(ref_file
.ptr
), GIT_SYMREF
) == 0) {
223 ref
->flags
|= GIT_REF_SYMBOLIC
;
224 git_buf_rtrim(&ref_file
);
225 result
= loose_parse_symbolic(ref
, &ref_file
);
227 ref
->flags
|= GIT_REF_OID
;
228 result
= loose_parse_oid(&ref
->target
.oid
, &ref_file
);
231 git_buf_free(&ref_file
);
235 static int loose_lookup_to_packfile(
236 struct packref
**ref_out
,
237 git_repository
*repo
,
240 git_buf ref_file
= GIT_BUF_INIT
;
241 struct packref
*ref
= NULL
;
246 if (reference_read(&ref_file
, NULL
, repo
->path_repository
, name
, NULL
) < 0)
249 git_buf_rtrim(&ref_file
);
251 name_len
= strlen(name
);
252 ref
= git__malloc(sizeof(struct packref
) + name_len
+ 1);
253 GITERR_CHECK_ALLOC(ref
);
255 memcpy(ref
->name
, name
, name_len
);
256 ref
->name
[name_len
] = 0;
258 if (loose_parse_oid(&ref
->oid
, &ref_file
) < 0) {
259 git_buf_free(&ref_file
);
264 ref
->flags
= GIT_PACKREF_WAS_LOOSE
;
267 git_buf_free(&ref_file
);
271 static int loose_write(git_reference
*ref
)
273 git_filebuf file
= GIT_FILEBUF_INIT
;
274 git_buf ref_path
= GIT_BUF_INIT
;
277 if (git_buf_joinpath(&ref_path
, ref
->owner
->path_repository
, ref
->name
) < 0)
280 /* Remove a possibly existing empty directory hierarchy
281 * which name would collide with the reference name
283 if (git_path_isdir(git_buf_cstr(&ref_path
)) &&
284 git_futils_rmdir_r(git_buf_cstr(&ref_path
), NULL
,
285 GIT_DIRREMOVAL_ONLY_EMPTY_DIRS
) < 0) {
286 git_buf_free(&ref_path
);
290 if (git_filebuf_open(&file
, ref_path
.ptr
, GIT_FILEBUF_FORCE
) < 0) {
291 git_buf_free(&ref_path
);
295 git_buf_free(&ref_path
);
297 if (ref
->flags
& GIT_REF_OID
) {
298 char oid
[GIT_OID_HEXSZ
+ 1];
300 git_oid_fmt(oid
, &ref
->target
.oid
);
301 oid
[GIT_OID_HEXSZ
] = '\0';
303 git_filebuf_printf(&file
, "%s\n", oid
);
305 } else if (ref
->flags
& GIT_REF_SYMBOLIC
) {
306 git_filebuf_printf(&file
, GIT_SYMREF
"%s\n", ref
->target
.symbolic
);
308 assert(0); /* don't let this happen */
311 if (p_stat(ref_path
.ptr
, &st
) == 0)
312 ref
->mtime
= st
.st_mtime
;
314 return git_filebuf_commit(&file
, GIT_REFS_FILE_MODE
);
317 static int packed_parse_peel(
318 struct packref
*tag_ref
,
319 const char **buffer_out
,
320 const char *buffer_end
)
322 const char *buffer
= *buffer_out
+ 1;
324 assert(buffer
[-1] == '^');
326 /* Ensure it's not the first entry of the file */
330 /* Ensure reference is a tag */
331 if (git__prefixcmp(tag_ref
->name
, GIT_REFS_TAGS_DIR
) != 0)
334 if (buffer
+ GIT_OID_HEXSZ
>= buffer_end
)
337 /* Is this a valid object id? */
338 if (git_oid_fromstr(&tag_ref
->peel
, buffer
) < 0)
341 buffer
= buffer
+ GIT_OID_HEXSZ
;
348 *buffer_out
= buffer
+ 1;
352 giterr_set(GITERR_REFERENCE
, "The packed references file is corrupted");
356 static int packed_parse_oid(
357 struct packref
**ref_out
,
358 const char **buffer_out
,
359 const char *buffer_end
)
361 struct packref
*ref
= NULL
;
363 const char *buffer
= *buffer_out
;
364 const char *refname_begin
, *refname_end
;
369 refname_begin
= (buffer
+ GIT_OID_HEXSZ
+ 1);
370 if (refname_begin
>= buffer_end
|| refname_begin
[-1] != ' ')
373 /* Is this a valid object id? */
374 if (git_oid_fromstr(&id
, buffer
) < 0)
377 refname_end
= memchr(refname_begin
, '\n', buffer_end
- refname_begin
);
378 if (refname_end
== NULL
)
381 if (refname_end
[-1] == '\r')
384 refname_len
= refname_end
- refname_begin
;
386 ref
= git__malloc(sizeof(struct packref
) + refname_len
+ 1);
387 GITERR_CHECK_ALLOC(ref
);
389 memcpy(ref
->name
, refname_begin
, refname_len
);
390 ref
->name
[refname_len
] = 0;
392 git_oid_cpy(&ref
->oid
, &id
);
397 *buffer_out
= refname_end
+ 1;
403 giterr_set(GITERR_REFERENCE
, "The packed references file is corrupted");
407 static int packed_load(git_repository
*repo
)
410 git_buf packfile
= GIT_BUF_INIT
;
411 const char *buffer_start
, *buffer_end
;
412 git_refcache
*ref_cache
= &repo
->references
;
414 /* First we make sure we have allocated the hash table */
415 if (ref_cache
->packfile
== NULL
) {
416 ref_cache
->packfile
= git_strmap_alloc();
417 GITERR_CHECK_ALLOC(ref_cache
->packfile
);
420 result
= reference_read(&packfile
, &ref_cache
->packfile_time
,
421 repo
->path_repository
, GIT_PACKEDREFS_FILE
, &updated
);
424 * If we couldn't find the file, we need to clear the table and
425 * return. On any other error, we return that error. If everything
426 * went fine and the file wasn't updated, then there's nothing new
427 * for us here, so just return. Anything else means we need to
428 * refresh the packed refs.
430 if (result
== GIT_ENOTFOUND
) {
431 git_strmap_clear(ref_cache
->packfile
);
442 * At this point, we want to refresh the packed refs. We already
443 * have the contents in our buffer.
445 git_strmap_clear(ref_cache
->packfile
);
447 buffer_start
= (const char *)packfile
.ptr
;
448 buffer_end
= (const char *)(buffer_start
) + packfile
.size
;
450 while (buffer_start
< buffer_end
&& buffer_start
[0] == '#') {
451 buffer_start
= strchr(buffer_start
, '\n');
452 if (buffer_start
== NULL
)
458 while (buffer_start
< buffer_end
) {
460 struct packref
*ref
= NULL
;
462 if (packed_parse_oid(&ref
, &buffer_start
, buffer_end
) < 0)
465 if (buffer_start
[0] == '^') {
466 if (packed_parse_peel(ref
, &buffer_start
, buffer_end
) < 0)
470 git_strmap_insert(ref_cache
->packfile
, ref
->name
, ref
, err
);
475 git_buf_free(&packfile
);
479 git_strmap_free(ref_cache
->packfile
);
480 ref_cache
->packfile
= NULL
;
481 git_buf_free(&packfile
);
486 struct dirent_list_data
{
487 git_repository
*repo
;
488 size_t repo_path_len
;
489 unsigned int list_flags
;
491 int (*callback
)(const char *, void *);
492 void *callback_payload
;
496 static int _dirent_loose_listall(void *_data
, git_buf
*full_path
)
498 struct dirent_list_data
*data
= (struct dirent_list_data
*)_data
;
499 const char *file_path
= full_path
->ptr
+ data
->repo_path_len
;
501 if (git_path_isdir(full_path
->ptr
) == true)
502 return git_path_direach(full_path
, _dirent_loose_listall
, _data
);
504 /* do not add twice a reference that exists already in the packfile */
505 if ((data
->list_flags
& GIT_REF_PACKED
) != 0 &&
506 git_strmap_exists(data
->repo
->references
.packfile
, file_path
))
509 if (data
->list_flags
!= GIT_REF_LISTALL
) {
510 if ((data
->list_flags
& loose_guess_rtype(full_path
)) == 0)
511 return 0; /* we are filtering out this reference */
514 /* Locked references aren't returned */
515 if (!git__suffixcmp(file_path
, GIT_FILELOCK_EXTENSION
))
518 if (data
->callback(file_path
, data
->callback_payload
))
519 data
->callback_error
= GIT_EUSER
;
521 return data
->callback_error
;
524 static int _dirent_loose_load(void *data
, git_buf
*full_path
)
526 git_repository
*repository
= (git_repository
*)data
;
527 void *old_ref
= NULL
;
529 const char *file_path
;
532 if (git_path_isdir(full_path
->ptr
) == true)
533 return git_path_direach(full_path
, _dirent_loose_load
, repository
);
535 file_path
= full_path
->ptr
+ strlen(repository
->path_repository
);
537 if (loose_lookup_to_packfile(&ref
, repository
, file_path
) < 0)
541 repository
->references
.packfile
, ref
->name
, ref
, old_ref
, err
);
552 * Load all the loose references from the repository
553 * into the in-memory Packfile, and build a vector with
554 * all the references so it can be written back to
557 static int packed_loadloose(git_repository
*repository
)
559 git_buf refs_path
= GIT_BUF_INIT
;
562 /* the packfile must have been previously loaded! */
563 assert(repository
->references
.packfile
);
565 if (git_buf_joinpath(&refs_path
, repository
->path_repository
, GIT_REFS_DIR
) < 0)
569 * Load all the loose files from disk into the Packfile table.
570 * This will overwrite any old packed entries with their
571 * updated loose versions
573 result
= git_path_direach(&refs_path
, _dirent_loose_load
, repository
);
574 git_buf_free(&refs_path
);
580 * Write a single reference into a packfile
582 static int packed_write_ref(struct packref
*ref
, git_filebuf
*file
)
584 char oid
[GIT_OID_HEXSZ
+ 1];
586 git_oid_fmt(oid
, &ref
->oid
);
587 oid
[GIT_OID_HEXSZ
] = 0;
590 * For references that peel to an object in the repo, we must
591 * write the resulting peel on a separate line, e.g.
593 * 6fa8a902cc1d18527e1355773c86721945475d37 refs/tags/libgit2-0.4
594 * ^2ec0cb7959b0bf965d54f95453f5b4b34e8d3100
596 * This obviously only applies to tags.
597 * The required peels have already been loaded into `ref->peel_target`.
599 if (ref
->flags
& GIT_PACKREF_HAS_PEEL
) {
600 char peel
[GIT_OID_HEXSZ
+ 1];
601 git_oid_fmt(peel
, &ref
->peel
);
602 peel
[GIT_OID_HEXSZ
] = 0;
604 if (git_filebuf_printf(file
, "%s %s\n^%s\n", oid
, ref
->name
, peel
) < 0)
607 if (git_filebuf_printf(file
, "%s %s\n", oid
, ref
->name
) < 0)
615 * Find out what object this reference resolves to.
617 * For references that point to a 'big' tag (e.g. an
618 * actual tag object on the repository), we need to
619 * cache on the packfile the OID of the object to
620 * which that 'big tag' is pointing to.
622 static int packed_find_peel(git_repository
*repo
, struct packref
*ref
)
626 if (ref
->flags
& GIT_PACKREF_HAS_PEEL
)
630 * Only applies to tags, i.e. references
631 * in the /refs/tags folder
633 if (git__prefixcmp(ref
->name
, GIT_REFS_TAGS_DIR
) != 0)
637 * Find the tagged object in the repository
639 if (git_object_lookup(&object
, repo
, &ref
->oid
, GIT_OBJ_ANY
) < 0)
643 * If the tagged object is a Tag object, we need to resolve it;
644 * if the ref is actually a 'weak' ref, we don't need to resolve
647 if (git_object_type(object
) == GIT_OBJ_TAG
) {
648 git_tag
*tag
= (git_tag
*)object
;
651 * Find the object pointed at by this tag
653 git_oid_cpy(&ref
->peel
, git_tag_target_oid(tag
));
654 ref
->flags
|= GIT_PACKREF_HAS_PEEL
;
657 * The reference has now cached the resolved OID, and is
658 * marked at such. When written to the packfile, it'll be
659 * accompanied by this resolved oid
663 git_object_free(object
);
668 * Remove all loose references
670 * Once we have successfully written a packfile,
671 * all the loose references that were packed must be
674 * This is a dangerous method; make sure the packfile
675 * is well-written, because we are destructing references
678 static int packed_remove_loose(git_repository
*repo
, git_vector
*packing_list
)
681 git_buf full_path
= GIT_BUF_INIT
;
684 for (i
= 0; i
< packing_list
->length
; ++i
) {
685 struct packref
*ref
= git_vector_get(packing_list
, i
);
687 if ((ref
->flags
& GIT_PACKREF_WAS_LOOSE
) == 0)
690 if (git_buf_joinpath(&full_path
, repo
->path_repository
, ref
->name
) < 0)
691 return -1; /* critical; do not try to recover on oom */
693 if (git_path_exists(full_path
.ptr
) == true && p_unlink(full_path
.ptr
) < 0) {
697 giterr_set(GITERR_REFERENCE
,
698 "Failed to remove loose reference '%s' after packing: %s",
699 full_path
.ptr
, strerror(errno
));
705 * if we fail to remove a single file, this is *not* good,
706 * but we should keep going and remove as many as possible.
707 * After we've removed as many files as possible, we return
708 * the error code anyway.
712 git_buf_free(&full_path
);
713 return failed
? -1 : 0;
716 static int packed_sort(const void *a
, const void *b
)
718 const struct packref
*ref_a
= (const struct packref
*)a
;
719 const struct packref
*ref_b
= (const struct packref
*)b
;
721 return strcmp(ref_a
->name
, ref_b
->name
);
725 * Write all the contents in the in-memory packfile to disk.
727 static int packed_write(git_repository
*repo
)
729 git_filebuf pack_file
= GIT_FILEBUF_INIT
;
731 git_buf pack_file_path
= GIT_BUF_INIT
;
732 git_vector packing_list
;
733 unsigned int total_refs
;
735 assert(repo
&& repo
->references
.packfile
);
738 (unsigned int)git_strmap_num_entries(repo
->references
.packfile
);
740 if (git_vector_init(&packing_list
, total_refs
, packed_sort
) < 0)
743 /* Load all the packfile into a vector */
745 struct packref
*reference
;
747 /* cannot fail: vector already has the right size */
748 git_strmap_foreach_value(repo
->references
.packfile
, reference
, {
749 git_vector_insert(&packing_list
, reference
);
753 /* sort the vector so the entries appear sorted on the packfile */
754 git_vector_sort(&packing_list
);
756 /* Now we can open the file! */
757 if (git_buf_joinpath(&pack_file_path
, repo
->path_repository
, GIT_PACKEDREFS_FILE
) < 0)
760 if (git_filebuf_open(&pack_file
, pack_file_path
.ptr
, 0) < 0)
761 goto cleanup_packfile
;
763 /* Packfiles have a header... apparently
764 * This is in fact not required, but we might as well print it
766 if (git_filebuf_printf(&pack_file
, "%s\n", GIT_PACKEDREFS_HEADER
) < 0)
767 goto cleanup_packfile
;
769 for (i
= 0; i
< packing_list
.length
; ++i
) {
770 struct packref
*ref
= (struct packref
*)git_vector_get(&packing_list
, i
);
772 if (packed_find_peel(repo
, ref
) < 0)
773 goto cleanup_packfile
;
775 if (packed_write_ref(ref
, &pack_file
) < 0)
776 goto cleanup_packfile
;
779 /* if we've written all the references properly, we can commit
780 * the packfile to make the changes effective */
781 if (git_filebuf_commit(&pack_file
, GIT_PACKEDREFS_FILE_MODE
) < 0)
784 /* when and only when the packfile has been properly written,
785 * we can go ahead and remove the loose refs */
786 if (packed_remove_loose(repo
, &packing_list
) < 0)
791 if (p_stat(pack_file_path
.ptr
, &st
) == 0)
792 repo
->references
.packfile_time
= st
.st_mtime
;
795 git_vector_free(&packing_list
);
796 git_buf_free(&pack_file_path
);
802 git_filebuf_cleanup(&pack_file
);
805 git_vector_free(&packing_list
);
806 git_buf_free(&pack_file_path
);
811 struct reference_available_t
{
817 static int _reference_available_cb(const char *ref
, void *data
)
819 struct reference_available_t
*d
;
822 d
= (struct reference_available_t
*)data
;
824 if (!d
->old_ref
|| strcmp(d
->old_ref
, ref
)) {
825 size_t reflen
= strlen(ref
);
826 size_t newlen
= strlen(d
->new_ref
);
827 size_t cmplen
= reflen
< newlen
? reflen
: newlen
;
828 const char *lead
= reflen
< newlen
? d
->new_ref
: ref
;
830 if (!strncmp(d
->new_ref
, ref
, cmplen
) && lead
[cmplen
] == '/') {
839 static int reference_path_available(
840 git_repository
*repo
,
845 struct reference_available_t data
;
848 data
.old_ref
= old_ref
;
851 error
= git_reference_foreach(
852 repo
, GIT_REF_LISTALL
, _reference_available_cb
, (void *)&data
);
856 if (!data
.available
) {
857 giterr_set(GITERR_REFERENCE
,
858 "The path to reference '%s' collides with an existing one", ref
);
865 static int reference_exists(int *exists
, git_repository
*repo
, const char *ref_name
)
867 git_buf ref_path
= GIT_BUF_INIT
;
869 if (packed_load(repo
) < 0)
872 if (git_buf_joinpath(&ref_path
, repo
->path_repository
, ref_name
) < 0)
875 if (git_path_isfile(ref_path
.ptr
) == true ||
876 git_strmap_exists(repo
->references
.packfile
, ref_path
.ptr
))
883 git_buf_free(&ref_path
);
888 * Check if a reference could be written to disk, based on:
890 * - Whether a reference with the same name already exists,
891 * and we are allowing or disallowing overwrites
893 * - Whether the name of the reference would collide with
896 static int reference_can_write(
897 git_repository
*repo
,
899 const char *previous_name
,
902 /* see if the reference shares a path with an existing reference;
903 * if a path is shared, we cannot create the reference, even when forcing */
904 if (reference_path_available(repo
, refname
, previous_name
) < 0)
907 /* check if the reference actually exists, but only if we are not forcing
908 * the rename. If we are forcing, it's OK to overwrite */
912 if (reference_exists(&exists
, repo
, refname
) < 0)
915 /* We cannot proceed if the reference already exists and we're not forcing
916 * the rename; the existing one would be overwritten */
918 giterr_set(GITERR_REFERENCE
,
919 "A reference with that name (%s) already exists", refname
);
924 /* FIXME: if the reference exists and we are forcing, do we really need to
925 * remove the reference first?
929 * - the reference already exists and is loose: not a problem, the file
930 * gets overwritten on disk
932 * - the reference already exists and is packed: we write a new one as
933 * loose, which by all means renders the packed one useless
940 static int packed_lookup(git_reference
*ref
)
942 struct packref
*pack_ref
= NULL
;
943 git_strmap
*packfile_refs
;
946 if (packed_load(ref
->owner
) < 0)
949 /* maybe the packfile hasn't changed at all, so we don't
950 * have to re-lookup the reference */
951 if ((ref
->flags
& GIT_REF_PACKED
) &&
952 ref
->mtime
== ref
->owner
->references
.packfile_time
)
955 if (ref
->flags
& GIT_REF_SYMBOLIC
) {
956 git__free(ref
->target
.symbolic
);
957 ref
->target
.symbolic
= NULL
;
960 /* Look up on the packfile */
961 packfile_refs
= ref
->owner
->references
.packfile
;
962 pos
= git_strmap_lookup_index(packfile_refs
, ref
->name
);
963 if (!git_strmap_valid_index(packfile_refs
, pos
)) {
964 giterr_set(GITERR_REFERENCE
, "Reference '%s' not found", ref
->name
);
965 return GIT_ENOTFOUND
;
968 pack_ref
= git_strmap_value_at(packfile_refs
, pos
);
970 ref
->flags
= GIT_REF_OID
| GIT_REF_PACKED
;
971 ref
->mtime
= ref
->owner
->references
.packfile_time
;
972 git_oid_cpy(&ref
->target
.oid
, &pack_ref
->oid
);
977 static int reference_lookup(git_reference
*ref
)
981 result
= loose_lookup(ref
);
985 /* only try to lookup this reference on the packfile if it
986 * wasn't found on the loose refs; not if there was a critical error */
987 if (result
== GIT_ENOTFOUND
) {
989 result
= packed_lookup(ref
);
994 /* unexpected error; free the reference */
995 git_reference_free(ref
);
1000 * Delete a reference.
1001 * This is an internal method; the reference is removed
1002 * from disk or the packfile, but the pointer is not freed
1004 static int reference_delete(git_reference
*ref
)
1010 /* If the reference is packed, this is an expensive operation.
1011 * We need to reload the packfile, remove the reference from the
1012 * packing list, and repack */
1013 if (ref
->flags
& GIT_REF_PACKED
) {
1014 git_strmap
*packfile_refs
;
1015 struct packref
*packref
;
1018 /* load the existing packfile */
1019 if (packed_load(ref
->owner
) < 0)
1022 packfile_refs
= ref
->owner
->references
.packfile
;
1023 pos
= git_strmap_lookup_index(packfile_refs
, ref
->name
);
1024 if (!git_strmap_valid_index(packfile_refs
, pos
)) {
1025 giterr_set(GITERR_REFERENCE
,
1026 "Reference %s stopped existing in the packfile", ref
->name
);
1030 packref
= git_strmap_value_at(packfile_refs
, pos
);
1031 git_strmap_delete_at(packfile_refs
, pos
);
1034 if (packed_write(ref
->owner
) < 0)
1037 /* If the reference is loose, we can just remove the reference
1038 * from the filesystem */
1040 git_reference
*ref_in_pack
;
1041 git_buf full_path
= GIT_BUF_INIT
;
1043 if (git_buf_joinpath(&full_path
, ref
->owner
->path_repository
, ref
->name
) < 0)
1046 result
= p_unlink(full_path
.ptr
);
1047 git_buf_free(&full_path
); /* done with path at this point */
1050 giterr_set(GITERR_OS
, "Failed to unlink '%s'", full_path
.ptr
);
1054 /* When deleting a loose reference, we have to ensure that an older
1055 * packed version of it doesn't exist */
1056 if (git_reference_lookup(&ref_in_pack
, ref
->owner
, ref
->name
) == 0) {
1057 assert((ref_in_pack
->flags
& GIT_REF_PACKED
) != 0);
1058 return git_reference_delete(ref_in_pack
);
1067 int git_reference_delete(git_reference
*ref
)
1069 int result
= reference_delete(ref
);
1070 git_reference_free(ref
);
1074 int git_reference_lookup(git_reference
**ref_out
,
1075 git_repository
*repo
, const char *name
)
1077 return git_reference_lookup_resolved(ref_out
, repo
, name
, 0);
1080 int git_reference_name_to_oid(
1081 git_oid
*out
, git_repository
*repo
, const char *name
)
1086 if ((error
= git_reference_lookup_resolved(&ref
, repo
, name
, -1)) < 0)
1089 git_oid_cpy(out
, git_reference_oid(ref
));
1090 git_reference_free(ref
);
1094 int git_reference_lookup_resolved(
1095 git_reference
**ref_out
,
1096 git_repository
*repo
,
1100 git_reference
*scan
;
1101 int result
, nesting
;
1103 assert(ref_out
&& repo
&& name
);
1107 if (max_nesting
> MAX_NESTING_LEVEL
)
1108 max_nesting
= MAX_NESTING_LEVEL
;
1109 else if (max_nesting
< 0)
1110 max_nesting
= DEFAULT_NESTING_LEVEL
;
1112 scan
= git__calloc(1, sizeof(git_reference
));
1113 GITERR_CHECK_ALLOC(scan
);
1115 scan
->name
= git__calloc(GIT_REFNAME_MAX
+ 1, sizeof(char));
1116 GITERR_CHECK_ALLOC(scan
->name
);
1118 if ((result
= git_reference__normalize_name_lax(
1122 git_reference_free(scan
);
1126 scan
->target
.symbolic
= git__strdup(scan
->name
);
1127 GITERR_CHECK_ALLOC(scan
->target
.symbolic
);
1130 scan
->flags
= GIT_REF_SYMBOLIC
;
1132 for (nesting
= max_nesting
;
1133 nesting
>= 0 && (scan
->flags
& GIT_REF_SYMBOLIC
) != 0;
1136 if (nesting
!= max_nesting
)
1137 strncpy(scan
->name
, scan
->target
.symbolic
, GIT_REFNAME_MAX
);
1141 if ((result
= reference_lookup(scan
)) < 0)
1142 return result
; /* lookup git_reference_free on scan already */
1145 if ((scan
->flags
& GIT_REF_OID
) == 0 && max_nesting
!= 0) {
1146 giterr_set(GITERR_REFERENCE
,
1147 "Cannot resolve reference (>%u levels deep)", max_nesting
);
1148 git_reference_free(scan
);
1159 git_ref_t
git_reference_type(git_reference
*ref
)
1163 if (ref
->flags
& GIT_REF_OID
)
1166 if (ref
->flags
& GIT_REF_SYMBOLIC
)
1167 return GIT_REF_SYMBOLIC
;
1169 return GIT_REF_INVALID
;
1172 int git_reference_is_packed(git_reference
*ref
)
1175 return !!(ref
->flags
& GIT_REF_PACKED
);
1178 const char *git_reference_name(git_reference
*ref
)
1184 git_repository
*git_reference_owner(git_reference
*ref
)
1190 const git_oid
*git_reference_oid(git_reference
*ref
)
1194 if ((ref
->flags
& GIT_REF_OID
) == 0)
1197 return &ref
->target
.oid
;
1200 const char *git_reference_target(git_reference
*ref
)
1204 if ((ref
->flags
& GIT_REF_SYMBOLIC
) == 0)
1207 return ref
->target
.symbolic
;
1210 int git_reference_create_symbolic(
1211 git_reference
**ref_out
,
1212 git_repository
*repo
,
1217 char normalized
[GIT_REFNAME_MAX
];
1218 git_reference
*ref
= NULL
;
1221 if (git_reference__normalize_name_lax(
1227 if ((error
= reference_can_write(repo
, normalized
, NULL
, force
)) < 0)
1230 if (reference_alloc(&ref
, repo
, normalized
) < 0)
1233 ref
->flags
|= GIT_REF_SYMBOLIC
;
1235 /* set the target; this will normalize the name automatically
1236 * and write the reference on disk */
1237 if (git_reference_set_target(ref
, target
) < 0) {
1238 git_reference_free(ref
);
1241 if (ref_out
== NULL
) {
1242 git_reference_free(ref
);
1250 int git_reference_create_oid(
1251 git_reference
**ref_out
,
1252 git_repository
*repo
,
1258 git_reference
*ref
= NULL
;
1259 char normalized
[GIT_REFNAME_MAX
];
1261 if (git_reference__normalize_name_lax(
1267 if ((error
= reference_can_write(repo
, normalized
, NULL
, force
)) < 0)
1270 if (reference_alloc(&ref
, repo
, name
) < 0)
1273 ref
->flags
|= GIT_REF_OID
;
1275 /* set the oid; this will write the reference on disk */
1276 if (git_reference_set_oid(ref
, id
) < 0) {
1277 git_reference_free(ref
);
1281 if (ref_out
== NULL
) {
1282 git_reference_free(ref
);
1290 * Change the OID target of a reference.
1292 * For both loose and packed references, just change
1293 * the oid in memory and (over)write the file in disk.
1295 * We do not repack packed references because of performance
1298 int git_reference_set_oid(git_reference
*ref
, const git_oid
*id
)
1300 git_odb
*odb
= NULL
;
1302 if ((ref
->flags
& GIT_REF_OID
) == 0) {
1303 giterr_set(GITERR_REFERENCE
, "Cannot set OID on symbolic reference");
1309 if (git_repository_odb__weakptr(&odb
, ref
->owner
) < 0)
1312 /* Don't let the user create references to OIDs that
1313 * don't exist in the ODB */
1314 if (!git_odb_exists(odb
, id
)) {
1315 giterr_set(GITERR_REFERENCE
,
1316 "Target OID for the reference doesn't exist on the repository");
1320 /* Update the OID value on `ref` */
1321 git_oid_cpy(&ref
->target
.oid
, id
);
1323 /* Write back to disk */
1324 return loose_write(ref
);
1328 * Change the target of a symbolic reference.
1330 * This is easy because symrefs cannot be inside
1331 * a pack. We just change the target in memory
1332 * and overwrite the file on disk.
1334 int git_reference_set_target(git_reference
*ref
, const char *target
)
1336 char normalized
[GIT_REFNAME_MAX
];
1338 if ((ref
->flags
& GIT_REF_SYMBOLIC
) == 0) {
1339 giterr_set(GITERR_REFERENCE
,
1340 "Cannot set symbolic target on a direct reference");
1344 if (git_reference__normalize_name_lax(
1350 git__free(ref
->target
.symbolic
);
1351 ref
->target
.symbolic
= git__strdup(normalized
);
1352 GITERR_CHECK_ALLOC(ref
->target
.symbolic
);
1354 return loose_write(ref
);
1357 int git_reference_rename(git_reference
*ref
, const char *new_name
, int force
)
1360 unsigned int normalization_flags
;
1361 git_buf aux_path
= GIT_BUF_INIT
;
1362 char normalized
[GIT_REFNAME_MAX
];
1363 bool should_head_be_updated
= false;
1365 normalization_flags
= ref
->flags
& GIT_REF_SYMBOLIC
?
1366 GIT_REF_FORMAT_ALLOW_ONELEVEL
1367 : GIT_REF_FORMAT_NORMAL
;
1369 if (git_reference_normalize_name(
1373 normalization_flags
) < 0)
1376 if ((result
= reference_can_write(ref
->owner
, normalized
, ref
->name
, force
)) < 0)
1379 /* Initialize path now so we won't get an allocation failure once
1380 * we actually start removing things. */
1381 if (git_buf_joinpath(&aux_path
, ref
->owner
->path_repository
, new_name
) < 0)
1385 * Check if we have to update HEAD.
1387 if ((should_head_be_updated
= git_branch_is_head(ref
)) < 0)
1391 * Now delete the old ref and remove an possibly existing directory
1392 * named `new_name`. Note that using the internal `reference_delete`
1393 * method deletes the ref from disk but doesn't free the pointer, so
1394 * we can still access the ref's attributes for creating the new one
1396 if (reference_delete(ref
) < 0)
1400 * Finally we can create the new reference.
1402 if (ref
->flags
& GIT_REF_SYMBOLIC
) {
1403 result
= git_reference_create_symbolic(
1404 NULL
, ref
->owner
, new_name
, ref
->target
.symbolic
, force
);
1406 result
= git_reference_create_oid(
1407 NULL
, ref
->owner
, new_name
, &ref
->target
.oid
, force
);
1414 * Update HEAD it was poiting to the reference being renamed.
1416 if (should_head_be_updated
&&
1417 git_repository_set_head(ref
->owner
, new_name
) < 0) {
1418 giterr_set(GITERR_REFERENCE
,
1419 "Failed to update HEAD after renaming reference");
1424 * Rename the reflog file, if it exists.
1426 if ((git_reference_has_log(ref
)) && (git_reflog_rename(ref
, new_name
) < 0))
1430 * Change the name of the reference given by the user.
1432 git__free(ref
->name
);
1433 ref
->name
= git__strdup(new_name
);
1435 /* The reference is no longer packed */
1436 ref
->flags
&= ~GIT_REF_PACKED
;
1438 git_buf_free(&aux_path
);
1442 git_buf_free(&aux_path
);
1447 * Try to create the old reference again, ignore failures
1449 if (ref
->flags
& GIT_REF_SYMBOLIC
)
1450 git_reference_create_symbolic(
1451 NULL
, ref
->owner
, ref
->name
, ref
->target
.symbolic
, 0);
1453 git_reference_create_oid(
1454 NULL
, ref
->owner
, ref
->name
, &ref
->target
.oid
, 0);
1456 /* The reference is no longer packed */
1457 ref
->flags
&= ~GIT_REF_PACKED
;
1459 git_buf_free(&aux_path
);
1463 int git_reference_resolve(git_reference
**ref_out
, git_reference
*ref
)
1465 if (ref
->flags
& GIT_REF_OID
)
1466 return git_reference_lookup(ref_out
, ref
->owner
, ref
->name
);
1468 return git_reference_lookup_resolved(ref_out
, ref
->owner
, ref
->target
.symbolic
, -1);
1471 int git_reference_packall(git_repository
*repo
)
1473 if (packed_load(repo
) < 0 || /* load the existing packfile */
1474 packed_loadloose(repo
) < 0 || /* add all the loose refs */
1475 packed_write(repo
) < 0) /* write back to disk */
1481 int git_reference_foreach(
1482 git_repository
*repo
,
1483 unsigned int list_flags
,
1484 int (*callback
)(const char *, void *),
1488 struct dirent_list_data data
;
1489 git_buf refs_path
= GIT_BUF_INIT
;
1491 /* list all the packed references first */
1492 if (list_flags
& GIT_REF_PACKED
) {
1493 const char *ref_name
;
1497 if (packed_load(repo
) < 0)
1500 git_strmap_foreach(repo
->references
.packfile
, ref_name
, ref
, {
1501 if (callback(ref_name
, payload
))
1506 /* now list the loose references, trying not to
1507 * duplicate the ref names already in the packed-refs file */
1509 data
.repo_path_len
= strlen(repo
->path_repository
);
1510 data
.list_flags
= list_flags
;
1512 data
.callback
= callback
;
1513 data
.callback_payload
= payload
;
1514 data
.callback_error
= 0;
1516 if (git_buf_joinpath(&refs_path
, repo
->path_repository
, GIT_REFS_DIR
) < 0)
1519 result
= git_path_direach(&refs_path
, _dirent_loose_listall
, &data
);
1521 git_buf_free(&refs_path
);
1523 return data
.callback_error
? GIT_EUSER
: result
;
1526 static int cb__reflist_add(const char *ref
, void *data
)
1528 return git_vector_insert((git_vector
*)data
, git__strdup(ref
));
1531 int git_reference_list(
1532 git_strarray
*array
,
1533 git_repository
*repo
,
1534 unsigned int list_flags
)
1536 git_vector ref_list
;
1538 assert(array
&& repo
);
1540 array
->strings
= NULL
;
1543 if (git_vector_init(&ref_list
, 8, NULL
) < 0)
1546 if (git_reference_foreach(
1547 repo
, list_flags
, &cb__reflist_add
, (void *)&ref_list
) < 0) {
1548 git_vector_free(&ref_list
);
1552 array
->strings
= (char **)ref_list
.contents
;
1553 array
->count
= ref_list
.length
;
1557 int git_reference_reload(git_reference
*ref
)
1559 return reference_lookup(ref
);
1562 void git_repository__refcache_free(git_refcache
*refs
)
1566 if (refs
->packfile
) {
1567 struct packref
*reference
;
1569 git_strmap_foreach_value(refs
->packfile
, reference
, {
1570 git__free(reference
);
1573 git_strmap_free(refs
->packfile
);
1577 static int is_valid_ref_char(char ch
)
1579 if ((unsigned) ch
<= ' ')
1596 static int ensure_segment_validity(const char *name
)
1598 const char *current
= name
;
1601 if (*current
== '.')
1602 return -1; /* Refname starts with "." */
1604 for (current
= name
; ; current
++) {
1605 if (*current
== '\0' || *current
== '/')
1608 if (!is_valid_ref_char(*current
))
1609 return -1; /* Illegal character in refname */
1611 if (prev
== '.' && *current
== '.')
1612 return -1; /* Refname contains ".." */
1614 if (prev
== '@' && *current
== '{')
1615 return -1; /* Refname contains "@{" */
1620 return (int)(current
- name
);
1623 static bool is_all_caps_and_underscore(const char *name
, size_t len
)
1628 assert(name
&& len
> 0);
1630 for (i
= 0; i
< len
; i
++)
1633 if ((c
< 'A' || c
> 'Z') && c
!= '_')
1637 if (*name
== '_' || name
[len
- 1] == '_')
1643 int git_reference__normalize_name(
1648 // Inspired from https://github.com/git/git/blob/f06d47e7e0d9db709ee204ed13a8a7486149f494/refs.c#L36-100
1651 int segment_len
, segments_count
= 0, error
= -1;
1652 unsigned int process_flags
;
1653 bool normalize
= (buf
!= NULL
);
1656 process_flags
= flags
;
1657 current
= (char *)name
;
1663 segment_len
= ensure_segment_validity(current
);
1664 if (segment_len
< 0) {
1665 if ((process_flags
& GIT_REF_FORMAT_REFSPEC_PATTERN
) &&
1666 current
[0] == '*' &&
1667 (current
[1] == '\0' || current
[1] == '/')) {
1668 /* Accept one wildcard as a full refname component. */
1669 process_flags
&= ~GIT_REF_FORMAT_REFSPEC_PATTERN
;
1675 if (segment_len
> 0) {
1677 size_t cur_len
= git_buf_len(buf
);
1679 git_buf_joinpath(buf
, git_buf_cstr(buf
), current
);
1680 git_buf_truncate(buf
,
1681 cur_len
+ segment_len
+ (segments_count
? 1 : 0));
1683 if (git_buf_oom(buf
))
1690 if (current
[segment_len
] == '\0')
1693 current
+= segment_len
+ 1;
1696 /* A refname can not be empty */
1697 if (segment_len
== 0 && segments_count
== 0)
1700 /* A refname can not end with "." */
1701 if (current
[segment_len
- 1] == '.')
1704 /* A refname can not end with "/" */
1705 if (current
[segment_len
- 1] == '/')
1708 /* A refname can not end with ".lock" */
1709 if (!git__suffixcmp(name
, GIT_FILELOCK_EXTENSION
))
1712 if ((segments_count
== 1 ) && !(flags
& GIT_REF_FORMAT_ALLOW_ONELEVEL
))
1715 if ((segments_count
== 1 ) &&
1716 !(is_all_caps_and_underscore(name
, (size_t)segment_len
) ||
1717 ((flags
& GIT_REF_FORMAT_REFSPEC_PATTERN
) && !strcmp("*", name
))))
1720 if ((segments_count
> 1)
1721 && (is_all_caps_and_underscore(name
, strchr(name
, '/') - name
)))
1730 "The given reference name '%s' is not valid", name
);
1735 int git_reference_normalize_name(
1741 git_buf buf
= GIT_BUF_INIT
;
1744 if ((error
= git_reference__normalize_name(&buf
, name
, flags
)) < 0)
1747 if (git_buf_len(&buf
) > buffer_size
- 1) {
1750 "The provided buffer is too short to hold the normalization of '%s'", name
);
1755 git_buf_copy_cstr(buffer_out
, buffer_size
, &buf
);
1764 int git_reference__normalize_name_lax(
1769 return git_reference_normalize_name(
1773 GIT_REF_FORMAT_ALLOW_ONELEVEL
);
1775 #define GIT_REF_TYPEMASK (GIT_REF_OID | GIT_REF_SYMBOLIC)
1777 int git_reference_cmp(git_reference
*ref1
, git_reference
*ref2
)
1779 assert(ref1
&& ref2
);
1781 /* let's put symbolic refs before OIDs */
1782 if ((ref1
->flags
& GIT_REF_TYPEMASK
) != (ref2
->flags
& GIT_REF_TYPEMASK
))
1783 return (ref1
->flags
& GIT_REF_SYMBOLIC
) ? -1 : 1;
1785 if (ref1
->flags
& GIT_REF_SYMBOLIC
)
1786 return strcmp(ref1
->target
.symbolic
, ref2
->target
.symbolic
);
1788 return git_oid_cmp(&ref1
->target
.oid
, &ref2
->target
.oid
);
1791 /* Update the reference named `ref_name` so it points to `oid` */
1792 int git_reference__update(git_repository
*repo
, const git_oid
*oid
, const char *ref_name
)
1797 res
= git_reference_lookup(&ref
, repo
, ref_name
);
1799 /* If we haven't found the reference at all, we assume we need to create
1800 * a new reference and that's it */
1801 if (res
== GIT_ENOTFOUND
) {
1803 return git_reference_create_oid(NULL
, repo
, ref_name
, oid
, 1);
1809 /* If we have found a reference, but it's symbolic, we need to update
1810 * the direct reference it points to */
1811 if (git_reference_type(ref
) == GIT_REF_SYMBOLIC
) {
1813 const char *sym_target
;
1815 /* The target pointed at by this reference */
1816 sym_target
= git_reference_target(ref
);
1818 /* resolve the reference to the target it points to */
1819 res
= git_reference_resolve(&aux
, ref
);
1822 * if the symbolic reference pointed to an inexisting ref,
1823 * this is means we're creating a new branch, for example.
1824 * We need to create a new direct reference with that name
1826 if (res
== GIT_ENOTFOUND
) {
1828 res
= git_reference_create_oid(NULL
, repo
, sym_target
, oid
, 1);
1829 git_reference_free(ref
);
1833 /* free the original symbolic reference now; not before because
1834 * we're using the `sym_target` pointer */
1835 git_reference_free(ref
);
1840 /* store the newly found direct reference in its place */
1844 /* ref is made to point to `oid`: ref is either the original reference,
1845 * or the target of the symbolic reference we've looked up */
1846 res
= git_reference_set_oid(ref
, oid
);
1847 git_reference_free(ref
);
1851 struct glob_cb_data
{
1853 int (*callback
)(const char *, void *);
1857 static int fromglob_cb(const char *reference_name
, void *payload
)
1859 struct glob_cb_data
*data
= (struct glob_cb_data
*)payload
;
1861 if (!p_fnmatch(data
->glob
, reference_name
, 0))
1862 return data
->callback(reference_name
, data
->payload
);
1867 int git_reference_foreach_glob(
1868 git_repository
*repo
,
1870 unsigned int list_flags
,
1872 const char *reference_name
,
1876 struct glob_cb_data data
;
1878 assert(repo
&& glob
&& callback
);
1881 data
.callback
= callback
;
1882 data
.payload
= payload
;
1884 return git_reference_foreach(
1885 repo
, list_flags
, fromglob_cb
, &data
);
1888 int git_reference_has_log(
1891 git_buf path
= GIT_BUF_INIT
;
1896 if (git_buf_join_n(&path
, '/', 3, ref
->owner
->path_repository
, GIT_REFLOG_DIR
, ref
->name
) < 0)
1899 result
= git_path_isfile(git_buf_cstr(&path
));
1900 git_buf_free(&path
);
1905 int git_reference_is_branch(git_reference
*ref
)
1908 return git__prefixcmp(ref
->name
, GIT_REFS_HEADS_DIR
) == 0;
1911 int git_reference_is_remote(git_reference
*ref
)
1914 return git__prefixcmp(ref
->name
, GIT_REFS_REMOTES_DIR
) == 0;
1917 static int peel_error(int error
, git_reference
*ref
, const char* msg
)
1921 "The reference '%s' cannot be peeled - %s", git_reference_name(ref
), msg
);
1925 static int reference_target(git_object
**object
, git_reference
*ref
)
1929 oid
= git_reference_oid(ref
);
1931 return git_object_lookup(object
, git_reference_owner(ref
), oid
, GIT_OBJ_ANY
);
1934 int git_reference_peel(
1935 git_object
**peeled
,
1937 git_otype target_type
)
1939 git_reference
*resolved
= NULL
;
1940 git_object
*target
= NULL
;
1945 if ((error
= git_reference_resolve(&resolved
, ref
)) < 0)
1946 return peel_error(error
, ref
, "Cannot resolve reference");
1948 if ((error
= reference_target(&target
, resolved
)) < 0) {
1949 peel_error(error
, ref
, "Cannot retrieve reference target");
1953 if (target_type
== GIT_OBJ_ANY
&& git_object_type(target
) != GIT_OBJ_TAG
)
1954 error
= git_object__dup(peeled
, target
);
1956 error
= git_object_peel(peeled
, target
, target_type
);
1959 git_object_free(target
);
1960 git_reference_free(resolved
);
1964 int git_reference__is_valid_name(
1965 const char *refname
,
1969 return git_reference__normalize_name(NULL
, refname
, flags
) == 0;
1972 int git_reference_is_valid_name(
1973 const char *refname
)
1975 return git_reference__is_valid_name(
1977 GIT_REF_FORMAT_ALLOW_ONELEVEL
);