2 * The backend-independent part of the reference module.
5 #include "git-compat-util.h"
8 #include "environment.h"
15 #include "refs/refs-internal.h"
16 #include "run-command.h"
18 #include "object-name.h"
19 #include "object-store-ll.h"
23 #include "submodule.h"
26 #include "repository.h"
31 #include "wildmatch.h"
34 * List of all available backends
36 static const struct ref_storage_be
*refs_backends
[] = {
37 [REF_STORAGE_FORMAT_FILES
] = &refs_be_files
,
38 [REF_STORAGE_FORMAT_REFTABLE
] = &refs_be_reftable
,
41 static const struct ref_storage_be
*find_ref_storage_backend(unsigned int ref_storage_format
)
43 if (ref_storage_format
< ARRAY_SIZE(refs_backends
))
44 return refs_backends
[ref_storage_format
];
48 unsigned int ref_storage_format_by_name(const char *name
)
50 for (unsigned int i
= 0; i
< ARRAY_SIZE(refs_backends
); i
++)
51 if (refs_backends
[i
] && !strcmp(refs_backends
[i
]->name
, name
))
53 return REF_STORAGE_FORMAT_UNKNOWN
;
56 const char *ref_storage_format_to_name(unsigned int ref_storage_format
)
58 const struct ref_storage_be
*be
= find_ref_storage_backend(ref_storage_format
);
65 * How to handle various characters in refnames:
66 * 0: An acceptable character for refs
68 * 2: ., look for a preceding . to reject .. in refs
69 * 3: {, look for a preceding @ to reject @{ in refs
70 * 4: A bad character: ASCII control characters, and
71 * ":", "?", "[", "\", "^", "~", SP, or TAB
72 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
74 static unsigned char refname_disposition
[256] = {
75 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
82 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
85 struct ref_namespace_info ref_namespace
[] = {
88 .decoration
= DECORATION_REF_HEAD
,
91 [NAMESPACE_BRANCHES
] = {
93 .decoration
= DECORATION_REF_LOCAL
,
97 .decoration
= DECORATION_REF_TAG
,
99 [NAMESPACE_REMOTE_REFS
] = {
101 * The default refspec for new remotes copies refs from
102 * refs/heads/ on the remote into refs/remotes/<remote>/.
103 * As such, "refs/remotes/" has special handling.
105 .ref
= "refs/remotes/",
106 .decoration
= DECORATION_REF_REMOTE
,
108 [NAMESPACE_STASH
] = {
110 * The single ref "refs/stash" stores the latest stash.
111 * Older stashes can be found in the reflog.
115 .decoration
= DECORATION_REF_STASH
,
117 [NAMESPACE_REPLACE
] = {
119 * This namespace allows Git to act as if one object ID
120 * points to the content of another. Unlike the other
121 * ref namespaces, this one can be changed by the
122 * GIT_REPLACE_REF_BASE environment variable. This
123 * .namespace value will be overwritten in setup_git_env().
125 .ref
= "refs/replace/",
126 .decoration
= DECORATION_GRAFTED
,
128 [NAMESPACE_NOTES
] = {
130 * The refs/notes/commit ref points to the tip of a
131 * parallel commit history that adds metadata to commits
132 * in the normal history. This ref can be overwritten
133 * by the core.notesRef config variable or the
134 * GIT_NOTES_REFS environment variable.
136 .ref
= "refs/notes/commit",
139 [NAMESPACE_PREFETCH
] = {
141 * Prefetch refs are written by the background 'fetch'
142 * maintenance task. It allows faster foreground fetches
143 * by advertising these previously-downloaded tips without
144 * updating refs/remotes/ without user intervention.
146 .ref
= "refs/prefetch/",
148 [NAMESPACE_REWRITTEN
] = {
150 * Rewritten refs are used by the 'label' command in the
151 * sequencer. These are particularly useful during an
152 * interactive rebase that uses the 'merge' command.
154 .ref
= "refs/rewritten/",
158 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
160 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
161 if (info
->ref_updated
)
164 info
->ref_updated
= 1;
168 * Try to read one refname component from the front of refname.
169 * Return the length of the component found, or -1 if the component is
170 * not legal. It is legal if it is something reasonable to have under
171 * ".git/refs/"; We do not like it if:
173 * - it begins with ".", or
174 * - it has double dots "..", or
175 * - it has ASCII control characters, or
176 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
177 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
178 * - it ends with a "/", or
179 * - it ends with ".lock", or
180 * - it contains a "@{" portion
182 * When sanitized is not NULL, instead of rejecting the input refname
183 * as an error, try to come up with a usable replacement for the input
186 static int check_refname_component(const char *refname
, int *flags
,
187 struct strbuf
*sanitized
)
191 size_t component_start
= 0; /* garbage - not a reasonable initial value */
194 component_start
= sanitized
->len
;
196 for (cp
= refname
; ; cp
++) {
198 unsigned char disp
= refname_disposition
[ch
];
200 if (sanitized
&& disp
!= 1)
201 strbuf_addch(sanitized
, ch
);
207 if (last
== '.') { /* Refname contains "..". */
209 /* collapse ".." to single "." */
210 strbuf_setlen(sanitized
, sanitized
->len
- 1);
216 if (last
== '@') { /* Refname contains "@{". */
218 sanitized
->buf
[sanitized
->len
-1] = '-';
226 sanitized
->buf
[sanitized
->len
-1] = '-';
231 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
232 /* refspec can't be a pattern */
234 sanitized
->buf
[sanitized
->len
-1] = '-';
240 * Unset the pattern flag so that we only accept
241 * a single asterisk for one side of refspec.
243 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
250 return 0; /* Component has zero length. */
252 if (refname
[0] == '.') { /* Component starts with '.'. */
254 sanitized
->buf
[component_start
] = '-';
258 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
259 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
262 /* Refname ends with ".lock". */
263 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
264 /* try again in case we have .lock.lock */
270 static int check_or_sanitize_refname(const char *refname
, int flags
,
271 struct strbuf
*sanitized
)
273 int component_len
, component_count
= 0;
275 if (!strcmp(refname
, "@")) {
276 /* Refname is a single character '@'. */
278 strbuf_addch(sanitized
, '-');
284 if (sanitized
&& sanitized
->len
)
285 strbuf_complete(sanitized
, '/');
287 /* We are at the start of a path component. */
288 component_len
= check_refname_component(refname
, &flags
,
290 if (sanitized
&& component_len
== 0)
291 ; /* OK, omit empty component */
292 else if (component_len
<= 0)
296 if (refname
[component_len
] == '\0')
298 /* Skip to next component. */
299 refname
+= component_len
+ 1;
302 if (refname
[component_len
- 1] == '.') {
303 /* Refname ends with '.'. */
305 ; /* omit ending dot */
309 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
310 return -1; /* Refname has only one component. */
314 int check_refname_format(const char *refname
, int flags
)
316 return check_or_sanitize_refname(refname
, flags
, NULL
);
319 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
321 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
322 BUG("sanitizing refname '%s' check returned error", refname
);
325 int refname_is_safe(const char *refname
)
329 if (skip_prefix(refname
, "refs/", &rest
)) {
332 size_t restlen
= strlen(rest
);
334 /* rest must not be empty, or start or end with "/" */
335 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
339 * Does the refname try to escape refs/?
340 * For example: refs/foo/../bar is safe but refs/foo/../../bar
343 buf
= xmallocz(restlen
);
344 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
350 if (!isupper(*refname
) && *refname
!= '_')
358 * Return true if refname, which has the specified oid and flags, can
359 * be resolved to an object in the database. If the referred-to object
360 * does not exist, emit a warning and return false.
362 int ref_resolves_to_object(const char *refname
,
363 struct repository
*repo
,
364 const struct object_id
*oid
,
367 if (flags
& REF_ISBROKEN
)
369 if (!repo_has_object_file(repo
, oid
)) {
370 error(_("%s does not point to a valid object!"), refname
);
376 char *refs_resolve_refdup(struct ref_store
*refs
,
377 const char *refname
, int resolve_flags
,
378 struct object_id
*oid
, int *flags
)
382 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
384 return xstrdup_or_null(result
);
387 char *resolve_refdup(const char *refname
, int resolve_flags
,
388 struct object_id
*oid
, int *flags
)
390 return refs_resolve_refdup(get_main_ref_store(the_repository
),
391 refname
, resolve_flags
,
395 /* The argument to for_each_filter_refs */
396 struct for_each_ref_filter
{
403 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
405 struct ref_store
*refs
= get_main_ref_store(the_repository
);
407 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
413 int read_ref(const char *refname
, struct object_id
*oid
)
415 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
418 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
420 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
424 int ref_exists(const char *refname
)
426 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
429 static int for_each_filter_refs(const char *refname
,
430 const struct object_id
*oid
,
431 int flags
, void *data
)
433 struct for_each_ref_filter
*filter
= data
;
435 if (wildmatch(filter
->pattern
, refname
, 0))
438 skip_prefix(refname
, filter
->prefix
, &refname
);
439 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
442 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
444 struct object
*o
= lookup_unknown_object(the_repository
, name
);
446 if (o
->type
== OBJ_NONE
) {
447 int type
= oid_object_info(the_repository
, name
, NULL
);
448 if (type
< 0 || !object_as_type(o
, type
, 0))
452 if (o
->type
!= OBJ_TAG
)
455 o
= deref_tag_noverify(o
);
459 oidcpy(oid
, &o
->oid
);
463 struct warn_if_dangling_data
{
466 const struct string_list
*refnames
;
470 static int warn_if_dangling_symref(const char *refname
,
471 const struct object_id
*oid UNUSED
,
472 int flags
, void *cb_data
)
474 struct warn_if_dangling_data
*d
= cb_data
;
475 const char *resolves_to
;
477 if (!(flags
& REF_ISSYMREF
))
480 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
483 ? strcmp(resolves_to
, d
->refname
)
484 : !string_list_has_string(d
->refnames
, resolves_to
))) {
488 fprintf(d
->fp
, d
->msg_fmt
, refname
);
493 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
495 struct warn_if_dangling_data data
;
498 data
.refname
= refname
;
499 data
.refnames
= NULL
;
500 data
.msg_fmt
= msg_fmt
;
501 for_each_rawref(warn_if_dangling_symref
, &data
);
504 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
506 struct warn_if_dangling_data data
;
510 data
.refnames
= refnames
;
511 data
.msg_fmt
= msg_fmt
;
512 for_each_rawref(warn_if_dangling_symref
, &data
);
515 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
517 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
520 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
522 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
525 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
527 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
530 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
532 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
535 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
537 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
540 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
542 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
545 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
547 struct strbuf buf
= STRBUF_INIT
;
549 struct object_id oid
;
552 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
553 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
554 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
555 strbuf_release(&buf
);
560 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
563 struct strbuf normalized_pattern
= STRBUF_INIT
;
566 BUG("pattern must not start with '/'");
569 strbuf_addstr(&normalized_pattern
, prefix
);
570 else if (!starts_with(pattern
, "refs/") &&
571 strcmp(pattern
, "HEAD"))
572 strbuf_addstr(&normalized_pattern
, "refs/");
574 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
578 strbuf_addstr(&normalized_pattern
, pattern
);
579 strbuf_strip_suffix(&normalized_pattern
, "/");
581 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
582 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
583 strbuf_release(&normalized_pattern
);
586 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
587 const char *prefix
, void *cb_data
)
589 struct strbuf real_pattern
= STRBUF_INIT
;
590 struct for_each_ref_filter filter
;
593 if (!prefix
&& !starts_with(pattern
, "refs/"))
594 strbuf_addstr(&real_pattern
, "refs/");
596 strbuf_addstr(&real_pattern
, prefix
);
597 strbuf_addstr(&real_pattern
, pattern
);
599 if (!has_glob_specials(pattern
)) {
600 /* Append implied '/' '*' if not present. */
601 strbuf_complete(&real_pattern
, '/');
602 /* No need to check for '*', there is none. */
603 strbuf_addch(&real_pattern
, '*');
606 filter
.pattern
= real_pattern
.buf
;
607 filter
.prefix
= prefix
;
609 filter
.cb_data
= cb_data
;
610 ret
= for_each_ref(for_each_filter_refs
, &filter
);
612 strbuf_release(&real_pattern
);
616 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
618 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
621 const char *prettify_refname(const char *name
)
623 if (skip_prefix(name
, "refs/heads/", &name
) ||
624 skip_prefix(name
, "refs/tags/", &name
) ||
625 skip_prefix(name
, "refs/remotes/", &name
))
630 static const char *ref_rev_parse_rules
[] = {
636 "refs/remotes/%.*s/HEAD",
640 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
643 * Is it possible that the caller meant full_name with abbrev_name?
644 * If so return a non-zero value to signal "yes"; the magnitude of
645 * the returned value gives the precedence used for disambiguation.
647 * If abbrev_name cannot mean full_name, return 0.
649 int refname_match(const char *abbrev_name
, const char *full_name
)
652 const int abbrev_name_len
= strlen(abbrev_name
);
653 const int num_rules
= NUM_REV_PARSE_RULES
;
655 for (p
= ref_rev_parse_rules
; *p
; p
++)
656 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
657 return &ref_rev_parse_rules
[num_rules
] - p
;
663 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
664 * the results to 'prefixes'
666 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
669 int len
= strlen(prefix
);
671 for (p
= ref_rev_parse_rules
; *p
; p
++)
672 strvec_pushf(prefixes
, *p
, len
, prefix
);
675 static const char default_branch_name_advice
[] = N_(
676 "Using '%s' as the name for the initial branch. This default branch name\n"
677 "is subject to change. To configure the initial branch name to use in all\n"
678 "of your new repositories, which will suppress this warning, call:\n"
680 "\tgit config --global init.defaultBranch <name>\n"
682 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
683 "'development'. The just-created branch can be renamed via this command:\n"
685 "\tgit branch -m <name>\n"
688 char *repo_default_branch_name(struct repository
*r
, int quiet
)
690 const char *config_key
= "init.defaultbranch";
691 const char *config_display_key
= "init.defaultBranch";
692 char *ret
= NULL
, *full_ref
;
693 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
697 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
698 die(_("could not retrieve `%s`"), config_display_key
);
701 ret
= xstrdup("master");
703 advise(_(default_branch_name_advice
), ret
);
706 full_ref
= xstrfmt("refs/heads/%s", ret
);
707 if (check_refname_format(full_ref
, 0))
708 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
714 const char *git_default_branch_name(int quiet
)
719 ret
= repo_default_branch_name(the_repository
, quiet
);
725 * *string and *len will only be substituted, and *string returned (for
726 * later free()ing) if the string passed in is a magic short-hand form
729 static char *substitute_branch_name(struct repository
*r
,
730 const char **string
, int *len
,
731 int nonfatal_dangling_mark
)
733 struct strbuf buf
= STRBUF_INIT
;
734 struct interpret_branch_name_options options
= {
735 .nonfatal_dangling_mark
= nonfatal_dangling_mark
737 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
741 *string
= strbuf_detach(&buf
, &size
);
743 return (char *)*string
;
749 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
750 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
752 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
753 nonfatal_dangling_mark
);
754 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
759 int expand_ref(struct repository
*repo
, const char *str
, int len
,
760 struct object_id
*oid
, char **ref
)
764 struct strbuf fullref
= STRBUF_INIT
;
767 for (p
= ref_rev_parse_rules
; *p
; p
++) {
768 struct object_id oid_from_ref
;
769 struct object_id
*this_result
;
771 struct ref_store
*refs
= get_main_ref_store(repo
);
773 this_result
= refs_found
? &oid_from_ref
: oid
;
774 strbuf_reset(&fullref
);
775 strbuf_addf(&fullref
, *p
, len
, str
);
776 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
782 if (!warn_ambiguous_refs
)
784 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
785 warning(_("ignoring dangling symref %s"), fullref
.buf
);
786 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
787 warning(_("ignoring broken ref %s"), fullref
.buf
);
790 strbuf_release(&fullref
);
794 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
795 struct object_id
*oid
, char **log
)
797 struct ref_store
*refs
= get_main_ref_store(r
);
798 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
801 struct strbuf path
= STRBUF_INIT
;
804 for (p
= ref_rev_parse_rules
; *p
; p
++) {
805 struct object_id hash
;
806 const char *ref
, *it
;
809 strbuf_addf(&path
, *p
, len
, str
);
810 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
812 oid
? &hash
: NULL
, NULL
);
815 if (refs_reflog_exists(refs
, path
.buf
))
817 else if (strcmp(ref
, path
.buf
) &&
818 refs_reflog_exists(refs
, ref
))
827 if (!warn_ambiguous_refs
)
830 strbuf_release(&path
);
835 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
837 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
840 int is_per_worktree_ref(const char *refname
)
842 return starts_with(refname
, "refs/worktree/") ||
843 starts_with(refname
, "refs/bisect/") ||
844 starts_with(refname
, "refs/rewritten/");
847 static int is_pseudoref_syntax(const char *refname
)
851 for (c
= refname
; *c
; c
++) {
852 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
857 * HEAD is not a pseudoref, but it certainly uses the
863 int is_pseudoref(struct ref_store
*refs
, const char *refname
)
865 static const char *const irregular_pseudorefs
[] = {
867 "BISECT_EXPECTED_REV",
868 "NOTES_MERGE_PARTIAL",
872 struct object_id oid
;
875 if (!is_pseudoref_syntax(refname
))
878 if (ends_with(refname
, "_HEAD")) {
879 refs_resolve_ref_unsafe(refs
, refname
,
880 RESOLVE_REF_READING
| RESOLVE_REF_NO_RECURSE
,
882 return !is_null_oid(&oid
);
885 for (i
= 0; i
< ARRAY_SIZE(irregular_pseudorefs
); i
++)
886 if (!strcmp(refname
, irregular_pseudorefs
[i
])) {
887 refs_resolve_ref_unsafe(refs
, refname
,
888 RESOLVE_REF_READING
| RESOLVE_REF_NO_RECURSE
,
890 return !is_null_oid(&oid
);
896 int is_headref(struct ref_store
*refs
, const char *refname
)
898 if (!strcmp(refname
, "HEAD"))
899 return refs_ref_exists(refs
, refname
);
904 static int is_current_worktree_ref(const char *ref
) {
905 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
908 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
909 const char **worktree_name
, int *worktree_name_length
,
910 const char **bare_refname
)
912 const char *name_dummy
;
913 int name_length_dummy
;
914 const char *ref_dummy
;
917 worktree_name
= &name_dummy
;
918 if (!worktree_name_length
)
919 worktree_name_length
= &name_length_dummy
;
921 bare_refname
= &ref_dummy
;
923 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
924 const char *slash
= strchr(*bare_refname
, '/');
926 *worktree_name
= *bare_refname
;
928 *worktree_name_length
= strlen(*worktree_name
);
930 /* This is an error condition, and the caller tell because the bare_refname is "" */
931 *bare_refname
= *worktree_name
+ *worktree_name_length
;
932 return REF_WORKTREE_OTHER
;
935 *worktree_name_length
= slash
- *bare_refname
;
936 *bare_refname
= slash
+ 1;
938 if (is_current_worktree_ref(*bare_refname
))
939 return REF_WORKTREE_OTHER
;
942 *worktree_name
= NULL
;
943 *worktree_name_length
= 0;
945 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
946 && is_current_worktree_ref(*bare_refname
))
947 return REF_WORKTREE_MAIN
;
949 *bare_refname
= maybe_worktree_ref
;
950 if (is_current_worktree_ref(maybe_worktree_ref
))
951 return REF_WORKTREE_CURRENT
;
953 return REF_WORKTREE_SHARED
;
956 long get_files_ref_lock_timeout_ms(void)
958 static int configured
= 0;
960 /* The default timeout is 100 ms: */
961 static int timeout_ms
= 100;
964 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
971 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
973 const struct object_id
*old_oid
,
976 struct ref_transaction
*transaction
;
977 struct strbuf err
= STRBUF_INIT
;
979 transaction
= ref_store_transaction_begin(refs
, &err
);
981 ref_transaction_delete(transaction
, refname
, old_oid
,
983 ref_transaction_commit(transaction
, &err
)) {
984 error("%s", err
.buf
);
985 ref_transaction_free(transaction
);
986 strbuf_release(&err
);
989 ref_transaction_free(transaction
);
990 strbuf_release(&err
);
994 int delete_ref(const char *msg
, const char *refname
,
995 const struct object_id
*old_oid
, unsigned int flags
)
997 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
1001 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
1006 while ((c
= *msg
++)) {
1007 if (wasspace
&& isspace(c
))
1009 wasspace
= isspace(c
);
1012 strbuf_addch(sb
, c
);
1017 static char *normalize_reflog_message(const char *msg
)
1019 struct strbuf sb
= STRBUF_INIT
;
1022 copy_reflog_msg(&sb
, msg
);
1023 return strbuf_detach(&sb
, NULL
);
1026 int should_autocreate_reflog(const char *refname
)
1028 switch (log_all_ref_updates
) {
1029 case LOG_REFS_ALWAYS
:
1031 case LOG_REFS_NORMAL
:
1032 return starts_with(refname
, "refs/heads/") ||
1033 starts_with(refname
, "refs/remotes/") ||
1034 starts_with(refname
, "refs/notes/") ||
1035 !strcmp(refname
, "HEAD");
1041 int is_branch(const char *refname
)
1043 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
1046 struct read_ref_at_cb
{
1047 const char *refname
;
1048 timestamp_t at_time
;
1051 struct object_id
*oid
;
1054 struct object_id ooid
;
1055 struct object_id noid
;
1059 timestamp_t
*cutoff_time
;
1064 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
1065 timestamp_t timestamp
, int tz
, const char *message
)
1068 *cb
->msg
= xstrdup(message
);
1069 if (cb
->cutoff_time
)
1070 *cb
->cutoff_time
= timestamp
;
1072 *cb
->cutoff_tz
= tz
;
1074 *cb
->cutoff_cnt
= cb
->reccnt
;
1077 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1078 const char *email UNUSED
,
1079 timestamp_t timestamp
, int tz
,
1080 const char *message
, void *cb_data
)
1082 struct read_ref_at_cb
*cb
= cb_data
;
1085 cb
->date
= timestamp
;
1087 if (timestamp
<= cb
->at_time
|| cb
->cnt
== 0) {
1088 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1090 * we have not yet updated cb->[n|o]oid so they still
1091 * hold the values for the previous record.
1093 if (!is_null_oid(&cb
->ooid
)) {
1094 oidcpy(cb
->oid
, noid
);
1095 if (!oideq(&cb
->ooid
, noid
))
1096 warning(_("log for ref %s has gap after %s"),
1097 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1099 else if (cb
->date
== cb
->at_time
)
1100 oidcpy(cb
->oid
, noid
);
1101 else if (!oideq(noid
, cb
->oid
))
1102 warning(_("log for ref %s unexpectedly ended on %s"),
1103 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1104 DATE_MODE(RFC2822
)));
1106 oidcpy(&cb
->ooid
, ooid
);
1107 oidcpy(&cb
->noid
, noid
);
1112 oidcpy(&cb
->ooid
, ooid
);
1113 oidcpy(&cb
->noid
, noid
);
1119 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1120 const char *email UNUSED
,
1121 timestamp_t timestamp
, int tz
,
1122 const char *message
, void *cb_data
)
1124 struct read_ref_at_cb
*cb
= cb_data
;
1126 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1127 oidcpy(cb
->oid
, ooid
);
1128 if (cb
->at_time
&& is_null_oid(cb
->oid
))
1129 oidcpy(cb
->oid
, noid
);
1130 /* We just want the first entry */
1134 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1135 unsigned int flags
, timestamp_t at_time
, int cnt
,
1136 struct object_id
*oid
, char **msg
,
1137 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1139 struct read_ref_at_cb cb
;
1141 memset(&cb
, 0, sizeof(cb
));
1142 cb
.refname
= refname
;
1143 cb
.at_time
= at_time
;
1146 cb
.cutoff_time
= cutoff_time
;
1147 cb
.cutoff_tz
= cutoff_tz
;
1148 cb
.cutoff_cnt
= cutoff_cnt
;
1151 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1156 * The caller asked for ref@{0}, and we had no entries.
1157 * It's a bit subtle, but in practice all callers have
1158 * prepped the "oid" field with the current value of
1159 * the ref, which is the most reasonable fallback.
1161 * We'll put dummy values into the out-parameters (so
1162 * they're not just uninitialized garbage), and the
1163 * caller can take our return value as a hint that
1164 * we did not find any such reflog.
1166 set_read_ref_cutoffs(&cb
, 0, 0, "empty reflog");
1169 if (flags
& GET_OID_QUIETLY
)
1172 die(_("log for %s is empty"), refname
);
1177 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1182 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1185 struct ref_transaction
*tr
;
1188 CALLOC_ARRAY(tr
, 1);
1189 tr
->ref_store
= refs
;
1193 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1195 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1198 void ref_transaction_free(struct ref_transaction
*transaction
)
1205 switch (transaction
->state
) {
1206 case REF_TRANSACTION_OPEN
:
1207 case REF_TRANSACTION_CLOSED
:
1210 case REF_TRANSACTION_PREPARED
:
1211 BUG("free called on a prepared reference transaction");
1214 BUG("unexpected reference transaction state");
1218 for (i
= 0; i
< transaction
->nr
; i
++) {
1219 free(transaction
->updates
[i
]->msg
);
1220 free(transaction
->updates
[i
]);
1222 free(transaction
->updates
);
1226 struct ref_update
*ref_transaction_add_update(
1227 struct ref_transaction
*transaction
,
1228 const char *refname
, unsigned int flags
,
1229 const struct object_id
*new_oid
,
1230 const struct object_id
*old_oid
,
1231 const char *new_target
, const char *old_target
,
1234 struct ref_update
*update
;
1236 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1237 BUG("update called for transaction that is not open");
1239 if (old_oid
&& old_target
)
1240 BUG("only one of old_oid and old_target should be non NULL");
1241 if (new_oid
&& new_target
)
1242 BUG("only one of new_oid and new_target should be non NULL");
1244 FLEX_ALLOC_STR(update
, refname
, refname
);
1245 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1246 transaction
->updates
[transaction
->nr
++] = update
;
1248 update
->flags
= flags
;
1250 if (flags
& REF_HAVE_NEW
)
1251 oidcpy(&update
->new_oid
, new_oid
);
1252 if (flags
& REF_HAVE_OLD
)
1253 oidcpy(&update
->old_oid
, old_oid
);
1254 update
->msg
= normalize_reflog_message(msg
);
1258 int ref_transaction_update(struct ref_transaction
*transaction
,
1259 const char *refname
,
1260 const struct object_id
*new_oid
,
1261 const struct object_id
*old_oid
,
1262 const char *new_target
,
1263 const char *old_target
,
1264 unsigned int flags
, const char *msg
,
1269 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1270 ((new_oid
&& !is_null_oid(new_oid
)) ?
1271 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1272 !refname_is_safe(refname
))) {
1273 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1278 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1279 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1282 * Clear flags outside the allowed set; this should be a noop because
1283 * of the BUG() check above, but it works around a -Wnonnull warning
1284 * with some versions of "gcc -O3".
1286 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1288 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1290 ref_transaction_add_update(transaction
, refname
, flags
,
1291 new_oid
, old_oid
, new_target
,
1296 int ref_transaction_create(struct ref_transaction
*transaction
,
1297 const char *refname
,
1298 const struct object_id
*new_oid
,
1299 unsigned int flags
, const char *msg
,
1302 if (!new_oid
|| is_null_oid(new_oid
)) {
1303 strbuf_addf(err
, "'%s' has a null OID", refname
);
1306 return ref_transaction_update(transaction
, refname
, new_oid
,
1307 null_oid(), NULL
, NULL
, flags
,
1311 int ref_transaction_delete(struct ref_transaction
*transaction
,
1312 const char *refname
,
1313 const struct object_id
*old_oid
,
1314 unsigned int flags
, const char *msg
,
1317 if (old_oid
&& is_null_oid(old_oid
))
1318 BUG("delete called with old_oid set to zeros");
1319 return ref_transaction_update(transaction
, refname
,
1320 null_oid(), old_oid
,
1325 int ref_transaction_verify(struct ref_transaction
*transaction
,
1326 const char *refname
,
1327 const struct object_id
*old_oid
,
1332 BUG("verify called with old_oid set to NULL");
1333 return ref_transaction_update(transaction
, refname
,
1339 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1340 const char *refname
, const struct object_id
*new_oid
,
1341 const struct object_id
*old_oid
, unsigned int flags
,
1342 enum action_on_err onerr
)
1344 struct ref_transaction
*t
= NULL
;
1345 struct strbuf err
= STRBUF_INIT
;
1348 t
= ref_store_transaction_begin(refs
, &err
);
1350 ref_transaction_update(t
, refname
, new_oid
, old_oid
, NULL
, NULL
,
1351 flags
, msg
, &err
) ||
1352 ref_transaction_commit(t
, &err
)) {
1354 ref_transaction_free(t
);
1357 const char *str
= _("update_ref failed for ref '%s': %s");
1360 case UPDATE_REFS_MSG_ON_ERR
:
1361 error(str
, refname
, err
.buf
);
1363 case UPDATE_REFS_DIE_ON_ERR
:
1364 die(str
, refname
, err
.buf
);
1366 case UPDATE_REFS_QUIET_ON_ERR
:
1369 strbuf_release(&err
);
1372 strbuf_release(&err
);
1374 ref_transaction_free(t
);
1378 int update_ref(const char *msg
, const char *refname
,
1379 const struct object_id
*new_oid
,
1380 const struct object_id
*old_oid
,
1381 unsigned int flags
, enum action_on_err onerr
)
1383 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1384 old_oid
, flags
, onerr
);
1388 * Check that the string refname matches a rule of the form
1389 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1390 * "foo/%.*s/baz", and return the string "bar".
1392 static const char *match_parse_rule(const char *refname
, const char *rule
,
1396 * Check that rule matches refname up to the first percent in the rule.
1397 * We can bail immediately if not, but otherwise we leave "rule" at the
1398 * %-placeholder, and "refname" at the start of the potential matched
1401 while (*rule
!= '%') {
1403 BUG("rev-parse rule did not have percent");
1404 if (*refname
++ != *rule
++)
1409 * Check that our "%" is the expected placeholder. This assumes there
1410 * are no other percents (placeholder or quoted) in the string, but
1411 * that is sufficient for our rev-parse rules.
1413 if (!skip_prefix(rule
, "%.*s", &rule
))
1417 * And now check that our suffix (if any) matches.
1419 if (!strip_suffix(refname
, rule
, len
))
1422 return refname
; /* len set by strip_suffix() */
1425 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1426 const char *refname
, int strict
)
1429 struct strbuf resolved_buf
= STRBUF_INIT
;
1431 /* skip first rule, it will always match */
1432 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1434 int rules_to_fail
= i
;
1435 const char *short_name
;
1436 size_t short_name_len
;
1438 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1444 * in strict mode, all (except the matched one) rules
1445 * must fail to resolve to a valid non-ambiguous ref
1448 rules_to_fail
= NUM_REV_PARSE_RULES
;
1451 * check if the short name resolves to a valid ref,
1452 * but use only rules prior to the matched one
1454 for (j
= 0; j
< rules_to_fail
; j
++) {
1455 const char *rule
= ref_rev_parse_rules
[j
];
1457 /* skip matched rule */
1462 * the short name is ambiguous, if it resolves
1463 * (with this previous rule) to a valid ref
1464 * read_ref() returns 0 on success
1466 strbuf_reset(&resolved_buf
);
1467 strbuf_addf(&resolved_buf
, rule
,
1468 cast_size_t_to_int(short_name_len
),
1470 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1475 * short name is non-ambiguous if all previous rules
1476 * haven't resolved to a valid ref
1478 if (j
== rules_to_fail
) {
1479 strbuf_release(&resolved_buf
);
1480 return xmemdupz(short_name
, short_name_len
);
1484 strbuf_release(&resolved_buf
);
1485 return xstrdup(refname
);
1488 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1490 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1494 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1495 struct strvec
*hide_refs
)
1498 if (!strcmp("transfer.hiderefs", var
) ||
1499 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1500 !strcmp(key
, "hiderefs"))) {
1505 return config_error_nonbool(var
);
1507 /* drop const to remove trailing '/' characters */
1508 ref
= (char *)strvec_push(hide_refs
, value
);
1510 while (len
&& ref
[len
- 1] == '/')
1516 int ref_is_hidden(const char *refname
, const char *refname_full
,
1517 const struct strvec
*hide_refs
)
1521 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1522 const char *match
= hide_refs
->v
[i
];
1523 const char *subject
;
1527 if (*match
== '!') {
1532 if (*match
== '^') {
1533 subject
= refname_full
;
1539 /* refname can be NULL when namespaces are used. */
1541 skip_prefix(subject
, match
, &p
) &&
1548 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1550 const char **pattern
;
1551 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1553 * We can't feed any excludes from hidden refs config
1554 * sections, since later rules may override previous
1555 * ones. For example, with rules "refs/foo" and
1556 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1557 * everything underneath it), but the earlier exclusion
1558 * would cause us to skip all of "refs/foo". We
1559 * likewise don't implement the namespace stripping
1560 * required for '^' rules.
1562 * Both are possible to do, but complicated, so avoid
1563 * populating the jump list at all if we see either of
1566 if (**pattern
== '!' || **pattern
== '^')
1569 return hide_refs
->v
;
1572 const char *find_descendant_ref(const char *dirname
,
1573 const struct string_list
*extras
,
1574 const struct string_list
*skip
)
1582 * Look at the place where dirname would be inserted into
1583 * extras. If there is an entry at that position that starts
1584 * with dirname (remember, dirname includes the trailing
1585 * slash) and is not in skip, then we have a conflict.
1587 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1588 pos
< extras
->nr
; pos
++) {
1589 const char *extra_refname
= extras
->items
[pos
].string
;
1591 if (!starts_with(extra_refname
, dirname
))
1594 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1595 return extra_refname
;
1600 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1602 struct object_id oid
;
1605 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1607 return fn("HEAD", &oid
, flag
, cb_data
);
1612 int head_ref(each_ref_fn fn
, void *cb_data
)
1614 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1617 struct ref_iterator
*refs_ref_iterator_begin(
1618 struct ref_store
*refs
,
1620 const char **exclude_patterns
,
1622 enum do_for_each_ref_flags flags
)
1624 struct ref_iterator
*iter
;
1626 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1627 static int ref_paranoia
= -1;
1629 if (ref_paranoia
< 0)
1630 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1632 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1633 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1637 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1639 * `iterator_begin()` already takes care of prefix, but we
1640 * might need to do some trimming:
1643 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1649 * Call fn for each reference in the specified submodule for which the
1650 * refname begins with prefix. If trim is non-zero, then trim that
1651 * many characters off the beginning of each refname before passing
1652 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1653 * include broken references in the iteration. If fn ever returns a
1654 * non-zero value, stop the iteration and return that value;
1655 * otherwise, return 0.
1657 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1658 each_repo_ref_fn fn
, int trim
, int flags
,
1661 struct ref_iterator
*iter
;
1662 struct ref_store
*refs
= get_main_ref_store(r
);
1667 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1669 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1672 struct do_for_each_ref_help
{
1677 static int do_for_each_ref_helper(struct repository
*r UNUSED
,
1678 const char *refname
,
1679 const struct object_id
*oid
,
1683 struct do_for_each_ref_help
*hp
= cb_data
;
1685 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1688 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1689 const char **exclude_patterns
,
1690 each_ref_fn fn
, int trim
,
1691 enum do_for_each_ref_flags flags
, void *cb_data
)
1693 struct ref_iterator
*iter
;
1694 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1699 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1702 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1703 do_for_each_ref_helper
, &hp
);
1706 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1708 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1711 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1713 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1716 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1717 each_ref_fn fn
, void *cb_data
)
1719 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1722 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1724 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1727 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1729 return do_for_each_ref(get_main_ref_store(the_repository
),
1730 prefix
, NULL
, fn
, 0, 0, cb_data
);
1733 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1734 const char **exclude_patterns
,
1735 each_ref_fn fn
, void *cb_data
)
1737 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1740 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1742 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1743 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1744 strlen(git_replace_ref_base
),
1745 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1748 int for_each_namespaced_ref(const char **exclude_patterns
,
1749 each_ref_fn fn
, void *cb_data
)
1751 struct strbuf buf
= STRBUF_INIT
;
1753 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1754 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1755 buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1756 strbuf_release(&buf
);
1760 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1762 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1763 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1766 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1768 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1771 int refs_for_each_include_root_refs(struct ref_store
*refs
, each_ref_fn fn
,
1774 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1775 DO_FOR_EACH_INCLUDE_ROOT_REFS
, cb_data
);
1778 static int qsort_strcmp(const void *va
, const void *vb
)
1780 const char *a
= *(const char **)va
;
1781 const char *b
= *(const char **)vb
;
1783 return strcmp(a
, b
);
1786 static void find_longest_prefixes_1(struct string_list
*out
,
1787 struct strbuf
*prefix
,
1788 const char **patterns
, size_t nr
)
1792 for (i
= 0; i
< nr
; i
++) {
1793 char c
= patterns
[i
][prefix
->len
];
1794 if (!c
|| is_glob_special(c
)) {
1795 string_list_append(out
, prefix
->buf
);
1805 * Set "end" to the index of the element _after_ the last one
1808 for (end
= i
+ 1; end
< nr
; end
++) {
1809 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1813 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1814 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1815 strbuf_setlen(prefix
, prefix
->len
- 1);
1821 static void find_longest_prefixes(struct string_list
*out
,
1822 const char **patterns
)
1824 struct strvec sorted
= STRVEC_INIT
;
1825 struct strbuf prefix
= STRBUF_INIT
;
1827 strvec_pushv(&sorted
, patterns
);
1828 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1830 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1832 strvec_clear(&sorted
);
1833 strbuf_release(&prefix
);
1836 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1837 const char *namespace,
1838 const char **patterns
,
1839 const char **exclude_patterns
,
1840 each_ref_fn fn
, void *cb_data
)
1842 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1843 struct string_list_item
*prefix
;
1844 struct strbuf buf
= STRBUF_INIT
;
1845 int ret
= 0, namespace_len
;
1847 find_longest_prefixes(&prefixes
, patterns
);
1850 strbuf_addstr(&buf
, namespace);
1851 namespace_len
= buf
.len
;
1853 for_each_string_list_item(prefix
, &prefixes
) {
1854 strbuf_addstr(&buf
, prefix
->string
);
1855 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1856 exclude_patterns
, fn
, cb_data
);
1859 strbuf_setlen(&buf
, namespace_len
);
1862 string_list_clear(&prefixes
, 0);
1863 strbuf_release(&buf
);
1867 static int refs_read_special_head(struct ref_store
*ref_store
,
1868 const char *refname
, struct object_id
*oid
,
1869 struct strbuf
*referent
, unsigned int *type
,
1872 struct strbuf full_path
= STRBUF_INIT
;
1873 struct strbuf content
= STRBUF_INIT
;
1875 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1877 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1878 *failure_errno
= errno
;
1882 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1886 strbuf_release(&full_path
);
1887 strbuf_release(&content
);
1891 static int is_special_ref(const char *refname
)
1894 * Special references are refs that have different semantics compared
1895 * to "normal" refs. These refs can thus not be stored in the ref
1896 * backend, but must always be accessed via the filesystem. The
1897 * following refs are special:
1899 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1900 * carries additional metadata like where it came from.
1902 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1905 * Reading, writing or deleting references must consistently go either
1906 * through the filesystem (special refs) or through the reference
1907 * backend (normal ones).
1909 static const char * const special_refs
[] = {
1915 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1916 if (!strcmp(refname
, special_refs
[i
]))
1922 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1923 struct object_id
*oid
, struct strbuf
*referent
,
1924 unsigned int *type
, int *failure_errno
)
1926 assert(failure_errno
);
1927 if (is_special_ref(refname
))
1928 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1929 type
, failure_errno
);
1931 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1932 type
, failure_errno
);
1935 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1936 struct strbuf
*referent
)
1938 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1941 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1942 const char *refname
,
1944 struct object_id
*oid
,
1947 static struct strbuf sb_refname
= STRBUF_INIT
;
1948 struct object_id unused_oid
;
1955 flags
= &unused_flags
;
1959 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1960 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1961 !refname_is_safe(refname
))
1965 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1966 * missing refs and refs that were present but invalid,
1967 * to complain about the latter to stderr.
1969 * We don't know whether the ref exists, so don't set
1972 *flags
|= REF_BAD_NAME
;
1975 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1976 unsigned int read_flags
= 0;
1979 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1980 &read_flags
, &failure_errno
)) {
1981 *flags
|= read_flags
;
1983 /* In reading mode, refs must eventually resolve */
1984 if (resolve_flags
& RESOLVE_REF_READING
)
1988 * Otherwise a missing ref is OK. But the files backend
1989 * may show errors besides ENOENT if there are
1990 * similarly-named refs.
1992 if (failure_errno
!= ENOENT
&&
1993 failure_errno
!= EISDIR
&&
1994 failure_errno
!= ENOTDIR
)
1998 if (*flags
& REF_BAD_NAME
)
1999 *flags
|= REF_ISBROKEN
;
2003 *flags
|= read_flags
;
2005 if (!(read_flags
& REF_ISSYMREF
)) {
2006 if (*flags
& REF_BAD_NAME
) {
2008 *flags
|= REF_ISBROKEN
;
2013 refname
= sb_refname
.buf
;
2014 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
2018 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
2019 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
2020 !refname_is_safe(refname
))
2023 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
2030 /* backend functions */
2031 int refs_init_db(struct ref_store
*refs
, int flags
, struct strbuf
*err
)
2033 return refs
->be
->init_db(refs
, flags
, err
);
2036 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
2037 struct object_id
*oid
, int *flags
)
2039 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
2040 resolve_flags
, oid
, flags
);
2043 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
2044 struct object_id
*oid
)
2046 struct ref_store
*refs
;
2049 refs
= get_submodule_ref_store(submodule
);
2054 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
2060 struct ref_store_hash_entry
2062 struct hashmap_entry ent
;
2064 struct ref_store
*refs
;
2066 /* NUL-terminated identifier of the ref store: */
2067 char name
[FLEX_ARRAY
];
2070 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
2071 const struct hashmap_entry
*eptr
,
2072 const struct hashmap_entry
*entry_or_key
,
2073 const void *keydata
)
2075 const struct ref_store_hash_entry
*e1
, *e2
;
2078 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2079 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2080 name
= keydata
? keydata
: e2
->name
;
2082 return strcmp(e1
->name
, name
);
2085 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2086 const char *name
, struct ref_store
*refs
)
2088 struct ref_store_hash_entry
*entry
;
2090 FLEX_ALLOC_STR(entry
, name
, name
);
2091 hashmap_entry_init(&entry
->ent
, strhash(name
));
2096 /* A hashmap of ref_stores, stored by submodule name: */
2097 static struct hashmap submodule_ref_stores
;
2099 /* A hashmap of ref_stores, stored by worktree id: */
2100 static struct hashmap worktree_ref_stores
;
2103 * Look up a ref store by name. If that ref_store hasn't been
2104 * registered yet, return NULL.
2106 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2109 struct ref_store_hash_entry
*entry
;
2112 if (!map
->tablesize
)
2113 /* It's initialized on demand in register_ref_store(). */
2116 hash
= strhash(name
);
2117 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2118 struct ref_store_hash_entry
, ent
);
2119 return entry
? entry
->refs
: NULL
;
2123 * Create, record, and return a ref_store instance for the specified
2126 static struct ref_store
*ref_store_init(struct repository
*repo
,
2130 const struct ref_storage_be
*be
;
2131 struct ref_store
*refs
;
2133 be
= find_ref_storage_backend(repo
->ref_storage_format
);
2135 BUG("reference backend is unknown");
2137 refs
= be
->init(repo
, gitdir
, flags
);
2141 struct ref_store
*get_main_ref_store(struct repository
*r
)
2143 if (r
->refs_private
)
2144 return r
->refs_private
;
2147 BUG("attempting to get main_ref_store outside of repository");
2149 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2150 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2151 return r
->refs_private
;
2155 * Associate a ref store with a name. It is a fatal error to call this
2156 * function twice for the same name.
2158 static void register_ref_store_map(struct hashmap
*map
,
2160 struct ref_store
*refs
,
2163 struct ref_store_hash_entry
*entry
;
2165 if (!map
->tablesize
)
2166 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2168 entry
= alloc_ref_store_hash_entry(name
, refs
);
2169 if (hashmap_put(map
, &entry
->ent
))
2170 BUG("%s ref_store '%s' initialized twice", type
, name
);
2173 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2175 struct strbuf submodule_sb
= STRBUF_INIT
;
2176 struct ref_store
*refs
;
2177 char *to_free
= NULL
;
2179 struct repository
*subrepo
;
2184 len
= strlen(submodule
);
2185 while (len
&& is_dir_sep(submodule
[len
- 1]))
2191 /* We need to strip off one or more trailing slashes */
2192 submodule
= to_free
= xmemdupz(submodule
, len
);
2194 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2198 strbuf_addstr(&submodule_sb
, submodule
);
2199 if (!is_nonbare_repository_dir(&submodule_sb
))
2202 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2205 subrepo
= xmalloc(sizeof(*subrepo
));
2207 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2208 * superprojects other than the_repository. This probably should be
2209 * done by making it take a struct repository * parameter instead of a
2212 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2217 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2218 REF_STORE_READ
| REF_STORE_ODB
);
2219 register_ref_store_map(&submodule_ref_stores
, "submodule",
2223 strbuf_release(&submodule_sb
);
2229 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2231 struct ref_store
*refs
;
2235 return get_main_ref_store(the_repository
);
2237 id
= wt
->id
? wt
->id
: "/";
2238 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2243 refs
= ref_store_init(the_repository
,
2244 git_common_path("worktrees/%s", wt
->id
),
2245 REF_STORE_ALL_CAPS
);
2247 refs
= ref_store_init(the_repository
,
2248 get_git_common_dir(),
2249 REF_STORE_ALL_CAPS
);
2252 register_ref_store_map(&worktree_ref_stores
, "worktree",
2257 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2258 const char *path
, const struct ref_storage_be
*be
)
2262 refs
->gitdir
= xstrdup(path
);
2265 /* backend functions */
2266 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2268 return refs
->be
->pack_refs(refs
, opts
);
2271 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2273 if (current_ref_iter
&&
2274 (current_ref_iter
->oid
== base
||
2275 oideq(current_ref_iter
->oid
, base
)))
2276 return ref_iterator_peel(current_ref_iter
, peeled
);
2278 return peel_object(base
, peeled
) ? -1 : 0;
2281 int refs_create_symref(struct ref_store
*refs
,
2282 const char *ref_target
,
2283 const char *refs_heads_master
,
2289 msg
= normalize_reflog_message(logmsg
);
2290 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2296 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2299 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2300 refs_heads_master
, logmsg
);
2303 int ref_update_reject_duplicates(struct string_list
*refnames
,
2306 size_t i
, n
= refnames
->nr
;
2310 for (i
= 1; i
< n
; i
++) {
2311 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2312 refnames
->items
[i
].string
);
2316 _("multiple updates for ref '%s' not allowed"),
2317 refnames
->items
[i
].string
);
2319 } else if (cmp
> 0) {
2320 BUG("ref_update_reject_duplicates() received unsorted list");
2326 static int run_transaction_hook(struct ref_transaction
*transaction
,
2329 struct child_process proc
= CHILD_PROCESS_INIT
;
2330 struct strbuf buf
= STRBUF_INIT
;
2334 hook
= find_hook("reference-transaction");
2338 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2340 proc
.stdout_to_stderr
= 1;
2341 proc
.trace2_hook_name
= "reference-transaction";
2343 ret
= start_command(&proc
);
2347 sigchain_push(SIGPIPE
, SIG_IGN
);
2349 for (i
= 0; i
< transaction
->nr
; i
++) {
2350 struct ref_update
*update
= transaction
->updates
[i
];
2354 if (!(update
->flags
& REF_HAVE_OLD
))
2355 strbuf_addf(&buf
, "%s ", oid_to_hex(null_oid()));
2356 else if (update
->old_target
)
2357 strbuf_addf(&buf
, "ref:%s ", update
->old_target
);
2359 strbuf_addf(&buf
, "%s ", oid_to_hex(&update
->old_oid
));
2361 if (!(update
->flags
& REF_HAVE_NEW
))
2362 strbuf_addf(&buf
, "%s ", oid_to_hex(null_oid()));
2363 else if (update
->new_target
)
2364 strbuf_addf(&buf
, "ref:%s ", update
->new_target
);
2366 strbuf_addf(&buf
, "%s ", oid_to_hex(&update
->new_oid
));
2368 strbuf_addf(&buf
, "%s\n", update
->refname
);
2370 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2371 if (errno
!= EPIPE
) {
2372 /* Don't leak errno outside this API */
2381 sigchain_pop(SIGPIPE
);
2382 strbuf_release(&buf
);
2384 ret
|= finish_command(&proc
);
2388 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2391 struct ref_store
*refs
= transaction
->ref_store
;
2394 switch (transaction
->state
) {
2395 case REF_TRANSACTION_OPEN
:
2398 case REF_TRANSACTION_PREPARED
:
2399 BUG("prepare called twice on reference transaction");
2401 case REF_TRANSACTION_CLOSED
:
2402 BUG("prepare called on a closed reference transaction");
2405 BUG("unexpected reference transaction state");
2409 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2411 _("ref updates forbidden inside quarantine environment"));
2415 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2419 ret
= run_transaction_hook(transaction
, "prepared");
2421 ref_transaction_abort(transaction
, err
);
2422 die(_("ref updates aborted by hook"));
2428 int ref_transaction_abort(struct ref_transaction
*transaction
,
2431 struct ref_store
*refs
= transaction
->ref_store
;
2434 switch (transaction
->state
) {
2435 case REF_TRANSACTION_OPEN
:
2436 /* No need to abort explicitly. */
2438 case REF_TRANSACTION_PREPARED
:
2439 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2441 case REF_TRANSACTION_CLOSED
:
2442 BUG("abort called on a closed reference transaction");
2445 BUG("unexpected reference transaction state");
2449 run_transaction_hook(transaction
, "aborted");
2451 ref_transaction_free(transaction
);
2455 int ref_transaction_commit(struct ref_transaction
*transaction
,
2458 struct ref_store
*refs
= transaction
->ref_store
;
2461 switch (transaction
->state
) {
2462 case REF_TRANSACTION_OPEN
:
2463 /* Need to prepare first. */
2464 ret
= ref_transaction_prepare(transaction
, err
);
2468 case REF_TRANSACTION_PREPARED
:
2469 /* Fall through to finish. */
2471 case REF_TRANSACTION_CLOSED
:
2472 BUG("commit called on a closed reference transaction");
2475 BUG("unexpected reference transaction state");
2479 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2481 run_transaction_hook(transaction
, "committed");
2485 int refs_verify_refname_available(struct ref_store
*refs
,
2486 const char *refname
,
2487 const struct string_list
*extras
,
2488 const struct string_list
*skip
,
2492 const char *extra_refname
;
2493 struct strbuf dirname
= STRBUF_INIT
;
2494 struct strbuf referent
= STRBUF_INIT
;
2495 struct object_id oid
;
2497 struct ref_iterator
*iter
;
2502 * For the sake of comments in this function, suppose that
2503 * refname is "refs/foo/bar".
2508 strbuf_grow(&dirname
, strlen(refname
) + 1);
2509 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2511 * Just saying "Is a directory" when we e.g. can't
2512 * lock some multi-level ref isn't very informative,
2513 * the user won't be told *what* is a directory, so
2514 * let's not use strerror() below.
2517 /* Expand dirname to the new prefix, not including the trailing slash: */
2518 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2521 * We are still at a leading dir of the refname (e.g.,
2522 * "refs/foo"; if there is a reference with that name,
2523 * it is a conflict, *unless* it is in skip.
2525 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2528 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2529 &type
, &ignore_errno
)) {
2530 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2531 dirname
.buf
, refname
);
2535 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2536 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2537 refname
, dirname
.buf
);
2543 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2544 * There is no point in searching for a reference with that
2545 * name, because a refname isn't considered to conflict with
2546 * itself. But we still need to check for references whose
2547 * names are in the "refs/foo/bar/" namespace, because they
2550 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2551 strbuf_addch(&dirname
, '/');
2553 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2554 DO_FOR_EACH_INCLUDE_BROKEN
);
2555 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2557 string_list_has_string(skip
, iter
->refname
))
2560 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2561 iter
->refname
, refname
);
2562 ref_iterator_abort(iter
);
2566 if (ok
!= ITER_DONE
)
2567 BUG("error while iterating over references");
2569 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2571 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2572 refname
, extra_refname
);
2577 strbuf_release(&referent
);
2578 strbuf_release(&dirname
);
2582 struct do_for_each_reflog_help
{
2587 static int do_for_each_reflog_helper(struct repository
*r UNUSED
,
2588 const char *refname
,
2589 const struct object_id
*oid UNUSED
,
2593 struct do_for_each_reflog_help
*hp
= cb_data
;
2594 return hp
->fn(refname
, hp
->cb_data
);
2597 int refs_for_each_reflog(struct ref_store
*refs
, each_reflog_fn fn
, void *cb_data
)
2599 struct ref_iterator
*iter
;
2600 struct do_for_each_reflog_help hp
= { fn
, cb_data
};
2602 iter
= refs
->be
->reflog_iterator_begin(refs
);
2604 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2605 do_for_each_reflog_helper
, &hp
);
2608 int for_each_reflog(each_reflog_fn fn
, void *cb_data
)
2610 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2613 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2614 const char *refname
,
2615 each_reflog_ent_fn fn
,
2618 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2622 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2625 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2626 refname
, fn
, cb_data
);
2629 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2630 each_reflog_ent_fn fn
, void *cb_data
)
2632 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2635 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2638 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2642 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2644 return refs
->be
->reflog_exists(refs
, refname
);
2647 int reflog_exists(const char *refname
)
2649 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2652 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2655 return refs
->be
->create_reflog(refs
, refname
, err
);
2658 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2660 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2664 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2666 return refs
->be
->delete_reflog(refs
, refname
);
2669 int delete_reflog(const char *refname
)
2671 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2674 int refs_reflog_expire(struct ref_store
*refs
,
2675 const char *refname
,
2677 reflog_expiry_prepare_fn prepare_fn
,
2678 reflog_expiry_should_prune_fn should_prune_fn
,
2679 reflog_expiry_cleanup_fn cleanup_fn
,
2680 void *policy_cb_data
)
2682 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2683 prepare_fn
, should_prune_fn
,
2684 cleanup_fn
, policy_cb_data
);
2687 int reflog_expire(const char *refname
,
2689 reflog_expiry_prepare_fn prepare_fn
,
2690 reflog_expiry_should_prune_fn should_prune_fn
,
2691 reflog_expiry_cleanup_fn cleanup_fn
,
2692 void *policy_cb_data
)
2694 return refs_reflog_expire(get_main_ref_store(the_repository
),
2696 prepare_fn
, should_prune_fn
,
2697 cleanup_fn
, policy_cb_data
);
2700 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2703 struct ref_store
*refs
= transaction
->ref_store
;
2705 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2708 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2709 ref_transaction_for_each_queued_update_fn cb
,
2714 for (i
= 0; i
< transaction
->nr
; i
++) {
2715 struct ref_update
*update
= transaction
->updates
[i
];
2718 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2719 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2724 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2725 struct string_list
*refnames
, unsigned int flags
)
2727 struct ref_transaction
*transaction
;
2728 struct strbuf err
= STRBUF_INIT
;
2729 struct string_list_item
*item
;
2730 int ret
= 0, failures
= 0;
2736 msg
= normalize_reflog_message(logmsg
);
2739 * Since we don't check the references' old_oids, the
2740 * individual updates can't fail, so we can pack all of the
2741 * updates into a single transaction.
2743 transaction
= ref_store_transaction_begin(refs
, &err
);
2745 ret
= error("%s", err
.buf
);
2749 for_each_string_list_item(item
, refnames
) {
2750 ret
= ref_transaction_delete(transaction
, item
->string
,
2751 NULL
, flags
, msg
, &err
);
2753 warning(_("could not delete reference %s: %s"),
2754 item
->string
, err
.buf
);
2760 ret
= ref_transaction_commit(transaction
, &err
);
2762 if (refnames
->nr
== 1)
2763 error(_("could not delete reference %s: %s"),
2764 refnames
->items
[0].string
, err
.buf
);
2766 error(_("could not delete references: %s"), err
.buf
);
2770 if (!ret
&& failures
)
2772 ref_transaction_free(transaction
);
2773 strbuf_release(&err
);
2778 int delete_refs(const char *msg
, struct string_list
*refnames
,
2781 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2784 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2785 const char *newref
, const char *logmsg
)
2790 msg
= normalize_reflog_message(logmsg
);
2791 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2796 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2798 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2801 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2802 const char *newref
, const char *logmsg
)
2807 msg
= normalize_reflog_message(logmsg
);
2808 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2813 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2815 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2818 const char *ref_update_original_update_refname(struct ref_update
*update
)
2820 while (update
->parent_update
)
2821 update
= update
->parent_update
;
2823 return update
->refname
;