2 * The backend-independent part of the reference module.
5 #include "git-compat-util.h"
12 #include "refs/refs-internal.h"
13 #include "run-command.h"
15 #include "object-store.h"
18 #include "submodule.h"
21 #include "repository.h"
27 * List of all available backends
29 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
31 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
33 struct ref_storage_be
*be
;
34 for (be
= refs_backends
; be
; be
= be
->next
)
35 if (!strcmp(be
->name
, name
))
41 * How to handle various characters in refnames:
42 * 0: An acceptable character for refs
44 * 2: ., look for a preceding . to reject .. in refs
45 * 3: {, look for a preceding @ to reject @{ in refs
46 * 4: A bad character: ASCII control characters, and
47 * ":", "?", "[", "\", "^", "~", SP, or TAB
48 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
50 static unsigned char refname_disposition
[256] = {
51 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
52 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
53 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
56 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
57 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
58 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
61 struct ref_namespace_info ref_namespace
[] = {
64 .decoration
= DECORATION_REF_HEAD
,
67 [NAMESPACE_BRANCHES
] = {
69 .decoration
= DECORATION_REF_LOCAL
,
73 .decoration
= DECORATION_REF_TAG
,
75 [NAMESPACE_REMOTE_REFS
] = {
77 * The default refspec for new remotes copies refs from
78 * refs/heads/ on the remote into refs/remotes/<remote>/.
79 * As such, "refs/remotes/" has special handling.
81 .ref
= "refs/remotes/",
82 .decoration
= DECORATION_REF_REMOTE
,
86 * The single ref "refs/stash" stores the latest stash.
87 * Older stashes can be found in the reflog.
91 .decoration
= DECORATION_REF_STASH
,
93 [NAMESPACE_REPLACE
] = {
95 * This namespace allows Git to act as if one object ID
96 * points to the content of another. Unlike the other
97 * ref namespaces, this one can be changed by the
98 * GIT_REPLACE_REF_BASE environment variable. This
99 * .namespace value will be overwritten in setup_git_env().
101 .ref
= "refs/replace/",
102 .decoration
= DECORATION_GRAFTED
,
104 [NAMESPACE_NOTES
] = {
106 * The refs/notes/commit ref points to the tip of a
107 * parallel commit history that adds metadata to commits
108 * in the normal history. This ref can be overwritten
109 * by the core.notesRef config variable or the
110 * GIT_NOTES_REFS environment variable.
112 .ref
= "refs/notes/commit",
115 [NAMESPACE_PREFETCH
] = {
117 * Prefetch refs are written by the background 'fetch'
118 * maintenance task. It allows faster foreground fetches
119 * by advertising these previously-downloaded tips without
120 * updating refs/remotes/ without user intervention.
122 .ref
= "refs/prefetch/",
124 [NAMESPACE_REWRITTEN
] = {
126 * Rewritten refs are used by the 'label' command in the
127 * sequencer. These are particularly useful during an
128 * interactive rebase that uses the 'merge' command.
130 .ref
= "refs/rewritten/",
134 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
136 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
137 if (info
->ref_updated
)
140 info
->ref_updated
= 1;
144 * Try to read one refname component from the front of refname.
145 * Return the length of the component found, or -1 if the component is
146 * not legal. It is legal if it is something reasonable to have under
147 * ".git/refs/"; We do not like it if:
149 * - it begins with ".", or
150 * - it has double dots "..", or
151 * - it has ASCII control characters, or
152 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
153 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
154 * - it ends with a "/", or
155 * - it ends with ".lock", or
156 * - it contains a "@{" portion
158 * When sanitized is not NULL, instead of rejecting the input refname
159 * as an error, try to come up with a usable replacement for the input
162 static int check_refname_component(const char *refname
, int *flags
,
163 struct strbuf
*sanitized
)
167 size_t component_start
= 0; /* garbage - not a reasonable initial value */
170 component_start
= sanitized
->len
;
172 for (cp
= refname
; ; cp
++) {
174 unsigned char disp
= refname_disposition
[ch
];
176 if (sanitized
&& disp
!= 1)
177 strbuf_addch(sanitized
, ch
);
183 if (last
== '.') { /* Refname contains "..". */
185 /* collapse ".." to single "." */
186 strbuf_setlen(sanitized
, sanitized
->len
- 1);
192 if (last
== '@') { /* Refname contains "@{". */
194 sanitized
->buf
[sanitized
->len
-1] = '-';
202 sanitized
->buf
[sanitized
->len
-1] = '-';
207 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
208 /* refspec can't be a pattern */
210 sanitized
->buf
[sanitized
->len
-1] = '-';
216 * Unset the pattern flag so that we only accept
217 * a single asterisk for one side of refspec.
219 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
226 return 0; /* Component has zero length. */
228 if (refname
[0] == '.') { /* Component starts with '.'. */
230 sanitized
->buf
[component_start
] = '-';
234 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
235 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
238 /* Refname ends with ".lock". */
239 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
240 /* try again in case we have .lock.lock */
246 static int check_or_sanitize_refname(const char *refname
, int flags
,
247 struct strbuf
*sanitized
)
249 int component_len
, component_count
= 0;
251 if (!strcmp(refname
, "@")) {
252 /* Refname is a single character '@'. */
254 strbuf_addch(sanitized
, '-');
260 if (sanitized
&& sanitized
->len
)
261 strbuf_complete(sanitized
, '/');
263 /* We are at the start of a path component. */
264 component_len
= check_refname_component(refname
, &flags
,
266 if (sanitized
&& component_len
== 0)
267 ; /* OK, omit empty component */
268 else if (component_len
<= 0)
272 if (refname
[component_len
] == '\0')
274 /* Skip to next component. */
275 refname
+= component_len
+ 1;
278 if (refname
[component_len
- 1] == '.') {
279 /* Refname ends with '.'. */
281 ; /* omit ending dot */
285 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
286 return -1; /* Refname has only one component. */
290 int check_refname_format(const char *refname
, int flags
)
292 return check_or_sanitize_refname(refname
, flags
, NULL
);
295 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
297 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
298 BUG("sanitizing refname '%s' check returned error", refname
);
301 int refname_is_safe(const char *refname
)
305 if (skip_prefix(refname
, "refs/", &rest
)) {
308 size_t restlen
= strlen(rest
);
310 /* rest must not be empty, or start or end with "/" */
311 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
315 * Does the refname try to escape refs/?
316 * For example: refs/foo/../bar is safe but refs/foo/../../bar
319 buf
= xmallocz(restlen
);
320 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
326 if (!isupper(*refname
) && *refname
!= '_')
334 * Return true if refname, which has the specified oid and flags, can
335 * be resolved to an object in the database. If the referred-to object
336 * does not exist, emit a warning and return false.
338 int ref_resolves_to_object(const char *refname
,
339 struct repository
*repo
,
340 const struct object_id
*oid
,
343 if (flags
& REF_ISBROKEN
)
345 if (!repo_has_object_file(repo
, oid
)) {
346 error(_("%s does not point to a valid object!"), refname
);
352 char *refs_resolve_refdup(struct ref_store
*refs
,
353 const char *refname
, int resolve_flags
,
354 struct object_id
*oid
, int *flags
)
358 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
360 return xstrdup_or_null(result
);
363 char *resolve_refdup(const char *refname
, int resolve_flags
,
364 struct object_id
*oid
, int *flags
)
366 return refs_resolve_refdup(get_main_ref_store(the_repository
),
367 refname
, resolve_flags
,
371 /* The argument to filter_refs */
379 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
381 struct ref_store
*refs
= get_main_ref_store(the_repository
);
383 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
389 int read_ref(const char *refname
, struct object_id
*oid
)
391 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
394 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
396 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
400 int ref_exists(const char *refname
)
402 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
405 static int filter_refs(const char *refname
, const struct object_id
*oid
,
406 int flags
, void *data
)
408 struct ref_filter
*filter
= (struct ref_filter
*)data
;
410 if (wildmatch(filter
->pattern
, refname
, 0))
413 skip_prefix(refname
, filter
->prefix
, &refname
);
414 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
417 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
419 struct object
*o
= lookup_unknown_object(the_repository
, name
);
421 if (o
->type
== OBJ_NONE
) {
422 int type
= oid_object_info(the_repository
, name
, NULL
);
423 if (type
< 0 || !object_as_type(o
, type
, 0))
427 if (o
->type
!= OBJ_TAG
)
430 o
= deref_tag_noverify(o
);
434 oidcpy(oid
, &o
->oid
);
438 struct warn_if_dangling_data
{
441 const struct string_list
*refnames
;
445 static int warn_if_dangling_symref(const char *refname
,
446 const struct object_id
*oid UNUSED
,
447 int flags
, void *cb_data
)
449 struct warn_if_dangling_data
*d
= cb_data
;
450 const char *resolves_to
;
452 if (!(flags
& REF_ISSYMREF
))
455 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
458 ? strcmp(resolves_to
, d
->refname
)
459 : !string_list_has_string(d
->refnames
, resolves_to
))) {
463 fprintf(d
->fp
, d
->msg_fmt
, refname
);
468 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
470 struct warn_if_dangling_data data
;
473 data
.refname
= refname
;
474 data
.refnames
= NULL
;
475 data
.msg_fmt
= msg_fmt
;
476 for_each_rawref(warn_if_dangling_symref
, &data
);
479 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
481 struct warn_if_dangling_data data
;
485 data
.refnames
= refnames
;
486 data
.msg_fmt
= msg_fmt
;
487 for_each_rawref(warn_if_dangling_symref
, &data
);
490 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
492 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
495 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
497 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
500 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
502 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
505 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
507 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
510 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
512 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
515 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
517 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
520 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
522 struct strbuf buf
= STRBUF_INIT
;
524 struct object_id oid
;
527 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
528 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
529 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
530 strbuf_release(&buf
);
535 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
538 struct strbuf normalized_pattern
= STRBUF_INIT
;
541 BUG("pattern must not start with '/'");
544 strbuf_addstr(&normalized_pattern
, prefix
);
545 else if (!starts_with(pattern
, "refs/") &&
546 strcmp(pattern
, "HEAD"))
547 strbuf_addstr(&normalized_pattern
, "refs/");
549 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
553 strbuf_addstr(&normalized_pattern
, pattern
);
554 strbuf_strip_suffix(&normalized_pattern
, "/");
556 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
557 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
558 strbuf_release(&normalized_pattern
);
561 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
562 const char *prefix
, void *cb_data
)
564 struct strbuf real_pattern
= STRBUF_INIT
;
565 struct ref_filter filter
;
568 if (!prefix
&& !starts_with(pattern
, "refs/"))
569 strbuf_addstr(&real_pattern
, "refs/");
571 strbuf_addstr(&real_pattern
, prefix
);
572 strbuf_addstr(&real_pattern
, pattern
);
574 if (!has_glob_specials(pattern
)) {
575 /* Append implied '/' '*' if not present. */
576 strbuf_complete(&real_pattern
, '/');
577 /* No need to check for '*', there is none. */
578 strbuf_addch(&real_pattern
, '*');
581 filter
.pattern
= real_pattern
.buf
;
582 filter
.prefix
= prefix
;
584 filter
.cb_data
= cb_data
;
585 ret
= for_each_ref(filter_refs
, &filter
);
587 strbuf_release(&real_pattern
);
591 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
593 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
596 const char *prettify_refname(const char *name
)
598 if (skip_prefix(name
, "refs/heads/", &name
) ||
599 skip_prefix(name
, "refs/tags/", &name
) ||
600 skip_prefix(name
, "refs/remotes/", &name
))
605 static const char *ref_rev_parse_rules
[] = {
611 "refs/remotes/%.*s/HEAD",
615 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
618 * Is it possible that the caller meant full_name with abbrev_name?
619 * If so return a non-zero value to signal "yes"; the magnitude of
620 * the returned value gives the precedence used for disambiguation.
622 * If abbrev_name cannot mean full_name, return 0.
624 int refname_match(const char *abbrev_name
, const char *full_name
)
627 const int abbrev_name_len
= strlen(abbrev_name
);
628 const int num_rules
= NUM_REV_PARSE_RULES
;
630 for (p
= ref_rev_parse_rules
; *p
; p
++)
631 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
632 return &ref_rev_parse_rules
[num_rules
] - p
;
638 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
639 * the results to 'prefixes'
641 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
644 int len
= strlen(prefix
);
646 for (p
= ref_rev_parse_rules
; *p
; p
++)
647 strvec_pushf(prefixes
, *p
, len
, prefix
);
650 static const char default_branch_name_advice
[] = N_(
651 "Using '%s' as the name for the initial branch. This default branch name\n"
652 "is subject to change. To configure the initial branch name to use in all\n"
653 "of your new repositories, which will suppress this warning, call:\n"
655 "\tgit config --global init.defaultBranch <name>\n"
657 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
658 "'development'. The just-created branch can be renamed via this command:\n"
660 "\tgit branch -m <name>\n"
663 char *repo_default_branch_name(struct repository
*r
, int quiet
)
665 const char *config_key
= "init.defaultbranch";
666 const char *config_display_key
= "init.defaultBranch";
667 char *ret
= NULL
, *full_ref
;
668 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
672 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
673 die(_("could not retrieve `%s`"), config_display_key
);
676 ret
= xstrdup("master");
678 advise(_(default_branch_name_advice
), ret
);
681 full_ref
= xstrfmt("refs/heads/%s", ret
);
682 if (check_refname_format(full_ref
, 0))
683 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
689 const char *git_default_branch_name(int quiet
)
694 ret
= repo_default_branch_name(the_repository
, quiet
);
700 * *string and *len will only be substituted, and *string returned (for
701 * later free()ing) if the string passed in is a magic short-hand form
704 static char *substitute_branch_name(struct repository
*r
,
705 const char **string
, int *len
,
706 int nonfatal_dangling_mark
)
708 struct strbuf buf
= STRBUF_INIT
;
709 struct interpret_branch_name_options options
= {
710 .nonfatal_dangling_mark
= nonfatal_dangling_mark
712 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
716 *string
= strbuf_detach(&buf
, &size
);
718 return (char *)*string
;
724 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
725 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
727 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
728 nonfatal_dangling_mark
);
729 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
734 int expand_ref(struct repository
*repo
, const char *str
, int len
,
735 struct object_id
*oid
, char **ref
)
739 struct strbuf fullref
= STRBUF_INIT
;
742 for (p
= ref_rev_parse_rules
; *p
; p
++) {
743 struct object_id oid_from_ref
;
744 struct object_id
*this_result
;
746 struct ref_store
*refs
= get_main_ref_store(repo
);
748 this_result
= refs_found
? &oid_from_ref
: oid
;
749 strbuf_reset(&fullref
);
750 strbuf_addf(&fullref
, *p
, len
, str
);
751 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
757 if (!warn_ambiguous_refs
)
759 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
760 warning(_("ignoring dangling symref %s"), fullref
.buf
);
761 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
762 warning(_("ignoring broken ref %s"), fullref
.buf
);
765 strbuf_release(&fullref
);
769 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
770 struct object_id
*oid
, char **log
)
772 struct ref_store
*refs
= get_main_ref_store(r
);
773 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
776 struct strbuf path
= STRBUF_INIT
;
779 for (p
= ref_rev_parse_rules
; *p
; p
++) {
780 struct object_id hash
;
781 const char *ref
, *it
;
784 strbuf_addf(&path
, *p
, len
, str
);
785 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
787 oid
? &hash
: NULL
, NULL
);
790 if (refs_reflog_exists(refs
, path
.buf
))
792 else if (strcmp(ref
, path
.buf
) &&
793 refs_reflog_exists(refs
, ref
))
802 if (!warn_ambiguous_refs
)
805 strbuf_release(&path
);
810 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
812 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
815 int is_per_worktree_ref(const char *refname
)
817 return starts_with(refname
, "refs/worktree/") ||
818 starts_with(refname
, "refs/bisect/") ||
819 starts_with(refname
, "refs/rewritten/");
822 static int is_pseudoref_syntax(const char *refname
)
826 for (c
= refname
; *c
; c
++) {
827 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
832 * HEAD is not a pseudoref, but it certainly uses the
838 static int is_current_worktree_ref(const char *ref
) {
839 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
842 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
843 const char **worktree_name
, int *worktree_name_length
,
844 const char **bare_refname
)
846 const char *name_dummy
;
847 int name_length_dummy
;
848 const char *ref_dummy
;
851 worktree_name
= &name_dummy
;
852 if (!worktree_name_length
)
853 worktree_name_length
= &name_length_dummy
;
855 bare_refname
= &ref_dummy
;
857 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
858 const char *slash
= strchr(*bare_refname
, '/');
860 *worktree_name
= *bare_refname
;
862 *worktree_name_length
= strlen(*worktree_name
);
864 /* This is an error condition, and the caller tell because the bare_refname is "" */
865 *bare_refname
= *worktree_name
+ *worktree_name_length
;
866 return REF_WORKTREE_OTHER
;
869 *worktree_name_length
= slash
- *bare_refname
;
870 *bare_refname
= slash
+ 1;
872 if (is_current_worktree_ref(*bare_refname
))
873 return REF_WORKTREE_OTHER
;
876 *worktree_name
= NULL
;
877 *worktree_name_length
= 0;
879 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
880 && is_current_worktree_ref(*bare_refname
))
881 return REF_WORKTREE_MAIN
;
883 *bare_refname
= maybe_worktree_ref
;
884 if (is_current_worktree_ref(maybe_worktree_ref
))
885 return REF_WORKTREE_CURRENT
;
887 return REF_WORKTREE_SHARED
;
890 long get_files_ref_lock_timeout_ms(void)
892 static int configured
= 0;
894 /* The default timeout is 100 ms: */
895 static int timeout_ms
= 100;
898 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
905 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
907 const struct object_id
*old_oid
,
910 struct ref_transaction
*transaction
;
911 struct strbuf err
= STRBUF_INIT
;
913 transaction
= ref_store_transaction_begin(refs
, &err
);
915 ref_transaction_delete(transaction
, refname
, old_oid
,
917 ref_transaction_commit(transaction
, &err
)) {
918 error("%s", err
.buf
);
919 ref_transaction_free(transaction
);
920 strbuf_release(&err
);
923 ref_transaction_free(transaction
);
924 strbuf_release(&err
);
928 int delete_ref(const char *msg
, const char *refname
,
929 const struct object_id
*old_oid
, unsigned int flags
)
931 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
935 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
940 while ((c
= *msg
++)) {
941 if (wasspace
&& isspace(c
))
943 wasspace
= isspace(c
);
951 static char *normalize_reflog_message(const char *msg
)
953 struct strbuf sb
= STRBUF_INIT
;
956 copy_reflog_msg(&sb
, msg
);
957 return strbuf_detach(&sb
, NULL
);
960 int should_autocreate_reflog(const char *refname
)
962 switch (log_all_ref_updates
) {
963 case LOG_REFS_ALWAYS
:
965 case LOG_REFS_NORMAL
:
966 return starts_with(refname
, "refs/heads/") ||
967 starts_with(refname
, "refs/remotes/") ||
968 starts_with(refname
, "refs/notes/") ||
969 !strcmp(refname
, "HEAD");
975 int is_branch(const char *refname
)
977 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
980 struct read_ref_at_cb
{
985 struct object_id
*oid
;
988 struct object_id ooid
;
989 struct object_id noid
;
993 timestamp_t
*cutoff_time
;
998 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
999 timestamp_t timestamp
, int tz
, const char *message
)
1002 *cb
->msg
= xstrdup(message
);
1003 if (cb
->cutoff_time
)
1004 *cb
->cutoff_time
= timestamp
;
1006 *cb
->cutoff_tz
= tz
;
1008 *cb
->cutoff_cnt
= cb
->reccnt
;
1011 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1012 const char *email UNUSED
,
1013 timestamp_t timestamp
, int tz
,
1014 const char *message
, void *cb_data
)
1016 struct read_ref_at_cb
*cb
= cb_data
;
1020 cb
->date
= timestamp
;
1023 * It is not possible for cb->cnt == 0 on the first iteration because
1024 * that special case is handled in read_ref_at().
1028 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
1029 if (timestamp
<= cb
->at_time
|| reached_count
) {
1030 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1032 * we have not yet updated cb->[n|o]oid so they still
1033 * hold the values for the previous record.
1035 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
1036 warning(_("log for ref %s has gap after %s"),
1037 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1039 oidcpy(cb
->oid
, ooid
);
1040 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
1041 oidcpy(cb
->oid
, noid
);
1042 else if (!oideq(noid
, cb
->oid
))
1043 warning(_("log for ref %s unexpectedly ended on %s"),
1044 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1045 DATE_MODE(RFC2822
)));
1049 oidcpy(&cb
->ooid
, ooid
);
1050 oidcpy(&cb
->noid
, noid
);
1051 return cb
->found_it
;
1054 static int read_ref_at_ent_newest(struct object_id
*ooid UNUSED
,
1055 struct object_id
*noid
,
1056 const char *email UNUSED
,
1057 timestamp_t timestamp
, int tz
,
1058 const char *message
, void *cb_data
)
1060 struct read_ref_at_cb
*cb
= cb_data
;
1062 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1063 oidcpy(cb
->oid
, noid
);
1064 /* We just want the first entry */
1068 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1069 const char *email UNUSED
,
1070 timestamp_t timestamp
, int tz
,
1071 const char *message
, void *cb_data
)
1073 struct read_ref_at_cb
*cb
= cb_data
;
1075 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1076 oidcpy(cb
->oid
, ooid
);
1077 if (is_null_oid(cb
->oid
))
1078 oidcpy(cb
->oid
, noid
);
1079 /* We just want the first entry */
1083 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1084 unsigned int flags
, timestamp_t at_time
, int cnt
,
1085 struct object_id
*oid
, char **msg
,
1086 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1088 struct read_ref_at_cb cb
;
1090 memset(&cb
, 0, sizeof(cb
));
1091 cb
.refname
= refname
;
1092 cb
.at_time
= at_time
;
1095 cb
.cutoff_time
= cutoff_time
;
1096 cb
.cutoff_tz
= cutoff_tz
;
1097 cb
.cutoff_cnt
= cutoff_cnt
;
1101 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
1105 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1108 if (flags
& GET_OID_QUIETLY
)
1111 die(_("log for %s is empty"), refname
);
1116 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1121 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1124 struct ref_transaction
*tr
;
1127 CALLOC_ARRAY(tr
, 1);
1128 tr
->ref_store
= refs
;
1132 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1134 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1137 void ref_transaction_free(struct ref_transaction
*transaction
)
1144 switch (transaction
->state
) {
1145 case REF_TRANSACTION_OPEN
:
1146 case REF_TRANSACTION_CLOSED
:
1149 case REF_TRANSACTION_PREPARED
:
1150 BUG("free called on a prepared reference transaction");
1153 BUG("unexpected reference transaction state");
1157 for (i
= 0; i
< transaction
->nr
; i
++) {
1158 free(transaction
->updates
[i
]->msg
);
1159 free(transaction
->updates
[i
]);
1161 free(transaction
->updates
);
1165 struct ref_update
*ref_transaction_add_update(
1166 struct ref_transaction
*transaction
,
1167 const char *refname
, unsigned int flags
,
1168 const struct object_id
*new_oid
,
1169 const struct object_id
*old_oid
,
1172 struct ref_update
*update
;
1174 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1175 BUG("update called for transaction that is not open");
1177 FLEX_ALLOC_STR(update
, refname
, refname
);
1178 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1179 transaction
->updates
[transaction
->nr
++] = update
;
1181 update
->flags
= flags
;
1183 if (flags
& REF_HAVE_NEW
)
1184 oidcpy(&update
->new_oid
, new_oid
);
1185 if (flags
& REF_HAVE_OLD
)
1186 oidcpy(&update
->old_oid
, old_oid
);
1187 update
->msg
= normalize_reflog_message(msg
);
1191 int ref_transaction_update(struct ref_transaction
*transaction
,
1192 const char *refname
,
1193 const struct object_id
*new_oid
,
1194 const struct object_id
*old_oid
,
1195 unsigned int flags
, const char *msg
,
1200 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1201 ((new_oid
&& !is_null_oid(new_oid
)) ?
1202 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1203 !refname_is_safe(refname
))) {
1204 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1209 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1210 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1213 * Clear flags outside the allowed set; this should be a noop because
1214 * of the BUG() check above, but it works around a -Wnonnull warning
1215 * with some versions of "gcc -O3".
1217 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1219 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1221 ref_transaction_add_update(transaction
, refname
, flags
,
1222 new_oid
, old_oid
, msg
);
1226 int ref_transaction_create(struct ref_transaction
*transaction
,
1227 const char *refname
,
1228 const struct object_id
*new_oid
,
1229 unsigned int flags
, const char *msg
,
1232 if (!new_oid
|| is_null_oid(new_oid
)) {
1233 strbuf_addf(err
, "'%s' has a null OID", refname
);
1236 return ref_transaction_update(transaction
, refname
, new_oid
,
1237 null_oid(), flags
, msg
, err
);
1240 int ref_transaction_delete(struct ref_transaction
*transaction
,
1241 const char *refname
,
1242 const struct object_id
*old_oid
,
1243 unsigned int flags
, const char *msg
,
1246 if (old_oid
&& is_null_oid(old_oid
))
1247 BUG("delete called with old_oid set to zeros");
1248 return ref_transaction_update(transaction
, refname
,
1249 null_oid(), old_oid
,
1253 int ref_transaction_verify(struct ref_transaction
*transaction
,
1254 const char *refname
,
1255 const struct object_id
*old_oid
,
1260 BUG("verify called with old_oid set to NULL");
1261 return ref_transaction_update(transaction
, refname
,
1266 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1267 const char *refname
, const struct object_id
*new_oid
,
1268 const struct object_id
*old_oid
, unsigned int flags
,
1269 enum action_on_err onerr
)
1271 struct ref_transaction
*t
= NULL
;
1272 struct strbuf err
= STRBUF_INIT
;
1275 t
= ref_store_transaction_begin(refs
, &err
);
1277 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1279 ref_transaction_commit(t
, &err
)) {
1281 ref_transaction_free(t
);
1284 const char *str
= _("update_ref failed for ref '%s': %s");
1287 case UPDATE_REFS_MSG_ON_ERR
:
1288 error(str
, refname
, err
.buf
);
1290 case UPDATE_REFS_DIE_ON_ERR
:
1291 die(str
, refname
, err
.buf
);
1293 case UPDATE_REFS_QUIET_ON_ERR
:
1296 strbuf_release(&err
);
1299 strbuf_release(&err
);
1301 ref_transaction_free(t
);
1305 int update_ref(const char *msg
, const char *refname
,
1306 const struct object_id
*new_oid
,
1307 const struct object_id
*old_oid
,
1308 unsigned int flags
, enum action_on_err onerr
)
1310 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1311 old_oid
, flags
, onerr
);
1314 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1315 const char *refname
, int strict
)
1318 static char **scanf_fmts
;
1319 static int nr_rules
;
1321 struct strbuf resolved_buf
= STRBUF_INIT
;
1325 * Pre-generate scanf formats from ref_rev_parse_rules[].
1326 * Generate a format suitable for scanf from a
1327 * ref_rev_parse_rules rule by interpolating "%s" at the
1328 * location of the "%.*s".
1330 size_t total_len
= 0;
1333 /* the rule list is NULL terminated, count them first */
1334 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1335 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1336 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1338 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1341 for (i
= 0; i
< nr_rules
; i
++) {
1342 assert(offset
< total_len
);
1343 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1344 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1345 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1349 /* bail out if there are no rules */
1351 return xstrdup(refname
);
1353 /* buffer for scanf result, at most refname must fit */
1354 short_name
= xstrdup(refname
);
1356 /* skip first rule, it will always match */
1357 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1359 int rules_to_fail
= i
;
1362 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1365 short_name_len
= strlen(short_name
);
1368 * in strict mode, all (except the matched one) rules
1369 * must fail to resolve to a valid non-ambiguous ref
1372 rules_to_fail
= nr_rules
;
1375 * check if the short name resolves to a valid ref,
1376 * but use only rules prior to the matched one
1378 for (j
= 0; j
< rules_to_fail
; j
++) {
1379 const char *rule
= ref_rev_parse_rules
[j
];
1381 /* skip matched rule */
1386 * the short name is ambiguous, if it resolves
1387 * (with this previous rule) to a valid ref
1388 * read_ref() returns 0 on success
1390 strbuf_reset(&resolved_buf
);
1391 strbuf_addf(&resolved_buf
, rule
,
1392 short_name_len
, short_name
);
1393 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1398 * short name is non-ambiguous if all previous rules
1399 * haven't resolved to a valid ref
1401 if (j
== rules_to_fail
) {
1402 strbuf_release(&resolved_buf
);
1407 strbuf_release(&resolved_buf
);
1409 return xstrdup(refname
);
1412 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1414 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1418 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1419 struct string_list
*hide_refs
)
1422 if (!strcmp("transfer.hiderefs", var
) ||
1423 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1424 !strcmp(key
, "hiderefs"))) {
1429 return config_error_nonbool(var
);
1430 ref
= xstrdup(value
);
1432 while (len
&& ref
[len
- 1] == '/')
1434 string_list_append_nodup(hide_refs
, ref
);
1439 int ref_is_hidden(const char *refname
, const char *refname_full
,
1440 const struct string_list
*hide_refs
)
1444 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1445 const char *match
= hide_refs
->items
[i
].string
;
1446 const char *subject
;
1450 if (*match
== '!') {
1455 if (*match
== '^') {
1456 subject
= refname_full
;
1462 /* refname can be NULL when namespaces are used. */
1464 skip_prefix(subject
, match
, &p
) &&
1471 const char *find_descendant_ref(const char *dirname
,
1472 const struct string_list
*extras
,
1473 const struct string_list
*skip
)
1481 * Look at the place where dirname would be inserted into
1482 * extras. If there is an entry at that position that starts
1483 * with dirname (remember, dirname includes the trailing
1484 * slash) and is not in skip, then we have a conflict.
1486 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1487 pos
< extras
->nr
; pos
++) {
1488 const char *extra_refname
= extras
->items
[pos
].string
;
1490 if (!starts_with(extra_refname
, dirname
))
1493 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1494 return extra_refname
;
1499 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1501 struct object_id oid
;
1504 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1506 return fn("HEAD", &oid
, flag
, cb_data
);
1511 int head_ref(each_ref_fn fn
, void *cb_data
)
1513 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1516 struct ref_iterator
*refs_ref_iterator_begin(
1517 struct ref_store
*refs
,
1518 const char *prefix
, int trim
,
1519 enum do_for_each_ref_flags flags
)
1521 struct ref_iterator
*iter
;
1523 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1524 static int ref_paranoia
= -1;
1526 if (ref_paranoia
< 0)
1527 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1529 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1530 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1534 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1537 * `iterator_begin()` already takes care of prefix, but we
1538 * might need to do some trimming:
1541 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1543 /* Sanity check for subclasses: */
1545 BUG("reference iterator is not ordered");
1551 * Call fn for each reference in the specified submodule for which the
1552 * refname begins with prefix. If trim is non-zero, then trim that
1553 * many characters off the beginning of each refname before passing
1554 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1555 * include broken references in the iteration. If fn ever returns a
1556 * non-zero value, stop the iteration and return that value;
1557 * otherwise, return 0.
1559 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1560 each_repo_ref_fn fn
, int trim
, int flags
,
1563 struct ref_iterator
*iter
;
1564 struct ref_store
*refs
= get_main_ref_store(r
);
1569 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1571 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1574 struct do_for_each_ref_help
{
1579 static int do_for_each_ref_helper(struct repository
*r
,
1580 const char *refname
,
1581 const struct object_id
*oid
,
1585 struct do_for_each_ref_help
*hp
= cb_data
;
1587 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1590 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1591 each_ref_fn fn
, int trim
,
1592 enum do_for_each_ref_flags flags
, void *cb_data
)
1594 struct ref_iterator
*iter
;
1595 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1600 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1602 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1603 do_for_each_ref_helper
, &hp
);
1606 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1608 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1611 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1613 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1616 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1617 each_ref_fn fn
, void *cb_data
)
1619 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1622 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1624 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1627 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1629 return do_for_each_ref(get_main_ref_store(the_repository
),
1630 prefix
, fn
, 0, 0, cb_data
);
1633 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1634 each_ref_fn fn
, void *cb_data
)
1636 return do_for_each_ref(refs
, prefix
, fn
, 0, 0, cb_data
);
1639 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1641 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1642 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1643 strlen(git_replace_ref_base
),
1644 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1647 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1649 struct strbuf buf
= STRBUF_INIT
;
1651 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1652 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1653 buf
.buf
, fn
, 0, 0, cb_data
);
1654 strbuf_release(&buf
);
1658 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1660 return do_for_each_ref(refs
, "", fn
, 0,
1661 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1664 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1666 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1669 static int qsort_strcmp(const void *va
, const void *vb
)
1671 const char *a
= *(const char **)va
;
1672 const char *b
= *(const char **)vb
;
1674 return strcmp(a
, b
);
1677 static void find_longest_prefixes_1(struct string_list
*out
,
1678 struct strbuf
*prefix
,
1679 const char **patterns
, size_t nr
)
1683 for (i
= 0; i
< nr
; i
++) {
1684 char c
= patterns
[i
][prefix
->len
];
1685 if (!c
|| is_glob_special(c
)) {
1686 string_list_append(out
, prefix
->buf
);
1696 * Set "end" to the index of the element _after_ the last one
1699 for (end
= i
+ 1; end
< nr
; end
++) {
1700 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1704 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1705 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1706 strbuf_setlen(prefix
, prefix
->len
- 1);
1712 static void find_longest_prefixes(struct string_list
*out
,
1713 const char **patterns
)
1715 struct strvec sorted
= STRVEC_INIT
;
1716 struct strbuf prefix
= STRBUF_INIT
;
1718 strvec_pushv(&sorted
, patterns
);
1719 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1721 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1723 strvec_clear(&sorted
);
1724 strbuf_release(&prefix
);
1727 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1728 const char *namespace,
1729 const char **patterns
,
1730 each_ref_fn fn
, void *cb_data
)
1732 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1733 struct string_list_item
*prefix
;
1734 struct strbuf buf
= STRBUF_INIT
;
1735 int ret
= 0, namespace_len
;
1737 find_longest_prefixes(&prefixes
, patterns
);
1740 strbuf_addstr(&buf
, namespace);
1741 namespace_len
= buf
.len
;
1743 for_each_string_list_item(prefix
, &prefixes
) {
1744 strbuf_addstr(&buf
, prefix
->string
);
1745 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
, fn
, cb_data
);
1748 strbuf_setlen(&buf
, namespace_len
);
1751 string_list_clear(&prefixes
, 0);
1752 strbuf_release(&buf
);
1756 static int refs_read_special_head(struct ref_store
*ref_store
,
1757 const char *refname
, struct object_id
*oid
,
1758 struct strbuf
*referent
, unsigned int *type
,
1761 struct strbuf full_path
= STRBUF_INIT
;
1762 struct strbuf content
= STRBUF_INIT
;
1764 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1766 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1769 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1773 strbuf_release(&full_path
);
1774 strbuf_release(&content
);
1778 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1779 struct object_id
*oid
, struct strbuf
*referent
,
1780 unsigned int *type
, int *failure_errno
)
1782 assert(failure_errno
);
1783 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1784 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1785 type
, failure_errno
);
1788 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1789 type
, failure_errno
);
1792 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1793 struct strbuf
*referent
)
1795 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1798 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1799 const char *refname
,
1801 struct object_id
*oid
,
1804 static struct strbuf sb_refname
= STRBUF_INIT
;
1805 struct object_id unused_oid
;
1812 flags
= &unused_flags
;
1816 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1817 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1818 !refname_is_safe(refname
))
1822 * dwim_ref() uses REF_ISBROKEN to distinguish between
1823 * missing refs and refs that were present but invalid,
1824 * to complain about the latter to stderr.
1826 * We don't know whether the ref exists, so don't set
1829 *flags
|= REF_BAD_NAME
;
1832 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1833 unsigned int read_flags
= 0;
1836 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1837 &read_flags
, &failure_errno
)) {
1838 *flags
|= read_flags
;
1840 /* In reading mode, refs must eventually resolve */
1841 if (resolve_flags
& RESOLVE_REF_READING
)
1845 * Otherwise a missing ref is OK. But the files backend
1846 * may show errors besides ENOENT if there are
1847 * similarly-named refs.
1849 if (failure_errno
!= ENOENT
&&
1850 failure_errno
!= EISDIR
&&
1851 failure_errno
!= ENOTDIR
)
1855 if (*flags
& REF_BAD_NAME
)
1856 *flags
|= REF_ISBROKEN
;
1860 *flags
|= read_flags
;
1862 if (!(read_flags
& REF_ISSYMREF
)) {
1863 if (*flags
& REF_BAD_NAME
) {
1865 *flags
|= REF_ISBROKEN
;
1870 refname
= sb_refname
.buf
;
1871 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1875 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1876 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1877 !refname_is_safe(refname
))
1880 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1887 /* backend functions */
1888 int refs_init_db(struct strbuf
*err
)
1890 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1892 return refs
->be
->init_db(refs
, err
);
1895 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1896 struct object_id
*oid
, int *flags
)
1898 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1899 resolve_flags
, oid
, flags
);
1902 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1903 struct object_id
*oid
)
1905 struct ref_store
*refs
;
1908 refs
= get_submodule_ref_store(submodule
);
1913 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1919 struct ref_store_hash_entry
1921 struct hashmap_entry ent
;
1923 struct ref_store
*refs
;
1925 /* NUL-terminated identifier of the ref store: */
1926 char name
[FLEX_ARRAY
];
1929 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
1930 const struct hashmap_entry
*eptr
,
1931 const struct hashmap_entry
*entry_or_key
,
1932 const void *keydata
)
1934 const struct ref_store_hash_entry
*e1
, *e2
;
1937 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1938 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1939 name
= keydata
? keydata
: e2
->name
;
1941 return strcmp(e1
->name
, name
);
1944 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1945 const char *name
, struct ref_store
*refs
)
1947 struct ref_store_hash_entry
*entry
;
1949 FLEX_ALLOC_STR(entry
, name
, name
);
1950 hashmap_entry_init(&entry
->ent
, strhash(name
));
1955 /* A hashmap of ref_stores, stored by submodule name: */
1956 static struct hashmap submodule_ref_stores
;
1958 /* A hashmap of ref_stores, stored by worktree id: */
1959 static struct hashmap worktree_ref_stores
;
1962 * Look up a ref store by name. If that ref_store hasn't been
1963 * registered yet, return NULL.
1965 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1968 struct ref_store_hash_entry
*entry
;
1971 if (!map
->tablesize
)
1972 /* It's initialized on demand in register_ref_store(). */
1975 hash
= strhash(name
);
1976 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1977 struct ref_store_hash_entry
, ent
);
1978 return entry
? entry
->refs
: NULL
;
1982 * Create, record, and return a ref_store instance for the specified
1985 static struct ref_store
*ref_store_init(struct repository
*repo
,
1989 const char *be_name
= "files";
1990 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1991 struct ref_store
*refs
;
1994 BUG("reference backend %s is unknown", be_name
);
1996 refs
= be
->init(repo
, gitdir
, flags
);
2000 struct ref_store
*get_main_ref_store(struct repository
*r
)
2002 if (r
->refs_private
)
2003 return r
->refs_private
;
2006 BUG("attempting to get main_ref_store outside of repository");
2008 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2009 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2010 return r
->refs_private
;
2014 * Associate a ref store with a name. It is a fatal error to call this
2015 * function twice for the same name.
2017 static void register_ref_store_map(struct hashmap
*map
,
2019 struct ref_store
*refs
,
2022 struct ref_store_hash_entry
*entry
;
2024 if (!map
->tablesize
)
2025 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2027 entry
= alloc_ref_store_hash_entry(name
, refs
);
2028 if (hashmap_put(map
, &entry
->ent
))
2029 BUG("%s ref_store '%s' initialized twice", type
, name
);
2032 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2034 struct strbuf submodule_sb
= STRBUF_INIT
;
2035 struct ref_store
*refs
;
2036 char *to_free
= NULL
;
2038 struct repository
*subrepo
;
2043 len
= strlen(submodule
);
2044 while (len
&& is_dir_sep(submodule
[len
- 1]))
2050 /* We need to strip off one or more trailing slashes */
2051 submodule
= to_free
= xmemdupz(submodule
, len
);
2053 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2057 strbuf_addstr(&submodule_sb
, submodule
);
2058 if (!is_nonbare_repository_dir(&submodule_sb
))
2061 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2064 subrepo
= xmalloc(sizeof(*subrepo
));
2066 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2067 * superprojects other than the_repository. This probably should be
2068 * done by making it take a struct repository * parameter instead of a
2071 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2076 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2077 REF_STORE_READ
| REF_STORE_ODB
);
2078 register_ref_store_map(&submodule_ref_stores
, "submodule",
2082 strbuf_release(&submodule_sb
);
2088 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2090 struct ref_store
*refs
;
2094 return get_main_ref_store(the_repository
);
2096 id
= wt
->id
? wt
->id
: "/";
2097 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2102 refs
= ref_store_init(the_repository
,
2103 git_common_path("worktrees/%s", wt
->id
),
2104 REF_STORE_ALL_CAPS
);
2106 refs
= ref_store_init(the_repository
,
2107 get_git_common_dir(),
2108 REF_STORE_ALL_CAPS
);
2111 register_ref_store_map(&worktree_ref_stores
, "worktree",
2116 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2117 const char *path
, const struct ref_storage_be
*be
)
2121 refs
->gitdir
= xstrdup(path
);
2124 /* backend functions */
2125 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
2127 return refs
->be
->pack_refs(refs
, flags
);
2130 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2132 if (current_ref_iter
&&
2133 (current_ref_iter
->oid
== base
||
2134 oideq(current_ref_iter
->oid
, base
)))
2135 return ref_iterator_peel(current_ref_iter
, peeled
);
2137 return peel_object(base
, peeled
) ? -1 : 0;
2140 int refs_create_symref(struct ref_store
*refs
,
2141 const char *ref_target
,
2142 const char *refs_heads_master
,
2148 msg
= normalize_reflog_message(logmsg
);
2149 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2155 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2158 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2159 refs_heads_master
, logmsg
);
2162 int ref_update_reject_duplicates(struct string_list
*refnames
,
2165 size_t i
, n
= refnames
->nr
;
2169 for (i
= 1; i
< n
; i
++) {
2170 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2171 refnames
->items
[i
].string
);
2175 _("multiple updates for ref '%s' not allowed"),
2176 refnames
->items
[i
].string
);
2178 } else if (cmp
> 0) {
2179 BUG("ref_update_reject_duplicates() received unsorted list");
2185 static int run_transaction_hook(struct ref_transaction
*transaction
,
2188 struct child_process proc
= CHILD_PROCESS_INIT
;
2189 struct strbuf buf
= STRBUF_INIT
;
2193 hook
= find_hook("reference-transaction");
2197 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2199 proc
.stdout_to_stderr
= 1;
2200 proc
.trace2_hook_name
= "reference-transaction";
2202 ret
= start_command(&proc
);
2206 sigchain_push(SIGPIPE
, SIG_IGN
);
2208 for (i
= 0; i
< transaction
->nr
; i
++) {
2209 struct ref_update
*update
= transaction
->updates
[i
];
2212 strbuf_addf(&buf
, "%s %s %s\n",
2213 oid_to_hex(&update
->old_oid
),
2214 oid_to_hex(&update
->new_oid
),
2217 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2218 if (errno
!= EPIPE
) {
2219 /* Don't leak errno outside this API */
2228 sigchain_pop(SIGPIPE
);
2229 strbuf_release(&buf
);
2231 ret
|= finish_command(&proc
);
2235 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2238 struct ref_store
*refs
= transaction
->ref_store
;
2241 switch (transaction
->state
) {
2242 case REF_TRANSACTION_OPEN
:
2245 case REF_TRANSACTION_PREPARED
:
2246 BUG("prepare called twice on reference transaction");
2248 case REF_TRANSACTION_CLOSED
:
2249 BUG("prepare called on a closed reference transaction");
2252 BUG("unexpected reference transaction state");
2256 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2258 _("ref updates forbidden inside quarantine environment"));
2262 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2266 ret
= run_transaction_hook(transaction
, "prepared");
2268 ref_transaction_abort(transaction
, err
);
2269 die(_("ref updates aborted by hook"));
2275 int ref_transaction_abort(struct ref_transaction
*transaction
,
2278 struct ref_store
*refs
= transaction
->ref_store
;
2281 switch (transaction
->state
) {
2282 case REF_TRANSACTION_OPEN
:
2283 /* No need to abort explicitly. */
2285 case REF_TRANSACTION_PREPARED
:
2286 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2288 case REF_TRANSACTION_CLOSED
:
2289 BUG("abort called on a closed reference transaction");
2292 BUG("unexpected reference transaction state");
2296 run_transaction_hook(transaction
, "aborted");
2298 ref_transaction_free(transaction
);
2302 int ref_transaction_commit(struct ref_transaction
*transaction
,
2305 struct ref_store
*refs
= transaction
->ref_store
;
2308 switch (transaction
->state
) {
2309 case REF_TRANSACTION_OPEN
:
2310 /* Need to prepare first. */
2311 ret
= ref_transaction_prepare(transaction
, err
);
2315 case REF_TRANSACTION_PREPARED
:
2316 /* Fall through to finish. */
2318 case REF_TRANSACTION_CLOSED
:
2319 BUG("commit called on a closed reference transaction");
2322 BUG("unexpected reference transaction state");
2326 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2328 run_transaction_hook(transaction
, "committed");
2332 int refs_verify_refname_available(struct ref_store
*refs
,
2333 const char *refname
,
2334 const struct string_list
*extras
,
2335 const struct string_list
*skip
,
2339 const char *extra_refname
;
2340 struct strbuf dirname
= STRBUF_INIT
;
2341 struct strbuf referent
= STRBUF_INIT
;
2342 struct object_id oid
;
2344 struct ref_iterator
*iter
;
2349 * For the sake of comments in this function, suppose that
2350 * refname is "refs/foo/bar".
2355 strbuf_grow(&dirname
, strlen(refname
) + 1);
2356 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2358 * Just saying "Is a directory" when we e.g. can't
2359 * lock some multi-level ref isn't very informative,
2360 * the user won't be told *what* is a directory, so
2361 * let's not use strerror() below.
2364 /* Expand dirname to the new prefix, not including the trailing slash: */
2365 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2368 * We are still at a leading dir of the refname (e.g.,
2369 * "refs/foo"; if there is a reference with that name,
2370 * it is a conflict, *unless* it is in skip.
2372 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2375 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2376 &type
, &ignore_errno
)) {
2377 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2378 dirname
.buf
, refname
);
2382 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2383 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2384 refname
, dirname
.buf
);
2390 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2391 * There is no point in searching for a reference with that
2392 * name, because a refname isn't considered to conflict with
2393 * itself. But we still need to check for references whose
2394 * names are in the "refs/foo/bar/" namespace, because they
2397 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2398 strbuf_addch(&dirname
, '/');
2400 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2401 DO_FOR_EACH_INCLUDE_BROKEN
);
2402 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2404 string_list_has_string(skip
, iter
->refname
))
2407 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2408 iter
->refname
, refname
);
2409 ref_iterator_abort(iter
);
2413 if (ok
!= ITER_DONE
)
2414 BUG("error while iterating over references");
2416 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2418 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2419 refname
, extra_refname
);
2424 strbuf_release(&referent
);
2425 strbuf_release(&dirname
);
2429 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2431 struct ref_iterator
*iter
;
2432 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2434 iter
= refs
->be
->reflog_iterator_begin(refs
);
2436 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2437 do_for_each_ref_helper
, &hp
);
2440 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2442 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2445 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2446 const char *refname
,
2447 each_reflog_ent_fn fn
,
2450 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2454 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2457 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2458 refname
, fn
, cb_data
);
2461 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2462 each_reflog_ent_fn fn
, void *cb_data
)
2464 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2467 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2470 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2474 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2476 return refs
->be
->reflog_exists(refs
, refname
);
2479 int reflog_exists(const char *refname
)
2481 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2484 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2487 return refs
->be
->create_reflog(refs
, refname
, err
);
2490 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2492 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2496 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2498 return refs
->be
->delete_reflog(refs
, refname
);
2501 int delete_reflog(const char *refname
)
2503 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2506 int refs_reflog_expire(struct ref_store
*refs
,
2507 const char *refname
,
2509 reflog_expiry_prepare_fn prepare_fn
,
2510 reflog_expiry_should_prune_fn should_prune_fn
,
2511 reflog_expiry_cleanup_fn cleanup_fn
,
2512 void *policy_cb_data
)
2514 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2515 prepare_fn
, should_prune_fn
,
2516 cleanup_fn
, policy_cb_data
);
2519 int reflog_expire(const char *refname
,
2521 reflog_expiry_prepare_fn prepare_fn
,
2522 reflog_expiry_should_prune_fn should_prune_fn
,
2523 reflog_expiry_cleanup_fn cleanup_fn
,
2524 void *policy_cb_data
)
2526 return refs_reflog_expire(get_main_ref_store(the_repository
),
2528 prepare_fn
, should_prune_fn
,
2529 cleanup_fn
, policy_cb_data
);
2532 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2535 struct ref_store
*refs
= transaction
->ref_store
;
2537 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2540 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2541 ref_transaction_for_each_queued_update_fn cb
,
2546 for (i
= 0; i
< transaction
->nr
; i
++) {
2547 struct ref_update
*update
= transaction
->updates
[i
];
2550 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2551 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2556 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2557 struct string_list
*refnames
, unsigned int flags
)
2562 msg
= normalize_reflog_message(logmsg
);
2563 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2568 int delete_refs(const char *msg
, struct string_list
*refnames
,
2571 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2574 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2575 const char *newref
, const char *logmsg
)
2580 msg
= normalize_reflog_message(logmsg
);
2581 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2586 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2588 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2591 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2592 const char *newref
, const char *logmsg
)
2597 msg
= normalize_reflog_message(logmsg
);
2598 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2603 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2605 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);