2 * The backend-independent part of the reference module.
11 #include "refs/refs-internal.h"
12 #include "run-command.h"
14 #include "object-store.h"
17 #include "submodule.h"
20 #include "repository.h"
26 * List of all available backends
28 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
30 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
32 struct ref_storage_be
*be
;
33 for (be
= refs_backends
; be
; be
= be
->next
)
34 if (!strcmp(be
->name
, name
))
40 * How to handle various characters in refnames:
41 * 0: An acceptable character for refs
43 * 2: ., look for a preceding . to reject .. in refs
44 * 3: {, look for a preceding @ to reject @{ in refs
45 * 4: A bad character: ASCII control characters, and
46 * ":", "?", "[", "\", "^", "~", SP, or TAB
47 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
49 static unsigned char refname_disposition
[256] = {
50 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
51 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
52 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
56 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
57 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
60 struct ref_namespace_info ref_namespace
[] = {
63 .decoration
= DECORATION_REF_HEAD
,
66 [NAMESPACE_BRANCHES
] = {
68 .decoration
= DECORATION_REF_LOCAL
,
72 .decoration
= DECORATION_REF_TAG
,
74 [NAMESPACE_REMOTE_REFS
] = {
76 * The default refspec for new remotes copies refs from
77 * refs/heads/ on the remote into refs/remotes/<remote>/.
78 * As such, "refs/remotes/" has special handling.
80 .ref
= "refs/remotes/",
81 .decoration
= DECORATION_REF_REMOTE
,
85 * The single ref "refs/stash" stores the latest stash.
86 * Older stashes can be found in the reflog.
90 .decoration
= DECORATION_REF_STASH
,
92 [NAMESPACE_REPLACE
] = {
94 * This namespace allows Git to act as if one object ID
95 * points to the content of another. Unlike the other
96 * ref namespaces, this one can be changed by the
97 * GIT_REPLACE_REF_BASE environment variable. This
98 * .namespace value will be overwritten in setup_git_env().
100 .ref
= "refs/replace/",
101 .decoration
= DECORATION_GRAFTED
,
103 [NAMESPACE_NOTES
] = {
105 * The refs/notes/commit ref points to the tip of a
106 * parallel commit history that adds metadata to commits
107 * in the normal history. This ref can be overwritten
108 * by the core.notesRef config variable or the
109 * GIT_NOTES_REFS environment variable.
111 .ref
= "refs/notes/commit",
114 [NAMESPACE_PREFETCH
] = {
116 * Prefetch refs are written by the background 'fetch'
117 * maintenance task. It allows faster foreground fetches
118 * by advertising these previously-downloaded tips without
119 * updating refs/remotes/ without user intervention.
121 .ref
= "refs/prefetch/",
123 [NAMESPACE_REWRITTEN
] = {
125 * Rewritten refs are used by the 'label' command in the
126 * sequencer. These are particularly useful during an
127 * interactive rebase that uses the 'merge' command.
129 .ref
= "refs/rewritten/",
133 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
135 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
136 if (info
->ref_updated
)
139 info
->ref_updated
= 1;
143 * Try to read one refname component from the front of refname.
144 * Return the length of the component found, or -1 if the component is
145 * not legal. It is legal if it is something reasonable to have under
146 * ".git/refs/"; We do not like it if:
148 * - it begins with ".", or
149 * - it has double dots "..", or
150 * - it has ASCII control characters, or
151 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
152 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
153 * - it ends with a "/", or
154 * - it ends with ".lock", or
155 * - it contains a "@{" portion
157 * When sanitized is not NULL, instead of rejecting the input refname
158 * as an error, try to come up with a usable replacement for the input
161 static int check_refname_component(const char *refname
, int *flags
,
162 struct strbuf
*sanitized
)
166 size_t component_start
= 0; /* garbage - not a reasonable initial value */
169 component_start
= sanitized
->len
;
171 for (cp
= refname
; ; cp
++) {
173 unsigned char disp
= refname_disposition
[ch
];
175 if (sanitized
&& disp
!= 1)
176 strbuf_addch(sanitized
, ch
);
182 if (last
== '.') { /* Refname contains "..". */
184 /* collapse ".." to single "." */
185 strbuf_setlen(sanitized
, sanitized
->len
- 1);
191 if (last
== '@') { /* Refname contains "@{". */
193 sanitized
->buf
[sanitized
->len
-1] = '-';
201 sanitized
->buf
[sanitized
->len
-1] = '-';
206 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
207 /* refspec can't be a pattern */
209 sanitized
->buf
[sanitized
->len
-1] = '-';
215 * Unset the pattern flag so that we only accept
216 * a single asterisk for one side of refspec.
218 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
225 return 0; /* Component has zero length. */
227 if (refname
[0] == '.') { /* Component starts with '.'. */
229 sanitized
->buf
[component_start
] = '-';
233 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
234 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
237 /* Refname ends with ".lock". */
238 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
239 /* try again in case we have .lock.lock */
245 static int check_or_sanitize_refname(const char *refname
, int flags
,
246 struct strbuf
*sanitized
)
248 int component_len
, component_count
= 0;
250 if (!strcmp(refname
, "@")) {
251 /* Refname is a single character '@'. */
253 strbuf_addch(sanitized
, '-');
259 if (sanitized
&& sanitized
->len
)
260 strbuf_complete(sanitized
, '/');
262 /* We are at the start of a path component. */
263 component_len
= check_refname_component(refname
, &flags
,
265 if (sanitized
&& component_len
== 0)
266 ; /* OK, omit empty component */
267 else if (component_len
<= 0)
271 if (refname
[component_len
] == '\0')
273 /* Skip to next component. */
274 refname
+= component_len
+ 1;
277 if (refname
[component_len
- 1] == '.') {
278 /* Refname ends with '.'. */
280 ; /* omit ending dot */
284 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
285 return -1; /* Refname has only one component. */
289 int check_refname_format(const char *refname
, int flags
)
291 return check_or_sanitize_refname(refname
, flags
, NULL
);
294 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
296 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
297 BUG("sanitizing refname '%s' check returned error", refname
);
300 int refname_is_safe(const char *refname
)
304 if (skip_prefix(refname
, "refs/", &rest
)) {
307 size_t restlen
= strlen(rest
);
309 /* rest must not be empty, or start or end with "/" */
310 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
314 * Does the refname try to escape refs/?
315 * For example: refs/foo/../bar is safe but refs/foo/../../bar
318 buf
= xmallocz(restlen
);
319 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
325 if (!isupper(*refname
) && *refname
!= '_')
333 * Return true if refname, which has the specified oid and flags, can
334 * be resolved to an object in the database. If the referred-to object
335 * does not exist, emit a warning and return false.
337 int ref_resolves_to_object(const char *refname
,
338 struct repository
*repo
,
339 const struct object_id
*oid
,
342 if (flags
& REF_ISBROKEN
)
344 if (!repo_has_object_file(repo
, oid
)) {
345 error(_("%s does not point to a valid object!"), refname
);
351 char *refs_resolve_refdup(struct ref_store
*refs
,
352 const char *refname
, int resolve_flags
,
353 struct object_id
*oid
, int *flags
)
357 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
359 return xstrdup_or_null(result
);
362 char *resolve_refdup(const char *refname
, int resolve_flags
,
363 struct object_id
*oid
, int *flags
)
365 return refs_resolve_refdup(get_main_ref_store(the_repository
),
366 refname
, resolve_flags
,
370 /* The argument to filter_refs */
378 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
380 struct ref_store
*refs
= get_main_ref_store(the_repository
);
382 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
388 int read_ref(const char *refname
, struct object_id
*oid
)
390 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
393 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
395 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
399 int ref_exists(const char *refname
)
401 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
404 static int filter_refs(const char *refname
, const struct object_id
*oid
,
405 int flags
, void *data
)
407 struct ref_filter
*filter
= (struct ref_filter
*)data
;
409 if (wildmatch(filter
->pattern
, refname
, 0))
412 skip_prefix(refname
, filter
->prefix
, &refname
);
413 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
416 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
418 struct object
*o
= lookup_unknown_object(the_repository
, name
);
420 if (o
->type
== OBJ_NONE
) {
421 int type
= oid_object_info(the_repository
, name
, NULL
);
422 if (type
< 0 || !object_as_type(o
, type
, 0))
426 if (o
->type
!= OBJ_TAG
)
429 o
= deref_tag_noverify(o
);
433 oidcpy(oid
, &o
->oid
);
437 struct warn_if_dangling_data
{
440 const struct string_list
*refnames
;
444 static int warn_if_dangling_symref(const char *refname
,
445 const struct object_id
*oid UNUSED
,
446 int flags
, void *cb_data
)
448 struct warn_if_dangling_data
*d
= cb_data
;
449 const char *resolves_to
;
451 if (!(flags
& REF_ISSYMREF
))
454 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
457 ? strcmp(resolves_to
, d
->refname
)
458 : !string_list_has_string(d
->refnames
, resolves_to
))) {
462 fprintf(d
->fp
, d
->msg_fmt
, refname
);
467 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
469 struct warn_if_dangling_data data
;
472 data
.refname
= refname
;
473 data
.refnames
= NULL
;
474 data
.msg_fmt
= msg_fmt
;
475 for_each_rawref(warn_if_dangling_symref
, &data
);
478 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
480 struct warn_if_dangling_data data
;
484 data
.refnames
= refnames
;
485 data
.msg_fmt
= msg_fmt
;
486 for_each_rawref(warn_if_dangling_symref
, &data
);
489 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
491 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
494 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
496 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
499 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
501 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
504 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
506 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
509 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
511 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
514 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
516 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
519 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
521 struct strbuf buf
= STRBUF_INIT
;
523 struct object_id oid
;
526 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
527 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
528 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
529 strbuf_release(&buf
);
534 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
537 struct strbuf normalized_pattern
= STRBUF_INIT
;
540 BUG("pattern must not start with '/'");
543 strbuf_addstr(&normalized_pattern
, prefix
);
544 else if (!starts_with(pattern
, "refs/") &&
545 strcmp(pattern
, "HEAD"))
546 strbuf_addstr(&normalized_pattern
, "refs/");
548 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
552 strbuf_addstr(&normalized_pattern
, pattern
);
553 strbuf_strip_suffix(&normalized_pattern
, "/");
555 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
556 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
557 strbuf_release(&normalized_pattern
);
560 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
561 const char *prefix
, void *cb_data
)
563 struct strbuf real_pattern
= STRBUF_INIT
;
564 struct ref_filter filter
;
567 if (!prefix
&& !starts_with(pattern
, "refs/"))
568 strbuf_addstr(&real_pattern
, "refs/");
570 strbuf_addstr(&real_pattern
, prefix
);
571 strbuf_addstr(&real_pattern
, pattern
);
573 if (!has_glob_specials(pattern
)) {
574 /* Append implied '/' '*' if not present. */
575 strbuf_complete(&real_pattern
, '/');
576 /* No need to check for '*', there is none. */
577 strbuf_addch(&real_pattern
, '*');
580 filter
.pattern
= real_pattern
.buf
;
581 filter
.prefix
= prefix
;
583 filter
.cb_data
= cb_data
;
584 ret
= for_each_ref(filter_refs
, &filter
);
586 strbuf_release(&real_pattern
);
590 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
592 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
595 const char *prettify_refname(const char *name
)
597 if (skip_prefix(name
, "refs/heads/", &name
) ||
598 skip_prefix(name
, "refs/tags/", &name
) ||
599 skip_prefix(name
, "refs/remotes/", &name
))
604 static const char *ref_rev_parse_rules
[] = {
610 "refs/remotes/%.*s/HEAD",
614 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
617 * Is it possible that the caller meant full_name with abbrev_name?
618 * If so return a non-zero value to signal "yes"; the magnitude of
619 * the returned value gives the precedence used for disambiguation.
621 * If abbrev_name cannot mean full_name, return 0.
623 int refname_match(const char *abbrev_name
, const char *full_name
)
626 const int abbrev_name_len
= strlen(abbrev_name
);
627 const int num_rules
= NUM_REV_PARSE_RULES
;
629 for (p
= ref_rev_parse_rules
; *p
; p
++)
630 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
631 return &ref_rev_parse_rules
[num_rules
] - p
;
637 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
638 * the results to 'prefixes'
640 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
643 int len
= strlen(prefix
);
645 for (p
= ref_rev_parse_rules
; *p
; p
++)
646 strvec_pushf(prefixes
, *p
, len
, prefix
);
649 static const char default_branch_name_advice
[] = N_(
650 "Using '%s' as the name for the initial branch. This default branch name\n"
651 "is subject to change. To configure the initial branch name to use in all\n"
652 "of your new repositories, which will suppress this warning, call:\n"
654 "\tgit config --global init.defaultBranch <name>\n"
656 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
657 "'development'. The just-created branch can be renamed via this command:\n"
659 "\tgit branch -m <name>\n"
662 char *repo_default_branch_name(struct repository
*r
, int quiet
)
664 const char *config_key
= "init.defaultbranch";
665 const char *config_display_key
= "init.defaultBranch";
666 char *ret
= NULL
, *full_ref
;
667 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
671 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
672 die(_("could not retrieve `%s`"), config_display_key
);
675 ret
= xstrdup("master");
677 advise(_(default_branch_name_advice
), ret
);
680 full_ref
= xstrfmt("refs/heads/%s", ret
);
681 if (check_refname_format(full_ref
, 0))
682 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
688 const char *git_default_branch_name(int quiet
)
693 ret
= repo_default_branch_name(the_repository
, quiet
);
699 * *string and *len will only be substituted, and *string returned (for
700 * later free()ing) if the string passed in is a magic short-hand form
703 static char *substitute_branch_name(struct repository
*r
,
704 const char **string
, int *len
,
705 int nonfatal_dangling_mark
)
707 struct strbuf buf
= STRBUF_INIT
;
708 struct interpret_branch_name_options options
= {
709 .nonfatal_dangling_mark
= nonfatal_dangling_mark
711 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
715 *string
= strbuf_detach(&buf
, &size
);
717 return (char *)*string
;
723 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
724 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
726 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
727 nonfatal_dangling_mark
);
728 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
733 int expand_ref(struct repository
*repo
, const char *str
, int len
,
734 struct object_id
*oid
, char **ref
)
738 struct strbuf fullref
= STRBUF_INIT
;
741 for (p
= ref_rev_parse_rules
; *p
; p
++) {
742 struct object_id oid_from_ref
;
743 struct object_id
*this_result
;
745 struct ref_store
*refs
= get_main_ref_store(repo
);
747 this_result
= refs_found
? &oid_from_ref
: oid
;
748 strbuf_reset(&fullref
);
749 strbuf_addf(&fullref
, *p
, len
, str
);
750 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
756 if (!warn_ambiguous_refs
)
758 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
759 warning(_("ignoring dangling symref %s"), fullref
.buf
);
760 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
761 warning(_("ignoring broken ref %s"), fullref
.buf
);
764 strbuf_release(&fullref
);
768 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
769 struct object_id
*oid
, char **log
)
771 struct ref_store
*refs
= get_main_ref_store(r
);
772 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
775 struct strbuf path
= STRBUF_INIT
;
778 for (p
= ref_rev_parse_rules
; *p
; p
++) {
779 struct object_id hash
;
780 const char *ref
, *it
;
783 strbuf_addf(&path
, *p
, len
, str
);
784 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
786 oid
? &hash
: NULL
, NULL
);
789 if (refs_reflog_exists(refs
, path
.buf
))
791 else if (strcmp(ref
, path
.buf
) &&
792 refs_reflog_exists(refs
, ref
))
801 if (!warn_ambiguous_refs
)
804 strbuf_release(&path
);
809 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
811 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
814 int is_per_worktree_ref(const char *refname
)
816 return starts_with(refname
, "refs/worktree/") ||
817 starts_with(refname
, "refs/bisect/") ||
818 starts_with(refname
, "refs/rewritten/");
821 static int is_pseudoref_syntax(const char *refname
)
825 for (c
= refname
; *c
; c
++) {
826 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
831 * HEAD is not a pseudoref, but it certainly uses the
837 static int is_current_worktree_ref(const char *ref
) {
838 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
841 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
842 const char **worktree_name
, int *worktree_name_length
,
843 const char **bare_refname
)
845 const char *name_dummy
;
846 int name_length_dummy
;
847 const char *ref_dummy
;
850 worktree_name
= &name_dummy
;
851 if (!worktree_name_length
)
852 worktree_name_length
= &name_length_dummy
;
854 bare_refname
= &ref_dummy
;
856 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
857 const char *slash
= strchr(*bare_refname
, '/');
859 *worktree_name
= *bare_refname
;
861 *worktree_name_length
= strlen(*worktree_name
);
863 /* This is an error condition, and the caller tell because the bare_refname is "" */
864 *bare_refname
= *worktree_name
+ *worktree_name_length
;
865 return REF_WORKTREE_OTHER
;
868 *worktree_name_length
= slash
- *bare_refname
;
869 *bare_refname
= slash
+ 1;
871 if (is_current_worktree_ref(*bare_refname
))
872 return REF_WORKTREE_OTHER
;
875 *worktree_name
= NULL
;
876 *worktree_name_length
= 0;
878 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
879 && is_current_worktree_ref(*bare_refname
))
880 return REF_WORKTREE_MAIN
;
882 *bare_refname
= maybe_worktree_ref
;
883 if (is_current_worktree_ref(maybe_worktree_ref
))
884 return REF_WORKTREE_CURRENT
;
886 return REF_WORKTREE_SHARED
;
889 long get_files_ref_lock_timeout_ms(void)
891 static int configured
= 0;
893 /* The default timeout is 100 ms: */
894 static int timeout_ms
= 100;
897 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
904 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
906 const struct object_id
*old_oid
,
909 struct ref_transaction
*transaction
;
910 struct strbuf err
= STRBUF_INIT
;
912 transaction
= ref_store_transaction_begin(refs
, &err
);
914 ref_transaction_delete(transaction
, refname
, old_oid
,
916 ref_transaction_commit(transaction
, &err
)) {
917 error("%s", err
.buf
);
918 ref_transaction_free(transaction
);
919 strbuf_release(&err
);
922 ref_transaction_free(transaction
);
923 strbuf_release(&err
);
927 int delete_ref(const char *msg
, const char *refname
,
928 const struct object_id
*old_oid
, unsigned int flags
)
930 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
934 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
939 while ((c
= *msg
++)) {
940 if (wasspace
&& isspace(c
))
942 wasspace
= isspace(c
);
950 static char *normalize_reflog_message(const char *msg
)
952 struct strbuf sb
= STRBUF_INIT
;
955 copy_reflog_msg(&sb
, msg
);
956 return strbuf_detach(&sb
, NULL
);
959 int should_autocreate_reflog(const char *refname
)
961 switch (log_all_ref_updates
) {
962 case LOG_REFS_ALWAYS
:
964 case LOG_REFS_NORMAL
:
965 return starts_with(refname
, "refs/heads/") ||
966 starts_with(refname
, "refs/remotes/") ||
967 starts_with(refname
, "refs/notes/") ||
968 !strcmp(refname
, "HEAD");
974 int is_branch(const char *refname
)
976 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
979 struct read_ref_at_cb
{
984 struct object_id
*oid
;
987 struct object_id ooid
;
988 struct object_id noid
;
992 timestamp_t
*cutoff_time
;
997 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
998 timestamp_t timestamp
, int tz
, const char *message
)
1001 *cb
->msg
= xstrdup(message
);
1002 if (cb
->cutoff_time
)
1003 *cb
->cutoff_time
= timestamp
;
1005 *cb
->cutoff_tz
= tz
;
1007 *cb
->cutoff_cnt
= cb
->reccnt
;
1010 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1011 const char *email UNUSED
,
1012 timestamp_t timestamp
, int tz
,
1013 const char *message
, void *cb_data
)
1015 struct read_ref_at_cb
*cb
= cb_data
;
1019 cb
->date
= timestamp
;
1022 * It is not possible for cb->cnt == 0 on the first iteration because
1023 * that special case is handled in read_ref_at().
1027 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
1028 if (timestamp
<= cb
->at_time
|| reached_count
) {
1029 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1031 * we have not yet updated cb->[n|o]oid so they still
1032 * hold the values for the previous record.
1034 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
1035 warning(_("log for ref %s has gap after %s"),
1036 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1038 oidcpy(cb
->oid
, ooid
);
1039 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
1040 oidcpy(cb
->oid
, noid
);
1041 else if (!oideq(noid
, cb
->oid
))
1042 warning(_("log for ref %s unexpectedly ended on %s"),
1043 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1044 DATE_MODE(RFC2822
)));
1048 oidcpy(&cb
->ooid
, ooid
);
1049 oidcpy(&cb
->noid
, noid
);
1050 return cb
->found_it
;
1053 static int read_ref_at_ent_newest(struct object_id
*ooid UNUSED
,
1054 struct object_id
*noid
,
1055 const char *email UNUSED
,
1056 timestamp_t timestamp
, int tz
,
1057 const char *message
, void *cb_data
)
1059 struct read_ref_at_cb
*cb
= cb_data
;
1061 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1062 oidcpy(cb
->oid
, noid
);
1063 /* We just want the first entry */
1067 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1068 const char *email UNUSED
,
1069 timestamp_t timestamp
, int tz
,
1070 const char *message
, void *cb_data
)
1072 struct read_ref_at_cb
*cb
= cb_data
;
1074 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1075 oidcpy(cb
->oid
, ooid
);
1076 if (is_null_oid(cb
->oid
))
1077 oidcpy(cb
->oid
, noid
);
1078 /* We just want the first entry */
1082 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1083 unsigned int flags
, timestamp_t at_time
, int cnt
,
1084 struct object_id
*oid
, char **msg
,
1085 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1087 struct read_ref_at_cb cb
;
1089 memset(&cb
, 0, sizeof(cb
));
1090 cb
.refname
= refname
;
1091 cb
.at_time
= at_time
;
1094 cb
.cutoff_time
= cutoff_time
;
1095 cb
.cutoff_tz
= cutoff_tz
;
1096 cb
.cutoff_cnt
= cutoff_cnt
;
1100 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
1104 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1107 if (flags
& GET_OID_QUIETLY
)
1110 die(_("log for %s is empty"), refname
);
1115 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1120 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1123 struct ref_transaction
*tr
;
1126 CALLOC_ARRAY(tr
, 1);
1127 tr
->ref_store
= refs
;
1131 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1133 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1136 void ref_transaction_free(struct ref_transaction
*transaction
)
1143 switch (transaction
->state
) {
1144 case REF_TRANSACTION_OPEN
:
1145 case REF_TRANSACTION_CLOSED
:
1148 case REF_TRANSACTION_PREPARED
:
1149 BUG("free called on a prepared reference transaction");
1152 BUG("unexpected reference transaction state");
1156 for (i
= 0; i
< transaction
->nr
; i
++) {
1157 free(transaction
->updates
[i
]->msg
);
1158 free(transaction
->updates
[i
]);
1160 free(transaction
->updates
);
1164 struct ref_update
*ref_transaction_add_update(
1165 struct ref_transaction
*transaction
,
1166 const char *refname
, unsigned int flags
,
1167 const struct object_id
*new_oid
,
1168 const struct object_id
*old_oid
,
1171 struct ref_update
*update
;
1173 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1174 BUG("update called for transaction that is not open");
1176 FLEX_ALLOC_STR(update
, refname
, refname
);
1177 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1178 transaction
->updates
[transaction
->nr
++] = update
;
1180 update
->flags
= flags
;
1182 if (flags
& REF_HAVE_NEW
)
1183 oidcpy(&update
->new_oid
, new_oid
);
1184 if (flags
& REF_HAVE_OLD
)
1185 oidcpy(&update
->old_oid
, old_oid
);
1186 update
->msg
= normalize_reflog_message(msg
);
1190 int ref_transaction_update(struct ref_transaction
*transaction
,
1191 const char *refname
,
1192 const struct object_id
*new_oid
,
1193 const struct object_id
*old_oid
,
1194 unsigned int flags
, const char *msg
,
1199 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1200 ((new_oid
&& !is_null_oid(new_oid
)) ?
1201 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1202 !refname_is_safe(refname
))) {
1203 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1208 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1209 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1212 * Clear flags outside the allowed set; this should be a noop because
1213 * of the BUG() check above, but it works around a -Wnonnull warning
1214 * with some versions of "gcc -O3".
1216 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1218 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1220 ref_transaction_add_update(transaction
, refname
, flags
,
1221 new_oid
, old_oid
, msg
);
1225 int ref_transaction_create(struct ref_transaction
*transaction
,
1226 const char *refname
,
1227 const struct object_id
*new_oid
,
1228 unsigned int flags
, const char *msg
,
1231 if (!new_oid
|| is_null_oid(new_oid
)) {
1232 strbuf_addf(err
, "'%s' has a null OID", refname
);
1235 return ref_transaction_update(transaction
, refname
, new_oid
,
1236 null_oid(), flags
, msg
, err
);
1239 int ref_transaction_delete(struct ref_transaction
*transaction
,
1240 const char *refname
,
1241 const struct object_id
*old_oid
,
1242 unsigned int flags
, const char *msg
,
1245 if (old_oid
&& is_null_oid(old_oid
))
1246 BUG("delete called with old_oid set to zeros");
1247 return ref_transaction_update(transaction
, refname
,
1248 null_oid(), old_oid
,
1252 int ref_transaction_verify(struct ref_transaction
*transaction
,
1253 const char *refname
,
1254 const struct object_id
*old_oid
,
1259 BUG("verify called with old_oid set to NULL");
1260 return ref_transaction_update(transaction
, refname
,
1265 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1266 const char *refname
, const struct object_id
*new_oid
,
1267 const struct object_id
*old_oid
, unsigned int flags
,
1268 enum action_on_err onerr
)
1270 struct ref_transaction
*t
= NULL
;
1271 struct strbuf err
= STRBUF_INIT
;
1274 t
= ref_store_transaction_begin(refs
, &err
);
1276 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1278 ref_transaction_commit(t
, &err
)) {
1280 ref_transaction_free(t
);
1283 const char *str
= _("update_ref failed for ref '%s': %s");
1286 case UPDATE_REFS_MSG_ON_ERR
:
1287 error(str
, refname
, err
.buf
);
1289 case UPDATE_REFS_DIE_ON_ERR
:
1290 die(str
, refname
, err
.buf
);
1292 case UPDATE_REFS_QUIET_ON_ERR
:
1295 strbuf_release(&err
);
1298 strbuf_release(&err
);
1300 ref_transaction_free(t
);
1304 int update_ref(const char *msg
, const char *refname
,
1305 const struct object_id
*new_oid
,
1306 const struct object_id
*old_oid
,
1307 unsigned int flags
, enum action_on_err onerr
)
1309 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1310 old_oid
, flags
, onerr
);
1313 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1314 const char *refname
, int strict
)
1317 static char **scanf_fmts
;
1319 struct strbuf resolved_buf
= STRBUF_INIT
;
1323 * Pre-generate scanf formats from ref_rev_parse_rules[].
1324 * Generate a format suitable for scanf from a
1325 * ref_rev_parse_rules rule by interpolating "%s" at the
1326 * location of the "%.*s".
1328 size_t total_len
= 0;
1331 for (i
= 0; i
< NUM_REV_PARSE_RULES
; i
++)
1332 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1333 total_len
+= strlen(ref_rev_parse_rules
[i
]) - 2 + 1;
1335 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), NUM_REV_PARSE_RULES
), total_len
));
1338 for (i
= 0; i
< NUM_REV_PARSE_RULES
; i
++) {
1339 assert(offset
< total_len
);
1340 scanf_fmts
[i
] = (char *)&scanf_fmts
[NUM_REV_PARSE_RULES
] + offset
;
1341 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1342 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1346 /* buffer for scanf result, at most refname must fit */
1347 short_name
= xstrdup(refname
);
1349 /* skip first rule, it will always match */
1350 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1352 int rules_to_fail
= i
;
1353 size_t short_name_len
;
1355 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1358 short_name_len
= strlen(short_name
);
1361 * in strict mode, all (except the matched one) rules
1362 * must fail to resolve to a valid non-ambiguous ref
1365 rules_to_fail
= NUM_REV_PARSE_RULES
;
1368 * check if the short name resolves to a valid ref,
1369 * but use only rules prior to the matched one
1371 for (j
= 0; j
< rules_to_fail
; j
++) {
1372 const char *rule
= ref_rev_parse_rules
[j
];
1374 /* skip matched rule */
1379 * the short name is ambiguous, if it resolves
1380 * (with this previous rule) to a valid ref
1381 * read_ref() returns 0 on success
1383 strbuf_reset(&resolved_buf
);
1384 strbuf_addf(&resolved_buf
, rule
,
1385 cast_size_t_to_int(short_name_len
),
1387 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1392 * short name is non-ambiguous if all previous rules
1393 * haven't resolved to a valid ref
1395 if (j
== rules_to_fail
) {
1396 strbuf_release(&resolved_buf
);
1401 strbuf_release(&resolved_buf
);
1403 return xstrdup(refname
);
1406 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1408 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1412 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1413 struct string_list
*hide_refs
)
1416 if (!strcmp("transfer.hiderefs", var
) ||
1417 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1418 !strcmp(key
, "hiderefs"))) {
1423 return config_error_nonbool(var
);
1424 ref
= xstrdup(value
);
1426 while (len
&& ref
[len
- 1] == '/')
1428 string_list_append_nodup(hide_refs
, ref
);
1433 int ref_is_hidden(const char *refname
, const char *refname_full
,
1434 const struct string_list
*hide_refs
)
1438 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1439 const char *match
= hide_refs
->items
[i
].string
;
1440 const char *subject
;
1444 if (*match
== '!') {
1449 if (*match
== '^') {
1450 subject
= refname_full
;
1456 /* refname can be NULL when namespaces are used. */
1458 skip_prefix(subject
, match
, &p
) &&
1465 const char *find_descendant_ref(const char *dirname
,
1466 const struct string_list
*extras
,
1467 const struct string_list
*skip
)
1475 * Look at the place where dirname would be inserted into
1476 * extras. If there is an entry at that position that starts
1477 * with dirname (remember, dirname includes the trailing
1478 * slash) and is not in skip, then we have a conflict.
1480 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1481 pos
< extras
->nr
; pos
++) {
1482 const char *extra_refname
= extras
->items
[pos
].string
;
1484 if (!starts_with(extra_refname
, dirname
))
1487 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1488 return extra_refname
;
1493 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1495 struct object_id oid
;
1498 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1500 return fn("HEAD", &oid
, flag
, cb_data
);
1505 int head_ref(each_ref_fn fn
, void *cb_data
)
1507 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1510 struct ref_iterator
*refs_ref_iterator_begin(
1511 struct ref_store
*refs
,
1512 const char *prefix
, int trim
,
1513 enum do_for_each_ref_flags flags
)
1515 struct ref_iterator
*iter
;
1517 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1518 static int ref_paranoia
= -1;
1520 if (ref_paranoia
< 0)
1521 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1523 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1524 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1528 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1531 * `iterator_begin()` already takes care of prefix, but we
1532 * might need to do some trimming:
1535 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1537 /* Sanity check for subclasses: */
1539 BUG("reference iterator is not ordered");
1545 * Call fn for each reference in the specified submodule for which the
1546 * refname begins with prefix. If trim is non-zero, then trim that
1547 * many characters off the beginning of each refname before passing
1548 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1549 * include broken references in the iteration. If fn ever returns a
1550 * non-zero value, stop the iteration and return that value;
1551 * otherwise, return 0.
1553 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1554 each_repo_ref_fn fn
, int trim
, int flags
,
1557 struct ref_iterator
*iter
;
1558 struct ref_store
*refs
= get_main_ref_store(r
);
1563 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1565 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1568 struct do_for_each_ref_help
{
1573 static int do_for_each_ref_helper(struct repository
*r
,
1574 const char *refname
,
1575 const struct object_id
*oid
,
1579 struct do_for_each_ref_help
*hp
= cb_data
;
1581 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1584 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1585 each_ref_fn fn
, int trim
,
1586 enum do_for_each_ref_flags flags
, void *cb_data
)
1588 struct ref_iterator
*iter
;
1589 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1594 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1596 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1597 do_for_each_ref_helper
, &hp
);
1600 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1602 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1605 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1607 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1610 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1611 each_ref_fn fn
, void *cb_data
)
1613 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1616 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1618 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1621 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1623 return do_for_each_ref(get_main_ref_store(the_repository
),
1624 prefix
, fn
, 0, 0, cb_data
);
1627 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1628 each_ref_fn fn
, void *cb_data
)
1630 return do_for_each_ref(refs
, prefix
, fn
, 0, 0, cb_data
);
1633 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1635 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1636 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1637 strlen(git_replace_ref_base
),
1638 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1641 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1643 struct strbuf buf
= STRBUF_INIT
;
1645 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1646 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1647 buf
.buf
, fn
, 0, 0, cb_data
);
1648 strbuf_release(&buf
);
1652 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1654 return do_for_each_ref(refs
, "", fn
, 0,
1655 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1658 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1660 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1663 static int qsort_strcmp(const void *va
, const void *vb
)
1665 const char *a
= *(const char **)va
;
1666 const char *b
= *(const char **)vb
;
1668 return strcmp(a
, b
);
1671 static void find_longest_prefixes_1(struct string_list
*out
,
1672 struct strbuf
*prefix
,
1673 const char **patterns
, size_t nr
)
1677 for (i
= 0; i
< nr
; i
++) {
1678 char c
= patterns
[i
][prefix
->len
];
1679 if (!c
|| is_glob_special(c
)) {
1680 string_list_append(out
, prefix
->buf
);
1690 * Set "end" to the index of the element _after_ the last one
1693 for (end
= i
+ 1; end
< nr
; end
++) {
1694 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1698 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1699 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1700 strbuf_setlen(prefix
, prefix
->len
- 1);
1706 static void find_longest_prefixes(struct string_list
*out
,
1707 const char **patterns
)
1709 struct strvec sorted
= STRVEC_INIT
;
1710 struct strbuf prefix
= STRBUF_INIT
;
1712 strvec_pushv(&sorted
, patterns
);
1713 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1715 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1717 strvec_clear(&sorted
);
1718 strbuf_release(&prefix
);
1721 int for_each_fullref_in_prefixes(const char *namespace,
1722 const char **patterns
,
1723 each_ref_fn fn
, void *cb_data
)
1725 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1726 struct string_list_item
*prefix
;
1727 struct strbuf buf
= STRBUF_INIT
;
1728 int ret
= 0, namespace_len
;
1730 find_longest_prefixes(&prefixes
, patterns
);
1733 strbuf_addstr(&buf
, namespace);
1734 namespace_len
= buf
.len
;
1736 for_each_string_list_item(prefix
, &prefixes
) {
1737 strbuf_addstr(&buf
, prefix
->string
);
1738 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
);
1741 strbuf_setlen(&buf
, namespace_len
);
1744 string_list_clear(&prefixes
, 0);
1745 strbuf_release(&buf
);
1749 static int refs_read_special_head(struct ref_store
*ref_store
,
1750 const char *refname
, struct object_id
*oid
,
1751 struct strbuf
*referent
, unsigned int *type
,
1754 struct strbuf full_path
= STRBUF_INIT
;
1755 struct strbuf content
= STRBUF_INIT
;
1757 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1759 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1762 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1766 strbuf_release(&full_path
);
1767 strbuf_release(&content
);
1771 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1772 struct object_id
*oid
, struct strbuf
*referent
,
1773 unsigned int *type
, int *failure_errno
)
1775 assert(failure_errno
);
1776 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1777 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1778 type
, failure_errno
);
1781 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1782 type
, failure_errno
);
1785 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1786 struct strbuf
*referent
)
1788 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1791 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1792 const char *refname
,
1794 struct object_id
*oid
,
1797 static struct strbuf sb_refname
= STRBUF_INIT
;
1798 struct object_id unused_oid
;
1805 flags
= &unused_flags
;
1809 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1810 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1811 !refname_is_safe(refname
))
1815 * dwim_ref() uses REF_ISBROKEN to distinguish between
1816 * missing refs and refs that were present but invalid,
1817 * to complain about the latter to stderr.
1819 * We don't know whether the ref exists, so don't set
1822 *flags
|= REF_BAD_NAME
;
1825 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1826 unsigned int read_flags
= 0;
1829 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1830 &read_flags
, &failure_errno
)) {
1831 *flags
|= read_flags
;
1833 /* In reading mode, refs must eventually resolve */
1834 if (resolve_flags
& RESOLVE_REF_READING
)
1838 * Otherwise a missing ref is OK. But the files backend
1839 * may show errors besides ENOENT if there are
1840 * similarly-named refs.
1842 if (failure_errno
!= ENOENT
&&
1843 failure_errno
!= EISDIR
&&
1844 failure_errno
!= ENOTDIR
)
1848 if (*flags
& REF_BAD_NAME
)
1849 *flags
|= REF_ISBROKEN
;
1853 *flags
|= read_flags
;
1855 if (!(read_flags
& REF_ISSYMREF
)) {
1856 if (*flags
& REF_BAD_NAME
) {
1858 *flags
|= REF_ISBROKEN
;
1863 refname
= sb_refname
.buf
;
1864 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1868 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1869 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1870 !refname_is_safe(refname
))
1873 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1880 /* backend functions */
1881 int refs_init_db(struct strbuf
*err
)
1883 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1885 return refs
->be
->init_db(refs
, err
);
1888 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1889 struct object_id
*oid
, int *flags
)
1891 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1892 resolve_flags
, oid
, flags
);
1895 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1896 struct object_id
*oid
)
1898 struct ref_store
*refs
;
1901 refs
= get_submodule_ref_store(submodule
);
1906 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1912 struct ref_store_hash_entry
1914 struct hashmap_entry ent
;
1916 struct ref_store
*refs
;
1918 /* NUL-terminated identifier of the ref store: */
1919 char name
[FLEX_ARRAY
];
1922 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
1923 const struct hashmap_entry
*eptr
,
1924 const struct hashmap_entry
*entry_or_key
,
1925 const void *keydata
)
1927 const struct ref_store_hash_entry
*e1
, *e2
;
1930 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1931 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1932 name
= keydata
? keydata
: e2
->name
;
1934 return strcmp(e1
->name
, name
);
1937 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1938 const char *name
, struct ref_store
*refs
)
1940 struct ref_store_hash_entry
*entry
;
1942 FLEX_ALLOC_STR(entry
, name
, name
);
1943 hashmap_entry_init(&entry
->ent
, strhash(name
));
1948 /* A hashmap of ref_stores, stored by submodule name: */
1949 static struct hashmap submodule_ref_stores
;
1951 /* A hashmap of ref_stores, stored by worktree id: */
1952 static struct hashmap worktree_ref_stores
;
1955 * Look up a ref store by name. If that ref_store hasn't been
1956 * registered yet, return NULL.
1958 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1961 struct ref_store_hash_entry
*entry
;
1964 if (!map
->tablesize
)
1965 /* It's initialized on demand in register_ref_store(). */
1968 hash
= strhash(name
);
1969 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1970 struct ref_store_hash_entry
, ent
);
1971 return entry
? entry
->refs
: NULL
;
1975 * Create, record, and return a ref_store instance for the specified
1978 static struct ref_store
*ref_store_init(struct repository
*repo
,
1982 const char *be_name
= "files";
1983 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1984 struct ref_store
*refs
;
1987 BUG("reference backend %s is unknown", be_name
);
1989 refs
= be
->init(repo
, gitdir
, flags
);
1993 struct ref_store
*get_main_ref_store(struct repository
*r
)
1995 if (r
->refs_private
)
1996 return r
->refs_private
;
1999 BUG("attempting to get main_ref_store outside of repository");
2001 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2002 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2003 return r
->refs_private
;
2007 * Associate a ref store with a name. It is a fatal error to call this
2008 * function twice for the same name.
2010 static void register_ref_store_map(struct hashmap
*map
,
2012 struct ref_store
*refs
,
2015 struct ref_store_hash_entry
*entry
;
2017 if (!map
->tablesize
)
2018 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2020 entry
= alloc_ref_store_hash_entry(name
, refs
);
2021 if (hashmap_put(map
, &entry
->ent
))
2022 BUG("%s ref_store '%s' initialized twice", type
, name
);
2025 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2027 struct strbuf submodule_sb
= STRBUF_INIT
;
2028 struct ref_store
*refs
;
2029 char *to_free
= NULL
;
2031 struct repository
*subrepo
;
2036 len
= strlen(submodule
);
2037 while (len
&& is_dir_sep(submodule
[len
- 1]))
2043 /* We need to strip off one or more trailing slashes */
2044 submodule
= to_free
= xmemdupz(submodule
, len
);
2046 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2050 strbuf_addstr(&submodule_sb
, submodule
);
2051 if (!is_nonbare_repository_dir(&submodule_sb
))
2054 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2057 subrepo
= xmalloc(sizeof(*subrepo
));
2059 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2060 * superprojects other than the_repository. This probably should be
2061 * done by making it take a struct repository * parameter instead of a
2064 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2069 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2070 REF_STORE_READ
| REF_STORE_ODB
);
2071 register_ref_store_map(&submodule_ref_stores
, "submodule",
2075 strbuf_release(&submodule_sb
);
2081 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2083 struct ref_store
*refs
;
2087 return get_main_ref_store(the_repository
);
2089 id
= wt
->id
? wt
->id
: "/";
2090 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2095 refs
= ref_store_init(the_repository
,
2096 git_common_path("worktrees/%s", wt
->id
),
2097 REF_STORE_ALL_CAPS
);
2099 refs
= ref_store_init(the_repository
,
2100 get_git_common_dir(),
2101 REF_STORE_ALL_CAPS
);
2104 register_ref_store_map(&worktree_ref_stores
, "worktree",
2109 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2110 const char *path
, const struct ref_storage_be
*be
)
2114 refs
->gitdir
= xstrdup(path
);
2117 /* backend functions */
2118 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
2120 return refs
->be
->pack_refs(refs
, flags
);
2123 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2125 if (current_ref_iter
&&
2126 (current_ref_iter
->oid
== base
||
2127 oideq(current_ref_iter
->oid
, base
)))
2128 return ref_iterator_peel(current_ref_iter
, peeled
);
2130 return peel_object(base
, peeled
) ? -1 : 0;
2133 int refs_create_symref(struct ref_store
*refs
,
2134 const char *ref_target
,
2135 const char *refs_heads_master
,
2141 msg
= normalize_reflog_message(logmsg
);
2142 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2148 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2151 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2152 refs_heads_master
, logmsg
);
2155 int ref_update_reject_duplicates(struct string_list
*refnames
,
2158 size_t i
, n
= refnames
->nr
;
2162 for (i
= 1; i
< n
; i
++) {
2163 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2164 refnames
->items
[i
].string
);
2168 _("multiple updates for ref '%s' not allowed"),
2169 refnames
->items
[i
].string
);
2171 } else if (cmp
> 0) {
2172 BUG("ref_update_reject_duplicates() received unsorted list");
2178 static int run_transaction_hook(struct ref_transaction
*transaction
,
2181 struct child_process proc
= CHILD_PROCESS_INIT
;
2182 struct strbuf buf
= STRBUF_INIT
;
2186 hook
= find_hook("reference-transaction");
2190 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2192 proc
.stdout_to_stderr
= 1;
2193 proc
.trace2_hook_name
= "reference-transaction";
2195 ret
= start_command(&proc
);
2199 sigchain_push(SIGPIPE
, SIG_IGN
);
2201 for (i
= 0; i
< transaction
->nr
; i
++) {
2202 struct ref_update
*update
= transaction
->updates
[i
];
2205 strbuf_addf(&buf
, "%s %s %s\n",
2206 oid_to_hex(&update
->old_oid
),
2207 oid_to_hex(&update
->new_oid
),
2210 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2211 if (errno
!= EPIPE
) {
2212 /* Don't leak errno outside this API */
2221 sigchain_pop(SIGPIPE
);
2222 strbuf_release(&buf
);
2224 ret
|= finish_command(&proc
);
2228 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2231 struct ref_store
*refs
= transaction
->ref_store
;
2234 switch (transaction
->state
) {
2235 case REF_TRANSACTION_OPEN
:
2238 case REF_TRANSACTION_PREPARED
:
2239 BUG("prepare called twice on reference transaction");
2241 case REF_TRANSACTION_CLOSED
:
2242 BUG("prepare called on a closed reference transaction");
2245 BUG("unexpected reference transaction state");
2249 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2251 _("ref updates forbidden inside quarantine environment"));
2255 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2259 ret
= run_transaction_hook(transaction
, "prepared");
2261 ref_transaction_abort(transaction
, err
);
2262 die(_("ref updates aborted by hook"));
2268 int ref_transaction_abort(struct ref_transaction
*transaction
,
2271 struct ref_store
*refs
= transaction
->ref_store
;
2274 switch (transaction
->state
) {
2275 case REF_TRANSACTION_OPEN
:
2276 /* No need to abort explicitly. */
2278 case REF_TRANSACTION_PREPARED
:
2279 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2281 case REF_TRANSACTION_CLOSED
:
2282 BUG("abort called on a closed reference transaction");
2285 BUG("unexpected reference transaction state");
2289 run_transaction_hook(transaction
, "aborted");
2291 ref_transaction_free(transaction
);
2295 int ref_transaction_commit(struct ref_transaction
*transaction
,
2298 struct ref_store
*refs
= transaction
->ref_store
;
2301 switch (transaction
->state
) {
2302 case REF_TRANSACTION_OPEN
:
2303 /* Need to prepare first. */
2304 ret
= ref_transaction_prepare(transaction
, err
);
2308 case REF_TRANSACTION_PREPARED
:
2309 /* Fall through to finish. */
2311 case REF_TRANSACTION_CLOSED
:
2312 BUG("commit called on a closed reference transaction");
2315 BUG("unexpected reference transaction state");
2319 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2321 run_transaction_hook(transaction
, "committed");
2325 int refs_verify_refname_available(struct ref_store
*refs
,
2326 const char *refname
,
2327 const struct string_list
*extras
,
2328 const struct string_list
*skip
,
2332 const char *extra_refname
;
2333 struct strbuf dirname
= STRBUF_INIT
;
2334 struct strbuf referent
= STRBUF_INIT
;
2335 struct object_id oid
;
2337 struct ref_iterator
*iter
;
2342 * For the sake of comments in this function, suppose that
2343 * refname is "refs/foo/bar".
2348 strbuf_grow(&dirname
, strlen(refname
) + 1);
2349 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2351 * Just saying "Is a directory" when we e.g. can't
2352 * lock some multi-level ref isn't very informative,
2353 * the user won't be told *what* is a directory, so
2354 * let's not use strerror() below.
2357 /* Expand dirname to the new prefix, not including the trailing slash: */
2358 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2361 * We are still at a leading dir of the refname (e.g.,
2362 * "refs/foo"; if there is a reference with that name,
2363 * it is a conflict, *unless* it is in skip.
2365 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2368 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2369 &type
, &ignore_errno
)) {
2370 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2371 dirname
.buf
, refname
);
2375 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2376 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2377 refname
, dirname
.buf
);
2383 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2384 * There is no point in searching for a reference with that
2385 * name, because a refname isn't considered to conflict with
2386 * itself. But we still need to check for references whose
2387 * names are in the "refs/foo/bar/" namespace, because they
2390 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2391 strbuf_addch(&dirname
, '/');
2393 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2394 DO_FOR_EACH_INCLUDE_BROKEN
);
2395 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2397 string_list_has_string(skip
, iter
->refname
))
2400 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2401 iter
->refname
, refname
);
2402 ref_iterator_abort(iter
);
2406 if (ok
!= ITER_DONE
)
2407 BUG("error while iterating over references");
2409 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2411 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2412 refname
, extra_refname
);
2417 strbuf_release(&referent
);
2418 strbuf_release(&dirname
);
2422 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2424 struct ref_iterator
*iter
;
2425 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2427 iter
= refs
->be
->reflog_iterator_begin(refs
);
2429 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2430 do_for_each_ref_helper
, &hp
);
2433 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2435 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2438 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2439 const char *refname
,
2440 each_reflog_ent_fn fn
,
2443 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2447 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2450 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2451 refname
, fn
, cb_data
);
2454 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2455 each_reflog_ent_fn fn
, void *cb_data
)
2457 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2460 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2463 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2467 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2469 return refs
->be
->reflog_exists(refs
, refname
);
2472 int reflog_exists(const char *refname
)
2474 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2477 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2480 return refs
->be
->create_reflog(refs
, refname
, err
);
2483 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2485 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2489 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2491 return refs
->be
->delete_reflog(refs
, refname
);
2494 int delete_reflog(const char *refname
)
2496 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2499 int refs_reflog_expire(struct ref_store
*refs
,
2500 const char *refname
,
2502 reflog_expiry_prepare_fn prepare_fn
,
2503 reflog_expiry_should_prune_fn should_prune_fn
,
2504 reflog_expiry_cleanup_fn cleanup_fn
,
2505 void *policy_cb_data
)
2507 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2508 prepare_fn
, should_prune_fn
,
2509 cleanup_fn
, policy_cb_data
);
2512 int reflog_expire(const char *refname
,
2514 reflog_expiry_prepare_fn prepare_fn
,
2515 reflog_expiry_should_prune_fn should_prune_fn
,
2516 reflog_expiry_cleanup_fn cleanup_fn
,
2517 void *policy_cb_data
)
2519 return refs_reflog_expire(get_main_ref_store(the_repository
),
2521 prepare_fn
, should_prune_fn
,
2522 cleanup_fn
, policy_cb_data
);
2525 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2528 struct ref_store
*refs
= transaction
->ref_store
;
2530 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2533 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2534 ref_transaction_for_each_queued_update_fn cb
,
2539 for (i
= 0; i
< transaction
->nr
; i
++) {
2540 struct ref_update
*update
= transaction
->updates
[i
];
2543 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2544 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2549 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2550 struct string_list
*refnames
, unsigned int flags
)
2555 msg
= normalize_reflog_message(logmsg
);
2556 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2561 int delete_refs(const char *msg
, struct string_list
*refnames
,
2564 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2567 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2568 const char *newref
, const char *logmsg
)
2573 msg
= normalize_reflog_message(logmsg
);
2574 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2579 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2581 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2584 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2585 const char *newref
, const char *logmsg
)
2590 msg
= normalize_reflog_message(logmsg
);
2591 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2596 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2598 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);