2 * The backend-independent part of the reference module.
5 #include "git-compat-util.h"
9 #include "environment.h"
16 #include "refs/refs-internal.h"
17 #include "run-command.h"
19 #include "object-name.h"
20 #include "object-store.h"
23 #include "submodule.h"
26 #include "repository.h"
34 * List of all available backends
36 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
38 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
40 struct ref_storage_be
*be
;
41 for (be
= refs_backends
; be
; be
= be
->next
)
42 if (!strcmp(be
->name
, name
))
48 * How to handle various characters in refnames:
49 * 0: An acceptable character for refs
51 * 2: ., look for a preceding . to reject .. in refs
52 * 3: {, look for a preceding @ to reject @{ in refs
53 * 4: A bad character: ASCII control characters, and
54 * ":", "?", "[", "\", "^", "~", SP, or TAB
55 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
57 static unsigned char refname_disposition
[256] = {
58 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
59 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
60 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
61 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
62 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
63 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
64 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
65 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
68 struct ref_namespace_info ref_namespace
[] = {
71 .decoration
= DECORATION_REF_HEAD
,
74 [NAMESPACE_BRANCHES
] = {
76 .decoration
= DECORATION_REF_LOCAL
,
80 .decoration
= DECORATION_REF_TAG
,
82 [NAMESPACE_REMOTE_REFS
] = {
84 * The default refspec for new remotes copies refs from
85 * refs/heads/ on the remote into refs/remotes/<remote>/.
86 * As such, "refs/remotes/" has special handling.
88 .ref
= "refs/remotes/",
89 .decoration
= DECORATION_REF_REMOTE
,
93 * The single ref "refs/stash" stores the latest stash.
94 * Older stashes can be found in the reflog.
98 .decoration
= DECORATION_REF_STASH
,
100 [NAMESPACE_REPLACE
] = {
102 * This namespace allows Git to act as if one object ID
103 * points to the content of another. Unlike the other
104 * ref namespaces, this one can be changed by the
105 * GIT_REPLACE_REF_BASE environment variable. This
106 * .namespace value will be overwritten in setup_git_env().
108 .ref
= "refs/replace/",
109 .decoration
= DECORATION_GRAFTED
,
111 [NAMESPACE_NOTES
] = {
113 * The refs/notes/commit ref points to the tip of a
114 * parallel commit history that adds metadata to commits
115 * in the normal history. This ref can be overwritten
116 * by the core.notesRef config variable or the
117 * GIT_NOTES_REFS environment variable.
119 .ref
= "refs/notes/commit",
122 [NAMESPACE_PREFETCH
] = {
124 * Prefetch refs are written by the background 'fetch'
125 * maintenance task. It allows faster foreground fetches
126 * by advertising these previously-downloaded tips without
127 * updating refs/remotes/ without user intervention.
129 .ref
= "refs/prefetch/",
131 [NAMESPACE_REWRITTEN
] = {
133 * Rewritten refs are used by the 'label' command in the
134 * sequencer. These are particularly useful during an
135 * interactive rebase that uses the 'merge' command.
137 .ref
= "refs/rewritten/",
141 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
143 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
144 if (info
->ref_updated
)
147 info
->ref_updated
= 1;
151 * Try to read one refname component from the front of refname.
152 * Return the length of the component found, or -1 if the component is
153 * not legal. It is legal if it is something reasonable to have under
154 * ".git/refs/"; We do not like it if:
156 * - it begins with ".", or
157 * - it has double dots "..", or
158 * - it has ASCII control characters, or
159 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
160 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
161 * - it ends with a "/", or
162 * - it ends with ".lock", or
163 * - it contains a "@{" portion
165 * When sanitized is not NULL, instead of rejecting the input refname
166 * as an error, try to come up with a usable replacement for the input
169 static int check_refname_component(const char *refname
, int *flags
,
170 struct strbuf
*sanitized
)
174 size_t component_start
= 0; /* garbage - not a reasonable initial value */
177 component_start
= sanitized
->len
;
179 for (cp
= refname
; ; cp
++) {
181 unsigned char disp
= refname_disposition
[ch
];
183 if (sanitized
&& disp
!= 1)
184 strbuf_addch(sanitized
, ch
);
190 if (last
== '.') { /* Refname contains "..". */
192 /* collapse ".." to single "." */
193 strbuf_setlen(sanitized
, sanitized
->len
- 1);
199 if (last
== '@') { /* Refname contains "@{". */
201 sanitized
->buf
[sanitized
->len
-1] = '-';
209 sanitized
->buf
[sanitized
->len
-1] = '-';
214 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
215 /* refspec can't be a pattern */
217 sanitized
->buf
[sanitized
->len
-1] = '-';
223 * Unset the pattern flag so that we only accept
224 * a single asterisk for one side of refspec.
226 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
233 return 0; /* Component has zero length. */
235 if (refname
[0] == '.') { /* Component starts with '.'. */
237 sanitized
->buf
[component_start
] = '-';
241 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
242 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
245 /* Refname ends with ".lock". */
246 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
247 /* try again in case we have .lock.lock */
253 static int check_or_sanitize_refname(const char *refname
, int flags
,
254 struct strbuf
*sanitized
)
256 int component_len
, component_count
= 0;
258 if (!strcmp(refname
, "@")) {
259 /* Refname is a single character '@'. */
261 strbuf_addch(sanitized
, '-');
267 if (sanitized
&& sanitized
->len
)
268 strbuf_complete(sanitized
, '/');
270 /* We are at the start of a path component. */
271 component_len
= check_refname_component(refname
, &flags
,
273 if (sanitized
&& component_len
== 0)
274 ; /* OK, omit empty component */
275 else if (component_len
<= 0)
279 if (refname
[component_len
] == '\0')
281 /* Skip to next component. */
282 refname
+= component_len
+ 1;
285 if (refname
[component_len
- 1] == '.') {
286 /* Refname ends with '.'. */
288 ; /* omit ending dot */
292 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
293 return -1; /* Refname has only one component. */
297 int check_refname_format(const char *refname
, int flags
)
299 return check_or_sanitize_refname(refname
, flags
, NULL
);
302 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
304 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
305 BUG("sanitizing refname '%s' check returned error", refname
);
308 int refname_is_safe(const char *refname
)
312 if (skip_prefix(refname
, "refs/", &rest
)) {
315 size_t restlen
= strlen(rest
);
317 /* rest must not be empty, or start or end with "/" */
318 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
322 * Does the refname try to escape refs/?
323 * For example: refs/foo/../bar is safe but refs/foo/../../bar
326 buf
= xmallocz(restlen
);
327 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
333 if (!isupper(*refname
) && *refname
!= '_')
341 * Return true if refname, which has the specified oid and flags, can
342 * be resolved to an object in the database. If the referred-to object
343 * does not exist, emit a warning and return false.
345 int ref_resolves_to_object(const char *refname
,
346 struct repository
*repo
,
347 const struct object_id
*oid
,
350 if (flags
& REF_ISBROKEN
)
352 if (!repo_has_object_file(repo
, oid
)) {
353 error(_("%s does not point to a valid object!"), refname
);
359 char *refs_resolve_refdup(struct ref_store
*refs
,
360 const char *refname
, int resolve_flags
,
361 struct object_id
*oid
, int *flags
)
365 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
367 return xstrdup_or_null(result
);
370 char *resolve_refdup(const char *refname
, int resolve_flags
,
371 struct object_id
*oid
, int *flags
)
373 return refs_resolve_refdup(get_main_ref_store(the_repository
),
374 refname
, resolve_flags
,
378 /* The argument to for_each_filter_refs */
379 struct for_each_ref_filter
{
386 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
388 struct ref_store
*refs
= get_main_ref_store(the_repository
);
390 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
396 int read_ref(const char *refname
, struct object_id
*oid
)
398 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
401 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
403 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
407 int ref_exists(const char *refname
)
409 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
412 static int for_each_filter_refs(const char *refname
,
413 const struct object_id
*oid
,
414 int flags
, void *data
)
416 struct for_each_ref_filter
*filter
= data
;
418 if (wildmatch(filter
->pattern
, refname
, 0))
421 skip_prefix(refname
, filter
->prefix
, &refname
);
422 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
425 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
427 struct object
*o
= lookup_unknown_object(the_repository
, name
);
429 if (o
->type
== OBJ_NONE
) {
430 int type
= oid_object_info(the_repository
, name
, NULL
);
431 if (type
< 0 || !object_as_type(o
, type
, 0))
435 if (o
->type
!= OBJ_TAG
)
438 o
= deref_tag_noverify(o
);
442 oidcpy(oid
, &o
->oid
);
446 struct warn_if_dangling_data
{
449 const struct string_list
*refnames
;
453 static int warn_if_dangling_symref(const char *refname
,
454 const struct object_id
*oid UNUSED
,
455 int flags
, void *cb_data
)
457 struct warn_if_dangling_data
*d
= cb_data
;
458 const char *resolves_to
;
460 if (!(flags
& REF_ISSYMREF
))
463 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
466 ? strcmp(resolves_to
, d
->refname
)
467 : !string_list_has_string(d
->refnames
, resolves_to
))) {
471 fprintf(d
->fp
, d
->msg_fmt
, refname
);
476 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
478 struct warn_if_dangling_data data
;
481 data
.refname
= refname
;
482 data
.refnames
= NULL
;
483 data
.msg_fmt
= msg_fmt
;
484 for_each_rawref(warn_if_dangling_symref
, &data
);
487 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
489 struct warn_if_dangling_data data
;
493 data
.refnames
= refnames
;
494 data
.msg_fmt
= msg_fmt
;
495 for_each_rawref(warn_if_dangling_symref
, &data
);
498 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
500 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
503 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
505 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
508 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
510 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
513 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
515 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
518 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
520 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
523 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
525 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
528 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
530 struct strbuf buf
= STRBUF_INIT
;
532 struct object_id oid
;
535 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
536 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
537 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
538 strbuf_release(&buf
);
543 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
546 struct strbuf normalized_pattern
= STRBUF_INIT
;
549 BUG("pattern must not start with '/'");
552 strbuf_addstr(&normalized_pattern
, prefix
);
553 else if (!starts_with(pattern
, "refs/") &&
554 strcmp(pattern
, "HEAD"))
555 strbuf_addstr(&normalized_pattern
, "refs/");
557 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
561 strbuf_addstr(&normalized_pattern
, pattern
);
562 strbuf_strip_suffix(&normalized_pattern
, "/");
564 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
565 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
566 strbuf_release(&normalized_pattern
);
569 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
570 const char *prefix
, void *cb_data
)
572 struct strbuf real_pattern
= STRBUF_INIT
;
573 struct for_each_ref_filter filter
;
576 if (!prefix
&& !starts_with(pattern
, "refs/"))
577 strbuf_addstr(&real_pattern
, "refs/");
579 strbuf_addstr(&real_pattern
, prefix
);
580 strbuf_addstr(&real_pattern
, pattern
);
582 if (!has_glob_specials(pattern
)) {
583 /* Append implied '/' '*' if not present. */
584 strbuf_complete(&real_pattern
, '/');
585 /* No need to check for '*', there is none. */
586 strbuf_addch(&real_pattern
, '*');
589 filter
.pattern
= real_pattern
.buf
;
590 filter
.prefix
= prefix
;
592 filter
.cb_data
= cb_data
;
593 ret
= for_each_ref(for_each_filter_refs
, &filter
);
595 strbuf_release(&real_pattern
);
599 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
601 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
604 const char *prettify_refname(const char *name
)
606 if (skip_prefix(name
, "refs/heads/", &name
) ||
607 skip_prefix(name
, "refs/tags/", &name
) ||
608 skip_prefix(name
, "refs/remotes/", &name
))
613 static const char *ref_rev_parse_rules
[] = {
619 "refs/remotes/%.*s/HEAD",
623 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
626 * Is it possible that the caller meant full_name with abbrev_name?
627 * If so return a non-zero value to signal "yes"; the magnitude of
628 * the returned value gives the precedence used for disambiguation.
630 * If abbrev_name cannot mean full_name, return 0.
632 int refname_match(const char *abbrev_name
, const char *full_name
)
635 const int abbrev_name_len
= strlen(abbrev_name
);
636 const int num_rules
= NUM_REV_PARSE_RULES
;
638 for (p
= ref_rev_parse_rules
; *p
; p
++)
639 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
640 return &ref_rev_parse_rules
[num_rules
] - p
;
646 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
647 * the results to 'prefixes'
649 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
652 int len
= strlen(prefix
);
654 for (p
= ref_rev_parse_rules
; *p
; p
++)
655 strvec_pushf(prefixes
, *p
, len
, prefix
);
658 static const char default_branch_name_advice
[] = N_(
659 "Using '%s' as the name for the initial branch. This default branch name\n"
660 "is subject to change. To configure the initial branch name to use in all\n"
661 "of your new repositories, which will suppress this warning, call:\n"
663 "\tgit config --global init.defaultBranch <name>\n"
665 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
666 "'development'. The just-created branch can be renamed via this command:\n"
668 "\tgit branch -m <name>\n"
671 char *repo_default_branch_name(struct repository
*r
, int quiet
)
673 const char *config_key
= "init.defaultbranch";
674 const char *config_display_key
= "init.defaultBranch";
675 char *ret
= NULL
, *full_ref
;
676 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
680 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
681 die(_("could not retrieve `%s`"), config_display_key
);
684 ret
= xstrdup("master");
686 advise(_(default_branch_name_advice
), ret
);
689 full_ref
= xstrfmt("refs/heads/%s", ret
);
690 if (check_refname_format(full_ref
, 0))
691 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
697 const char *git_default_branch_name(int quiet
)
702 ret
= repo_default_branch_name(the_repository
, quiet
);
708 * *string and *len will only be substituted, and *string returned (for
709 * later free()ing) if the string passed in is a magic short-hand form
712 static char *substitute_branch_name(struct repository
*r
,
713 const char **string
, int *len
,
714 int nonfatal_dangling_mark
)
716 struct strbuf buf
= STRBUF_INIT
;
717 struct interpret_branch_name_options options
= {
718 .nonfatal_dangling_mark
= nonfatal_dangling_mark
720 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
724 *string
= strbuf_detach(&buf
, &size
);
726 return (char *)*string
;
732 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
733 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
735 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
736 nonfatal_dangling_mark
);
737 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
742 int expand_ref(struct repository
*repo
, const char *str
, int len
,
743 struct object_id
*oid
, char **ref
)
747 struct strbuf fullref
= STRBUF_INIT
;
750 for (p
= ref_rev_parse_rules
; *p
; p
++) {
751 struct object_id oid_from_ref
;
752 struct object_id
*this_result
;
754 struct ref_store
*refs
= get_main_ref_store(repo
);
756 this_result
= refs_found
? &oid_from_ref
: oid
;
757 strbuf_reset(&fullref
);
758 strbuf_addf(&fullref
, *p
, len
, str
);
759 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
765 if (!warn_ambiguous_refs
)
767 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
768 warning(_("ignoring dangling symref %s"), fullref
.buf
);
769 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
770 warning(_("ignoring broken ref %s"), fullref
.buf
);
773 strbuf_release(&fullref
);
777 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
778 struct object_id
*oid
, char **log
)
780 struct ref_store
*refs
= get_main_ref_store(r
);
781 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
784 struct strbuf path
= STRBUF_INIT
;
787 for (p
= ref_rev_parse_rules
; *p
; p
++) {
788 struct object_id hash
;
789 const char *ref
, *it
;
792 strbuf_addf(&path
, *p
, len
, str
);
793 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
795 oid
? &hash
: NULL
, NULL
);
798 if (refs_reflog_exists(refs
, path
.buf
))
800 else if (strcmp(ref
, path
.buf
) &&
801 refs_reflog_exists(refs
, ref
))
810 if (!warn_ambiguous_refs
)
813 strbuf_release(&path
);
818 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
820 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
823 int is_per_worktree_ref(const char *refname
)
825 return starts_with(refname
, "refs/worktree/") ||
826 starts_with(refname
, "refs/bisect/") ||
827 starts_with(refname
, "refs/rewritten/");
830 static int is_pseudoref_syntax(const char *refname
)
834 for (c
= refname
; *c
; c
++) {
835 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
840 * HEAD is not a pseudoref, but it certainly uses the
846 static int is_current_worktree_ref(const char *ref
) {
847 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
850 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
851 const char **worktree_name
, int *worktree_name_length
,
852 const char **bare_refname
)
854 const char *name_dummy
;
855 int name_length_dummy
;
856 const char *ref_dummy
;
859 worktree_name
= &name_dummy
;
860 if (!worktree_name_length
)
861 worktree_name_length
= &name_length_dummy
;
863 bare_refname
= &ref_dummy
;
865 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
866 const char *slash
= strchr(*bare_refname
, '/');
868 *worktree_name
= *bare_refname
;
870 *worktree_name_length
= strlen(*worktree_name
);
872 /* This is an error condition, and the caller tell because the bare_refname is "" */
873 *bare_refname
= *worktree_name
+ *worktree_name_length
;
874 return REF_WORKTREE_OTHER
;
877 *worktree_name_length
= slash
- *bare_refname
;
878 *bare_refname
= slash
+ 1;
880 if (is_current_worktree_ref(*bare_refname
))
881 return REF_WORKTREE_OTHER
;
884 *worktree_name
= NULL
;
885 *worktree_name_length
= 0;
887 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
888 && is_current_worktree_ref(*bare_refname
))
889 return REF_WORKTREE_MAIN
;
891 *bare_refname
= maybe_worktree_ref
;
892 if (is_current_worktree_ref(maybe_worktree_ref
))
893 return REF_WORKTREE_CURRENT
;
895 return REF_WORKTREE_SHARED
;
898 long get_files_ref_lock_timeout_ms(void)
900 static int configured
= 0;
902 /* The default timeout is 100 ms: */
903 static int timeout_ms
= 100;
906 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
913 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
915 const struct object_id
*old_oid
,
918 struct ref_transaction
*transaction
;
919 struct strbuf err
= STRBUF_INIT
;
921 transaction
= ref_store_transaction_begin(refs
, &err
);
923 ref_transaction_delete(transaction
, refname
, old_oid
,
925 ref_transaction_commit(transaction
, &err
)) {
926 error("%s", err
.buf
);
927 ref_transaction_free(transaction
);
928 strbuf_release(&err
);
931 ref_transaction_free(transaction
);
932 strbuf_release(&err
);
936 int delete_ref(const char *msg
, const char *refname
,
937 const struct object_id
*old_oid
, unsigned int flags
)
939 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
943 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
948 while ((c
= *msg
++)) {
949 if (wasspace
&& isspace(c
))
951 wasspace
= isspace(c
);
959 static char *normalize_reflog_message(const char *msg
)
961 struct strbuf sb
= STRBUF_INIT
;
964 copy_reflog_msg(&sb
, msg
);
965 return strbuf_detach(&sb
, NULL
);
968 int should_autocreate_reflog(const char *refname
)
970 switch (log_all_ref_updates
) {
971 case LOG_REFS_ALWAYS
:
973 case LOG_REFS_NORMAL
:
974 return starts_with(refname
, "refs/heads/") ||
975 starts_with(refname
, "refs/remotes/") ||
976 starts_with(refname
, "refs/notes/") ||
977 !strcmp(refname
, "HEAD");
983 int is_branch(const char *refname
)
985 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
988 struct read_ref_at_cb
{
993 struct object_id
*oid
;
996 struct object_id ooid
;
997 struct object_id noid
;
1001 timestamp_t
*cutoff_time
;
1006 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
1007 timestamp_t timestamp
, int tz
, const char *message
)
1010 *cb
->msg
= xstrdup(message
);
1011 if (cb
->cutoff_time
)
1012 *cb
->cutoff_time
= timestamp
;
1014 *cb
->cutoff_tz
= tz
;
1016 *cb
->cutoff_cnt
= cb
->reccnt
;
1019 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1020 const char *email UNUSED
,
1021 timestamp_t timestamp
, int tz
,
1022 const char *message
, void *cb_data
)
1024 struct read_ref_at_cb
*cb
= cb_data
;
1028 cb
->date
= timestamp
;
1031 * It is not possible for cb->cnt == 0 on the first iteration because
1032 * that special case is handled in read_ref_at().
1036 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
1037 if (timestamp
<= cb
->at_time
|| reached_count
) {
1038 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1040 * we have not yet updated cb->[n|o]oid so they still
1041 * hold the values for the previous record.
1043 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
1044 warning(_("log for ref %s has gap after %s"),
1045 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1047 oidcpy(cb
->oid
, ooid
);
1048 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
1049 oidcpy(cb
->oid
, noid
);
1050 else if (!oideq(noid
, cb
->oid
))
1051 warning(_("log for ref %s unexpectedly ended on %s"),
1052 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1053 DATE_MODE(RFC2822
)));
1057 oidcpy(&cb
->ooid
, ooid
);
1058 oidcpy(&cb
->noid
, noid
);
1059 return cb
->found_it
;
1062 static int read_ref_at_ent_newest(struct object_id
*ooid UNUSED
,
1063 struct object_id
*noid
,
1064 const char *email UNUSED
,
1065 timestamp_t timestamp
, int tz
,
1066 const char *message
, void *cb_data
)
1068 struct read_ref_at_cb
*cb
= cb_data
;
1070 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1071 oidcpy(cb
->oid
, noid
);
1072 /* We just want the first entry */
1076 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1077 const char *email UNUSED
,
1078 timestamp_t timestamp
, int tz
,
1079 const char *message
, void *cb_data
)
1081 struct read_ref_at_cb
*cb
= cb_data
;
1083 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1084 oidcpy(cb
->oid
, ooid
);
1085 if (is_null_oid(cb
->oid
))
1086 oidcpy(cb
->oid
, noid
);
1087 /* We just want the first entry */
1091 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1092 unsigned int flags
, timestamp_t at_time
, int cnt
,
1093 struct object_id
*oid
, char **msg
,
1094 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1096 struct read_ref_at_cb cb
;
1098 memset(&cb
, 0, sizeof(cb
));
1099 cb
.refname
= refname
;
1100 cb
.at_time
= at_time
;
1103 cb
.cutoff_time
= cutoff_time
;
1104 cb
.cutoff_tz
= cutoff_tz
;
1105 cb
.cutoff_cnt
= cutoff_cnt
;
1109 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
1113 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1116 if (flags
& GET_OID_QUIETLY
)
1119 die(_("log for %s is empty"), refname
);
1124 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1129 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1132 struct ref_transaction
*tr
;
1135 CALLOC_ARRAY(tr
, 1);
1136 tr
->ref_store
= refs
;
1140 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1142 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1145 void ref_transaction_free(struct ref_transaction
*transaction
)
1152 switch (transaction
->state
) {
1153 case REF_TRANSACTION_OPEN
:
1154 case REF_TRANSACTION_CLOSED
:
1157 case REF_TRANSACTION_PREPARED
:
1158 BUG("free called on a prepared reference transaction");
1161 BUG("unexpected reference transaction state");
1165 for (i
= 0; i
< transaction
->nr
; i
++) {
1166 free(transaction
->updates
[i
]->msg
);
1167 free(transaction
->updates
[i
]);
1169 free(transaction
->updates
);
1173 struct ref_update
*ref_transaction_add_update(
1174 struct ref_transaction
*transaction
,
1175 const char *refname
, unsigned int flags
,
1176 const struct object_id
*new_oid
,
1177 const struct object_id
*old_oid
,
1180 struct ref_update
*update
;
1182 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1183 BUG("update called for transaction that is not open");
1185 FLEX_ALLOC_STR(update
, refname
, refname
);
1186 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1187 transaction
->updates
[transaction
->nr
++] = update
;
1189 update
->flags
= flags
;
1191 if (flags
& REF_HAVE_NEW
)
1192 oidcpy(&update
->new_oid
, new_oid
);
1193 if (flags
& REF_HAVE_OLD
)
1194 oidcpy(&update
->old_oid
, old_oid
);
1195 update
->msg
= normalize_reflog_message(msg
);
1199 int ref_transaction_update(struct ref_transaction
*transaction
,
1200 const char *refname
,
1201 const struct object_id
*new_oid
,
1202 const struct object_id
*old_oid
,
1203 unsigned int flags
, const char *msg
,
1208 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1209 ((new_oid
&& !is_null_oid(new_oid
)) ?
1210 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1211 !refname_is_safe(refname
))) {
1212 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1217 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1218 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1221 * Clear flags outside the allowed set; this should be a noop because
1222 * of the BUG() check above, but it works around a -Wnonnull warning
1223 * with some versions of "gcc -O3".
1225 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1227 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1229 ref_transaction_add_update(transaction
, refname
, flags
,
1230 new_oid
, old_oid
, msg
);
1234 int ref_transaction_create(struct ref_transaction
*transaction
,
1235 const char *refname
,
1236 const struct object_id
*new_oid
,
1237 unsigned int flags
, const char *msg
,
1240 if (!new_oid
|| is_null_oid(new_oid
)) {
1241 strbuf_addf(err
, "'%s' has a null OID", refname
);
1244 return ref_transaction_update(transaction
, refname
, new_oid
,
1245 null_oid(), flags
, msg
, err
);
1248 int ref_transaction_delete(struct ref_transaction
*transaction
,
1249 const char *refname
,
1250 const struct object_id
*old_oid
,
1251 unsigned int flags
, const char *msg
,
1254 if (old_oid
&& is_null_oid(old_oid
))
1255 BUG("delete called with old_oid set to zeros");
1256 return ref_transaction_update(transaction
, refname
,
1257 null_oid(), old_oid
,
1261 int ref_transaction_verify(struct ref_transaction
*transaction
,
1262 const char *refname
,
1263 const struct object_id
*old_oid
,
1268 BUG("verify called with old_oid set to NULL");
1269 return ref_transaction_update(transaction
, refname
,
1274 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1275 const char *refname
, const struct object_id
*new_oid
,
1276 const struct object_id
*old_oid
, unsigned int flags
,
1277 enum action_on_err onerr
)
1279 struct ref_transaction
*t
= NULL
;
1280 struct strbuf err
= STRBUF_INIT
;
1283 t
= ref_store_transaction_begin(refs
, &err
);
1285 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1287 ref_transaction_commit(t
, &err
)) {
1289 ref_transaction_free(t
);
1292 const char *str
= _("update_ref failed for ref '%s': %s");
1295 case UPDATE_REFS_MSG_ON_ERR
:
1296 error(str
, refname
, err
.buf
);
1298 case UPDATE_REFS_DIE_ON_ERR
:
1299 die(str
, refname
, err
.buf
);
1301 case UPDATE_REFS_QUIET_ON_ERR
:
1304 strbuf_release(&err
);
1307 strbuf_release(&err
);
1309 ref_transaction_free(t
);
1313 int update_ref(const char *msg
, const char *refname
,
1314 const struct object_id
*new_oid
,
1315 const struct object_id
*old_oid
,
1316 unsigned int flags
, enum action_on_err onerr
)
1318 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1319 old_oid
, flags
, onerr
);
1323 * Check that the string refname matches a rule of the form
1324 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1325 * "foo/%.*s/baz", and return the string "bar".
1327 static const char *match_parse_rule(const char *refname
, const char *rule
,
1331 * Check that rule matches refname up to the first percent in the rule.
1332 * We can bail immediately if not, but otherwise we leave "rule" at the
1333 * %-placeholder, and "refname" at the start of the potential matched
1336 while (*rule
!= '%') {
1338 BUG("rev-parse rule did not have percent");
1339 if (*refname
++ != *rule
++)
1344 * Check that our "%" is the expected placeholder. This assumes there
1345 * are no other percents (placeholder or quoted) in the string, but
1346 * that is sufficient for our rev-parse rules.
1348 if (!skip_prefix(rule
, "%.*s", &rule
))
1352 * And now check that our suffix (if any) matches.
1354 if (!strip_suffix(refname
, rule
, len
))
1357 return refname
; /* len set by strip_suffix() */
1360 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1361 const char *refname
, int strict
)
1364 struct strbuf resolved_buf
= STRBUF_INIT
;
1366 /* skip first rule, it will always match */
1367 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1369 int rules_to_fail
= i
;
1370 const char *short_name
;
1371 size_t short_name_len
;
1373 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1379 * in strict mode, all (except the matched one) rules
1380 * must fail to resolve to a valid non-ambiguous ref
1383 rules_to_fail
= NUM_REV_PARSE_RULES
;
1386 * check if the short name resolves to a valid ref,
1387 * but use only rules prior to the matched one
1389 for (j
= 0; j
< rules_to_fail
; j
++) {
1390 const char *rule
= ref_rev_parse_rules
[j
];
1392 /* skip matched rule */
1397 * the short name is ambiguous, if it resolves
1398 * (with this previous rule) to a valid ref
1399 * read_ref() returns 0 on success
1401 strbuf_reset(&resolved_buf
);
1402 strbuf_addf(&resolved_buf
, rule
,
1403 cast_size_t_to_int(short_name_len
),
1405 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1410 * short name is non-ambiguous if all previous rules
1411 * haven't resolved to a valid ref
1413 if (j
== rules_to_fail
) {
1414 strbuf_release(&resolved_buf
);
1415 return xmemdupz(short_name
, short_name_len
);
1419 strbuf_release(&resolved_buf
);
1420 return xstrdup(refname
);
1423 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1425 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1429 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1430 struct strvec
*hide_refs
)
1433 if (!strcmp("transfer.hiderefs", var
) ||
1434 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1435 !strcmp(key
, "hiderefs"))) {
1440 return config_error_nonbool(var
);
1442 /* drop const to remove trailing '/' characters */
1443 ref
= (char *)strvec_push(hide_refs
, value
);
1445 while (len
&& ref
[len
- 1] == '/')
1451 int ref_is_hidden(const char *refname
, const char *refname_full
,
1452 const struct strvec
*hide_refs
)
1456 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1457 const char *match
= hide_refs
->v
[i
];
1458 const char *subject
;
1462 if (*match
== '!') {
1467 if (*match
== '^') {
1468 subject
= refname_full
;
1474 /* refname can be NULL when namespaces are used. */
1476 skip_prefix(subject
, match
, &p
) &&
1483 const char *find_descendant_ref(const char *dirname
,
1484 const struct string_list
*extras
,
1485 const struct string_list
*skip
)
1493 * Look at the place where dirname would be inserted into
1494 * extras. If there is an entry at that position that starts
1495 * with dirname (remember, dirname includes the trailing
1496 * slash) and is not in skip, then we have a conflict.
1498 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1499 pos
< extras
->nr
; pos
++) {
1500 const char *extra_refname
= extras
->items
[pos
].string
;
1502 if (!starts_with(extra_refname
, dirname
))
1505 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1506 return extra_refname
;
1511 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1513 struct object_id oid
;
1516 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1518 return fn("HEAD", &oid
, flag
, cb_data
);
1523 int head_ref(each_ref_fn fn
, void *cb_data
)
1525 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1528 struct ref_iterator
*refs_ref_iterator_begin(
1529 struct ref_store
*refs
,
1531 const char **exclude_patterns
,
1533 enum do_for_each_ref_flags flags
)
1535 struct ref_iterator
*iter
;
1537 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1538 static int ref_paranoia
= -1;
1540 if (ref_paranoia
< 0)
1541 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1543 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1544 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1548 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1550 * `iterator_begin()` already takes care of prefix, but we
1551 * might need to do some trimming:
1554 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1556 /* Sanity check for subclasses: */
1558 BUG("reference iterator is not ordered");
1564 * Call fn for each reference in the specified submodule for which the
1565 * refname begins with prefix. If trim is non-zero, then trim that
1566 * many characters off the beginning of each refname before passing
1567 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1568 * include broken references in the iteration. If fn ever returns a
1569 * non-zero value, stop the iteration and return that value;
1570 * otherwise, return 0.
1572 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1573 each_repo_ref_fn fn
, int trim
, int flags
,
1576 struct ref_iterator
*iter
;
1577 struct ref_store
*refs
= get_main_ref_store(r
);
1582 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1584 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1587 struct do_for_each_ref_help
{
1592 static int do_for_each_ref_helper(struct repository
*r
,
1593 const char *refname
,
1594 const struct object_id
*oid
,
1598 struct do_for_each_ref_help
*hp
= cb_data
;
1600 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1603 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1604 const char **exclude_patterns
,
1605 each_ref_fn fn
, int trim
,
1606 enum do_for_each_ref_flags flags
, void *cb_data
)
1608 struct ref_iterator
*iter
;
1609 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1614 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1617 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1618 do_for_each_ref_helper
, &hp
);
1621 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1623 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1626 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1628 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1631 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1632 each_ref_fn fn
, void *cb_data
)
1634 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1637 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1639 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1642 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1644 return do_for_each_ref(get_main_ref_store(the_repository
),
1645 prefix
, NULL
, fn
, 0, 0, cb_data
);
1648 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1649 const char **exclude_patterns
,
1650 each_ref_fn fn
, void *cb_data
)
1652 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1655 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1657 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1658 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1659 strlen(git_replace_ref_base
),
1660 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1663 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1665 struct strbuf buf
= STRBUF_INIT
;
1667 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1668 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1669 buf
.buf
, NULL
, fn
, 0, 0, cb_data
);
1670 strbuf_release(&buf
);
1674 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1676 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1677 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1680 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1682 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1685 static int qsort_strcmp(const void *va
, const void *vb
)
1687 const char *a
= *(const char **)va
;
1688 const char *b
= *(const char **)vb
;
1690 return strcmp(a
, b
);
1693 static void find_longest_prefixes_1(struct string_list
*out
,
1694 struct strbuf
*prefix
,
1695 const char **patterns
, size_t nr
)
1699 for (i
= 0; i
< nr
; i
++) {
1700 char c
= patterns
[i
][prefix
->len
];
1701 if (!c
|| is_glob_special(c
)) {
1702 string_list_append(out
, prefix
->buf
);
1712 * Set "end" to the index of the element _after_ the last one
1715 for (end
= i
+ 1; end
< nr
; end
++) {
1716 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1720 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1721 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1722 strbuf_setlen(prefix
, prefix
->len
- 1);
1728 static void find_longest_prefixes(struct string_list
*out
,
1729 const char **patterns
)
1731 struct strvec sorted
= STRVEC_INIT
;
1732 struct strbuf prefix
= STRBUF_INIT
;
1734 strvec_pushv(&sorted
, patterns
);
1735 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1737 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1739 strvec_clear(&sorted
);
1740 strbuf_release(&prefix
);
1743 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1744 const char *namespace,
1745 const char **patterns
,
1746 const char **exclude_patterns
,
1747 each_ref_fn fn
, void *cb_data
)
1749 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1750 struct string_list_item
*prefix
;
1751 struct strbuf buf
= STRBUF_INIT
;
1752 int ret
= 0, namespace_len
;
1754 find_longest_prefixes(&prefixes
, patterns
);
1757 strbuf_addstr(&buf
, namespace);
1758 namespace_len
= buf
.len
;
1760 for_each_string_list_item(prefix
, &prefixes
) {
1761 strbuf_addstr(&buf
, prefix
->string
);
1762 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1763 exclude_patterns
, fn
, cb_data
);
1766 strbuf_setlen(&buf
, namespace_len
);
1769 string_list_clear(&prefixes
, 0);
1770 strbuf_release(&buf
);
1774 static int refs_read_special_head(struct ref_store
*ref_store
,
1775 const char *refname
, struct object_id
*oid
,
1776 struct strbuf
*referent
, unsigned int *type
,
1779 struct strbuf full_path
= STRBUF_INIT
;
1780 struct strbuf content
= STRBUF_INIT
;
1782 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1784 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1787 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1791 strbuf_release(&full_path
);
1792 strbuf_release(&content
);
1796 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1797 struct object_id
*oid
, struct strbuf
*referent
,
1798 unsigned int *type
, int *failure_errno
)
1800 assert(failure_errno
);
1801 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1802 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1803 type
, failure_errno
);
1806 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1807 type
, failure_errno
);
1810 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1811 struct strbuf
*referent
)
1813 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1816 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1817 const char *refname
,
1819 struct object_id
*oid
,
1822 static struct strbuf sb_refname
= STRBUF_INIT
;
1823 struct object_id unused_oid
;
1830 flags
= &unused_flags
;
1834 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1835 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1836 !refname_is_safe(refname
))
1840 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1841 * missing refs and refs that were present but invalid,
1842 * to complain about the latter to stderr.
1844 * We don't know whether the ref exists, so don't set
1847 *flags
|= REF_BAD_NAME
;
1850 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1851 unsigned int read_flags
= 0;
1854 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1855 &read_flags
, &failure_errno
)) {
1856 *flags
|= read_flags
;
1858 /* In reading mode, refs must eventually resolve */
1859 if (resolve_flags
& RESOLVE_REF_READING
)
1863 * Otherwise a missing ref is OK. But the files backend
1864 * may show errors besides ENOENT if there are
1865 * similarly-named refs.
1867 if (failure_errno
!= ENOENT
&&
1868 failure_errno
!= EISDIR
&&
1869 failure_errno
!= ENOTDIR
)
1873 if (*flags
& REF_BAD_NAME
)
1874 *flags
|= REF_ISBROKEN
;
1878 *flags
|= read_flags
;
1880 if (!(read_flags
& REF_ISSYMREF
)) {
1881 if (*flags
& REF_BAD_NAME
) {
1883 *flags
|= REF_ISBROKEN
;
1888 refname
= sb_refname
.buf
;
1889 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1893 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1894 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1895 !refname_is_safe(refname
))
1898 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1905 /* backend functions */
1906 int refs_init_db(struct strbuf
*err
)
1908 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1910 return refs
->be
->init_db(refs
, err
);
1913 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1914 struct object_id
*oid
, int *flags
)
1916 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1917 resolve_flags
, oid
, flags
);
1920 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1921 struct object_id
*oid
)
1923 struct ref_store
*refs
;
1926 refs
= get_submodule_ref_store(submodule
);
1931 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1937 struct ref_store_hash_entry
1939 struct hashmap_entry ent
;
1941 struct ref_store
*refs
;
1943 /* NUL-terminated identifier of the ref store: */
1944 char name
[FLEX_ARRAY
];
1947 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
1948 const struct hashmap_entry
*eptr
,
1949 const struct hashmap_entry
*entry_or_key
,
1950 const void *keydata
)
1952 const struct ref_store_hash_entry
*e1
, *e2
;
1955 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1956 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1957 name
= keydata
? keydata
: e2
->name
;
1959 return strcmp(e1
->name
, name
);
1962 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1963 const char *name
, struct ref_store
*refs
)
1965 struct ref_store_hash_entry
*entry
;
1967 FLEX_ALLOC_STR(entry
, name
, name
);
1968 hashmap_entry_init(&entry
->ent
, strhash(name
));
1973 /* A hashmap of ref_stores, stored by submodule name: */
1974 static struct hashmap submodule_ref_stores
;
1976 /* A hashmap of ref_stores, stored by worktree id: */
1977 static struct hashmap worktree_ref_stores
;
1980 * Look up a ref store by name. If that ref_store hasn't been
1981 * registered yet, return NULL.
1983 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1986 struct ref_store_hash_entry
*entry
;
1989 if (!map
->tablesize
)
1990 /* It's initialized on demand in register_ref_store(). */
1993 hash
= strhash(name
);
1994 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1995 struct ref_store_hash_entry
, ent
);
1996 return entry
? entry
->refs
: NULL
;
2000 * Create, record, and return a ref_store instance for the specified
2003 static struct ref_store
*ref_store_init(struct repository
*repo
,
2007 const char *be_name
= "files";
2008 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
2009 struct ref_store
*refs
;
2012 BUG("reference backend %s is unknown", be_name
);
2014 refs
= be
->init(repo
, gitdir
, flags
);
2018 struct ref_store
*get_main_ref_store(struct repository
*r
)
2020 if (r
->refs_private
)
2021 return r
->refs_private
;
2024 BUG("attempting to get main_ref_store outside of repository");
2026 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2027 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2028 return r
->refs_private
;
2032 * Associate a ref store with a name. It is a fatal error to call this
2033 * function twice for the same name.
2035 static void register_ref_store_map(struct hashmap
*map
,
2037 struct ref_store
*refs
,
2040 struct ref_store_hash_entry
*entry
;
2042 if (!map
->tablesize
)
2043 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2045 entry
= alloc_ref_store_hash_entry(name
, refs
);
2046 if (hashmap_put(map
, &entry
->ent
))
2047 BUG("%s ref_store '%s' initialized twice", type
, name
);
2050 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2052 struct strbuf submodule_sb
= STRBUF_INIT
;
2053 struct ref_store
*refs
;
2054 char *to_free
= NULL
;
2056 struct repository
*subrepo
;
2061 len
= strlen(submodule
);
2062 while (len
&& is_dir_sep(submodule
[len
- 1]))
2068 /* We need to strip off one or more trailing slashes */
2069 submodule
= to_free
= xmemdupz(submodule
, len
);
2071 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2075 strbuf_addstr(&submodule_sb
, submodule
);
2076 if (!is_nonbare_repository_dir(&submodule_sb
))
2079 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2082 subrepo
= xmalloc(sizeof(*subrepo
));
2084 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2085 * superprojects other than the_repository. This probably should be
2086 * done by making it take a struct repository * parameter instead of a
2089 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2094 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2095 REF_STORE_READ
| REF_STORE_ODB
);
2096 register_ref_store_map(&submodule_ref_stores
, "submodule",
2100 strbuf_release(&submodule_sb
);
2106 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2108 struct ref_store
*refs
;
2112 return get_main_ref_store(the_repository
);
2114 id
= wt
->id
? wt
->id
: "/";
2115 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2120 refs
= ref_store_init(the_repository
,
2121 git_common_path("worktrees/%s", wt
->id
),
2122 REF_STORE_ALL_CAPS
);
2124 refs
= ref_store_init(the_repository
,
2125 get_git_common_dir(),
2126 REF_STORE_ALL_CAPS
);
2129 register_ref_store_map(&worktree_ref_stores
, "worktree",
2134 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2135 const char *path
, const struct ref_storage_be
*be
)
2139 refs
->gitdir
= xstrdup(path
);
2142 /* backend functions */
2143 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
2145 return refs
->be
->pack_refs(refs
, flags
);
2148 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2150 if (current_ref_iter
&&
2151 (current_ref_iter
->oid
== base
||
2152 oideq(current_ref_iter
->oid
, base
)))
2153 return ref_iterator_peel(current_ref_iter
, peeled
);
2155 return peel_object(base
, peeled
) ? -1 : 0;
2158 int refs_create_symref(struct ref_store
*refs
,
2159 const char *ref_target
,
2160 const char *refs_heads_master
,
2166 msg
= normalize_reflog_message(logmsg
);
2167 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2173 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2176 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2177 refs_heads_master
, logmsg
);
2180 int ref_update_reject_duplicates(struct string_list
*refnames
,
2183 size_t i
, n
= refnames
->nr
;
2187 for (i
= 1; i
< n
; i
++) {
2188 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2189 refnames
->items
[i
].string
);
2193 _("multiple updates for ref '%s' not allowed"),
2194 refnames
->items
[i
].string
);
2196 } else if (cmp
> 0) {
2197 BUG("ref_update_reject_duplicates() received unsorted list");
2203 static int run_transaction_hook(struct ref_transaction
*transaction
,
2206 struct child_process proc
= CHILD_PROCESS_INIT
;
2207 struct strbuf buf
= STRBUF_INIT
;
2211 hook
= find_hook("reference-transaction");
2215 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2217 proc
.stdout_to_stderr
= 1;
2218 proc
.trace2_hook_name
= "reference-transaction";
2220 ret
= start_command(&proc
);
2224 sigchain_push(SIGPIPE
, SIG_IGN
);
2226 for (i
= 0; i
< transaction
->nr
; i
++) {
2227 struct ref_update
*update
= transaction
->updates
[i
];
2230 strbuf_addf(&buf
, "%s %s %s\n",
2231 oid_to_hex(&update
->old_oid
),
2232 oid_to_hex(&update
->new_oid
),
2235 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2236 if (errno
!= EPIPE
) {
2237 /* Don't leak errno outside this API */
2246 sigchain_pop(SIGPIPE
);
2247 strbuf_release(&buf
);
2249 ret
|= finish_command(&proc
);
2253 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2256 struct ref_store
*refs
= transaction
->ref_store
;
2259 switch (transaction
->state
) {
2260 case REF_TRANSACTION_OPEN
:
2263 case REF_TRANSACTION_PREPARED
:
2264 BUG("prepare called twice on reference transaction");
2266 case REF_TRANSACTION_CLOSED
:
2267 BUG("prepare called on a closed reference transaction");
2270 BUG("unexpected reference transaction state");
2274 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2276 _("ref updates forbidden inside quarantine environment"));
2280 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2284 ret
= run_transaction_hook(transaction
, "prepared");
2286 ref_transaction_abort(transaction
, err
);
2287 die(_("ref updates aborted by hook"));
2293 int ref_transaction_abort(struct ref_transaction
*transaction
,
2296 struct ref_store
*refs
= transaction
->ref_store
;
2299 switch (transaction
->state
) {
2300 case REF_TRANSACTION_OPEN
:
2301 /* No need to abort explicitly. */
2303 case REF_TRANSACTION_PREPARED
:
2304 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2306 case REF_TRANSACTION_CLOSED
:
2307 BUG("abort called on a closed reference transaction");
2310 BUG("unexpected reference transaction state");
2314 run_transaction_hook(transaction
, "aborted");
2316 ref_transaction_free(transaction
);
2320 int ref_transaction_commit(struct ref_transaction
*transaction
,
2323 struct ref_store
*refs
= transaction
->ref_store
;
2326 switch (transaction
->state
) {
2327 case REF_TRANSACTION_OPEN
:
2328 /* Need to prepare first. */
2329 ret
= ref_transaction_prepare(transaction
, err
);
2333 case REF_TRANSACTION_PREPARED
:
2334 /* Fall through to finish. */
2336 case REF_TRANSACTION_CLOSED
:
2337 BUG("commit called on a closed reference transaction");
2340 BUG("unexpected reference transaction state");
2344 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2346 run_transaction_hook(transaction
, "committed");
2350 int refs_verify_refname_available(struct ref_store
*refs
,
2351 const char *refname
,
2352 const struct string_list
*extras
,
2353 const struct string_list
*skip
,
2357 const char *extra_refname
;
2358 struct strbuf dirname
= STRBUF_INIT
;
2359 struct strbuf referent
= STRBUF_INIT
;
2360 struct object_id oid
;
2362 struct ref_iterator
*iter
;
2367 * For the sake of comments in this function, suppose that
2368 * refname is "refs/foo/bar".
2373 strbuf_grow(&dirname
, strlen(refname
) + 1);
2374 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2376 * Just saying "Is a directory" when we e.g. can't
2377 * lock some multi-level ref isn't very informative,
2378 * the user won't be told *what* is a directory, so
2379 * let's not use strerror() below.
2382 /* Expand dirname to the new prefix, not including the trailing slash: */
2383 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2386 * We are still at a leading dir of the refname (e.g.,
2387 * "refs/foo"; if there is a reference with that name,
2388 * it is a conflict, *unless* it is in skip.
2390 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2393 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2394 &type
, &ignore_errno
)) {
2395 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2396 dirname
.buf
, refname
);
2400 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2401 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2402 refname
, dirname
.buf
);
2408 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2409 * There is no point in searching for a reference with that
2410 * name, because a refname isn't considered to conflict with
2411 * itself. But we still need to check for references whose
2412 * names are in the "refs/foo/bar/" namespace, because they
2415 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2416 strbuf_addch(&dirname
, '/');
2418 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2419 DO_FOR_EACH_INCLUDE_BROKEN
);
2420 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2422 string_list_has_string(skip
, iter
->refname
))
2425 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2426 iter
->refname
, refname
);
2427 ref_iterator_abort(iter
);
2431 if (ok
!= ITER_DONE
)
2432 BUG("error while iterating over references");
2434 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2436 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2437 refname
, extra_refname
);
2442 strbuf_release(&referent
);
2443 strbuf_release(&dirname
);
2447 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2449 struct ref_iterator
*iter
;
2450 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2452 iter
= refs
->be
->reflog_iterator_begin(refs
);
2454 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2455 do_for_each_ref_helper
, &hp
);
2458 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2460 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2463 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2464 const char *refname
,
2465 each_reflog_ent_fn fn
,
2468 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2472 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2475 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2476 refname
, fn
, cb_data
);
2479 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2480 each_reflog_ent_fn fn
, void *cb_data
)
2482 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2485 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2488 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2492 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2494 return refs
->be
->reflog_exists(refs
, refname
);
2497 int reflog_exists(const char *refname
)
2499 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2502 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2505 return refs
->be
->create_reflog(refs
, refname
, err
);
2508 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2510 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2514 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2516 return refs
->be
->delete_reflog(refs
, refname
);
2519 int delete_reflog(const char *refname
)
2521 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2524 int refs_reflog_expire(struct ref_store
*refs
,
2525 const char *refname
,
2527 reflog_expiry_prepare_fn prepare_fn
,
2528 reflog_expiry_should_prune_fn should_prune_fn
,
2529 reflog_expiry_cleanup_fn cleanup_fn
,
2530 void *policy_cb_data
)
2532 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2533 prepare_fn
, should_prune_fn
,
2534 cleanup_fn
, policy_cb_data
);
2537 int reflog_expire(const char *refname
,
2539 reflog_expiry_prepare_fn prepare_fn
,
2540 reflog_expiry_should_prune_fn should_prune_fn
,
2541 reflog_expiry_cleanup_fn cleanup_fn
,
2542 void *policy_cb_data
)
2544 return refs_reflog_expire(get_main_ref_store(the_repository
),
2546 prepare_fn
, should_prune_fn
,
2547 cleanup_fn
, policy_cb_data
);
2550 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2553 struct ref_store
*refs
= transaction
->ref_store
;
2555 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2558 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2559 ref_transaction_for_each_queued_update_fn cb
,
2564 for (i
= 0; i
< transaction
->nr
; i
++) {
2565 struct ref_update
*update
= transaction
->updates
[i
];
2568 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2569 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2574 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2575 struct string_list
*refnames
, unsigned int flags
)
2580 msg
= normalize_reflog_message(logmsg
);
2581 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2586 int delete_refs(const char *msg
, struct string_list
*refnames
,
2589 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2592 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2593 const char *newref
, const char *logmsg
)
2598 msg
= normalize_reflog_message(logmsg
);
2599 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2604 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2606 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2609 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2610 const char *newref
, const char *logmsg
)
2615 msg
= normalize_reflog_message(logmsg
);
2616 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2621 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2623 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);