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((char *)transaction
->updates
[i
]->new_target
);
1221 free((char *)transaction
->updates
[i
]->old_target
);
1222 free(transaction
->updates
[i
]);
1224 free(transaction
->updates
);
1228 struct ref_update
*ref_transaction_add_update(
1229 struct ref_transaction
*transaction
,
1230 const char *refname
, unsigned int flags
,
1231 const struct object_id
*new_oid
,
1232 const struct object_id
*old_oid
,
1233 const char *new_target
, const char *old_target
,
1236 struct ref_update
*update
;
1238 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1239 BUG("update called for transaction that is not open");
1241 if (old_oid
&& old_target
)
1242 BUG("only one of old_oid and old_target should be non NULL");
1243 if (new_oid
&& new_target
)
1244 BUG("only one of new_oid and new_target should be non NULL");
1246 FLEX_ALLOC_STR(update
, refname
, refname
);
1247 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1248 transaction
->updates
[transaction
->nr
++] = update
;
1250 update
->flags
= flags
;
1252 update
->new_target
= xstrdup_or_null(new_target
);
1253 update
->old_target
= xstrdup_or_null(old_target
);
1254 if ((flags
& REF_HAVE_NEW
) && new_oid
)
1255 oidcpy(&update
->new_oid
, new_oid
);
1256 if ((flags
& REF_HAVE_OLD
) && old_oid
)
1257 oidcpy(&update
->old_oid
, old_oid
);
1259 update
->msg
= normalize_reflog_message(msg
);
1263 int ref_transaction_update(struct ref_transaction
*transaction
,
1264 const char *refname
,
1265 const struct object_id
*new_oid
,
1266 const struct object_id
*old_oid
,
1267 const char *new_target
,
1268 const char *old_target
,
1269 unsigned int flags
, const char *msg
,
1274 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1275 ((new_oid
&& !is_null_oid(new_oid
)) ?
1276 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1277 !refname_is_safe(refname
))) {
1278 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1283 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1284 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1287 * Clear flags outside the allowed set; this should be a noop because
1288 * of the BUG() check above, but it works around a -Wnonnull warning
1289 * with some versions of "gcc -O3".
1291 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1293 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1294 flags
|= (new_target
? REF_HAVE_NEW
: 0) | (old_target
? REF_HAVE_OLD
: 0);
1296 ref_transaction_add_update(transaction
, refname
, flags
,
1297 new_oid
, old_oid
, new_target
,
1302 int ref_transaction_create(struct ref_transaction
*transaction
,
1303 const char *refname
,
1304 const struct object_id
*new_oid
,
1305 unsigned int flags
, const char *msg
,
1308 if (!new_oid
|| is_null_oid(new_oid
)) {
1309 strbuf_addf(err
, "'%s' has a null OID", refname
);
1312 return ref_transaction_update(transaction
, refname
, new_oid
,
1313 null_oid(), NULL
, NULL
, flags
,
1317 int ref_transaction_delete(struct ref_transaction
*transaction
,
1318 const char *refname
,
1319 const struct object_id
*old_oid
,
1320 unsigned int flags
, const char *msg
,
1323 if (old_oid
&& is_null_oid(old_oid
))
1324 BUG("delete called with old_oid set to zeros");
1325 return ref_transaction_update(transaction
, refname
,
1326 null_oid(), old_oid
,
1331 int ref_transaction_verify(struct ref_transaction
*transaction
,
1332 const char *refname
,
1333 const struct object_id
*old_oid
,
1338 BUG("verify called with old_oid set to NULL");
1339 return ref_transaction_update(transaction
, refname
,
1345 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1346 const char *refname
, const struct object_id
*new_oid
,
1347 const struct object_id
*old_oid
, unsigned int flags
,
1348 enum action_on_err onerr
)
1350 struct ref_transaction
*t
= NULL
;
1351 struct strbuf err
= STRBUF_INIT
;
1354 t
= ref_store_transaction_begin(refs
, &err
);
1356 ref_transaction_update(t
, refname
, new_oid
, old_oid
, NULL
, NULL
,
1357 flags
, msg
, &err
) ||
1358 ref_transaction_commit(t
, &err
)) {
1360 ref_transaction_free(t
);
1363 const char *str
= _("update_ref failed for ref '%s': %s");
1366 case UPDATE_REFS_MSG_ON_ERR
:
1367 error(str
, refname
, err
.buf
);
1369 case UPDATE_REFS_DIE_ON_ERR
:
1370 die(str
, refname
, err
.buf
);
1372 case UPDATE_REFS_QUIET_ON_ERR
:
1375 strbuf_release(&err
);
1378 strbuf_release(&err
);
1380 ref_transaction_free(t
);
1384 int update_ref(const char *msg
, const char *refname
,
1385 const struct object_id
*new_oid
,
1386 const struct object_id
*old_oid
,
1387 unsigned int flags
, enum action_on_err onerr
)
1389 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1390 old_oid
, flags
, onerr
);
1394 * Check that the string refname matches a rule of the form
1395 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1396 * "foo/%.*s/baz", and return the string "bar".
1398 static const char *match_parse_rule(const char *refname
, const char *rule
,
1402 * Check that rule matches refname up to the first percent in the rule.
1403 * We can bail immediately if not, but otherwise we leave "rule" at the
1404 * %-placeholder, and "refname" at the start of the potential matched
1407 while (*rule
!= '%') {
1409 BUG("rev-parse rule did not have percent");
1410 if (*refname
++ != *rule
++)
1415 * Check that our "%" is the expected placeholder. This assumes there
1416 * are no other percents (placeholder or quoted) in the string, but
1417 * that is sufficient for our rev-parse rules.
1419 if (!skip_prefix(rule
, "%.*s", &rule
))
1423 * And now check that our suffix (if any) matches.
1425 if (!strip_suffix(refname
, rule
, len
))
1428 return refname
; /* len set by strip_suffix() */
1431 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1432 const char *refname
, int strict
)
1435 struct strbuf resolved_buf
= STRBUF_INIT
;
1437 /* skip first rule, it will always match */
1438 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1440 int rules_to_fail
= i
;
1441 const char *short_name
;
1442 size_t short_name_len
;
1444 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1450 * in strict mode, all (except the matched one) rules
1451 * must fail to resolve to a valid non-ambiguous ref
1454 rules_to_fail
= NUM_REV_PARSE_RULES
;
1457 * check if the short name resolves to a valid ref,
1458 * but use only rules prior to the matched one
1460 for (j
= 0; j
< rules_to_fail
; j
++) {
1461 const char *rule
= ref_rev_parse_rules
[j
];
1463 /* skip matched rule */
1468 * the short name is ambiguous, if it resolves
1469 * (with this previous rule) to a valid ref
1470 * read_ref() returns 0 on success
1472 strbuf_reset(&resolved_buf
);
1473 strbuf_addf(&resolved_buf
, rule
,
1474 cast_size_t_to_int(short_name_len
),
1476 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1481 * short name is non-ambiguous if all previous rules
1482 * haven't resolved to a valid ref
1484 if (j
== rules_to_fail
) {
1485 strbuf_release(&resolved_buf
);
1486 return xmemdupz(short_name
, short_name_len
);
1490 strbuf_release(&resolved_buf
);
1491 return xstrdup(refname
);
1494 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1496 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1500 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1501 struct strvec
*hide_refs
)
1504 if (!strcmp("transfer.hiderefs", var
) ||
1505 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1506 !strcmp(key
, "hiderefs"))) {
1511 return config_error_nonbool(var
);
1513 /* drop const to remove trailing '/' characters */
1514 ref
= (char *)strvec_push(hide_refs
, value
);
1516 while (len
&& ref
[len
- 1] == '/')
1522 int ref_is_hidden(const char *refname
, const char *refname_full
,
1523 const struct strvec
*hide_refs
)
1527 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1528 const char *match
= hide_refs
->v
[i
];
1529 const char *subject
;
1533 if (*match
== '!') {
1538 if (*match
== '^') {
1539 subject
= refname_full
;
1545 /* refname can be NULL when namespaces are used. */
1547 skip_prefix(subject
, match
, &p
) &&
1554 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1556 const char **pattern
;
1557 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1559 * We can't feed any excludes from hidden refs config
1560 * sections, since later rules may override previous
1561 * ones. For example, with rules "refs/foo" and
1562 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1563 * everything underneath it), but the earlier exclusion
1564 * would cause us to skip all of "refs/foo". We
1565 * likewise don't implement the namespace stripping
1566 * required for '^' rules.
1568 * Both are possible to do, but complicated, so avoid
1569 * populating the jump list at all if we see either of
1572 if (**pattern
== '!' || **pattern
== '^')
1575 return hide_refs
->v
;
1578 const char *find_descendant_ref(const char *dirname
,
1579 const struct string_list
*extras
,
1580 const struct string_list
*skip
)
1588 * Look at the place where dirname would be inserted into
1589 * extras. If there is an entry at that position that starts
1590 * with dirname (remember, dirname includes the trailing
1591 * slash) and is not in skip, then we have a conflict.
1593 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1594 pos
< extras
->nr
; pos
++) {
1595 const char *extra_refname
= extras
->items
[pos
].string
;
1597 if (!starts_with(extra_refname
, dirname
))
1600 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1601 return extra_refname
;
1606 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1608 struct object_id oid
;
1611 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1613 return fn("HEAD", &oid
, flag
, cb_data
);
1618 int head_ref(each_ref_fn fn
, void *cb_data
)
1620 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1623 struct ref_iterator
*refs_ref_iterator_begin(
1624 struct ref_store
*refs
,
1626 const char **exclude_patterns
,
1628 enum do_for_each_ref_flags flags
)
1630 struct ref_iterator
*iter
;
1632 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1633 static int ref_paranoia
= -1;
1635 if (ref_paranoia
< 0)
1636 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1638 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1639 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1643 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1645 * `iterator_begin()` already takes care of prefix, but we
1646 * might need to do some trimming:
1649 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1655 * Call fn for each reference in the specified submodule for which the
1656 * refname begins with prefix. If trim is non-zero, then trim that
1657 * many characters off the beginning of each refname before passing
1658 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1659 * include broken references in the iteration. If fn ever returns a
1660 * non-zero value, stop the iteration and return that value;
1661 * otherwise, return 0.
1663 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1664 each_repo_ref_fn fn
, int trim
, int flags
,
1667 struct ref_iterator
*iter
;
1668 struct ref_store
*refs
= get_main_ref_store(r
);
1673 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1675 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1678 struct do_for_each_ref_help
{
1683 static int do_for_each_ref_helper(struct repository
*r UNUSED
,
1684 const char *refname
,
1685 const struct object_id
*oid
,
1689 struct do_for_each_ref_help
*hp
= cb_data
;
1691 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1694 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1695 const char **exclude_patterns
,
1696 each_ref_fn fn
, int trim
,
1697 enum do_for_each_ref_flags flags
, void *cb_data
)
1699 struct ref_iterator
*iter
;
1700 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1705 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1708 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1709 do_for_each_ref_helper
, &hp
);
1712 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1714 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1717 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1719 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1722 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1723 each_ref_fn fn
, void *cb_data
)
1725 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1728 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1730 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1733 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1735 return do_for_each_ref(get_main_ref_store(the_repository
),
1736 prefix
, NULL
, fn
, 0, 0, cb_data
);
1739 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1740 const char **exclude_patterns
,
1741 each_ref_fn fn
, void *cb_data
)
1743 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1746 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1748 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1749 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1750 strlen(git_replace_ref_base
),
1751 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1754 int for_each_namespaced_ref(const char **exclude_patterns
,
1755 each_ref_fn fn
, void *cb_data
)
1757 struct strbuf buf
= STRBUF_INIT
;
1759 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1760 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1761 buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1762 strbuf_release(&buf
);
1766 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1768 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1769 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1772 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1774 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1777 int refs_for_each_include_root_refs(struct ref_store
*refs
, each_ref_fn fn
,
1780 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1781 DO_FOR_EACH_INCLUDE_ROOT_REFS
, cb_data
);
1784 static int qsort_strcmp(const void *va
, const void *vb
)
1786 const char *a
= *(const char **)va
;
1787 const char *b
= *(const char **)vb
;
1789 return strcmp(a
, b
);
1792 static void find_longest_prefixes_1(struct string_list
*out
,
1793 struct strbuf
*prefix
,
1794 const char **patterns
, size_t nr
)
1798 for (i
= 0; i
< nr
; i
++) {
1799 char c
= patterns
[i
][prefix
->len
];
1800 if (!c
|| is_glob_special(c
)) {
1801 string_list_append(out
, prefix
->buf
);
1811 * Set "end" to the index of the element _after_ the last one
1814 for (end
= i
+ 1; end
< nr
; end
++) {
1815 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1819 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1820 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1821 strbuf_setlen(prefix
, prefix
->len
- 1);
1827 static void find_longest_prefixes(struct string_list
*out
,
1828 const char **patterns
)
1830 struct strvec sorted
= STRVEC_INIT
;
1831 struct strbuf prefix
= STRBUF_INIT
;
1833 strvec_pushv(&sorted
, patterns
);
1834 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1836 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1838 strvec_clear(&sorted
);
1839 strbuf_release(&prefix
);
1842 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1843 const char *namespace,
1844 const char **patterns
,
1845 const char **exclude_patterns
,
1846 each_ref_fn fn
, void *cb_data
)
1848 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1849 struct string_list_item
*prefix
;
1850 struct strbuf buf
= STRBUF_INIT
;
1851 int ret
= 0, namespace_len
;
1853 find_longest_prefixes(&prefixes
, patterns
);
1856 strbuf_addstr(&buf
, namespace);
1857 namespace_len
= buf
.len
;
1859 for_each_string_list_item(prefix
, &prefixes
) {
1860 strbuf_addstr(&buf
, prefix
->string
);
1861 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1862 exclude_patterns
, fn
, cb_data
);
1865 strbuf_setlen(&buf
, namespace_len
);
1868 string_list_clear(&prefixes
, 0);
1869 strbuf_release(&buf
);
1873 static int refs_read_special_head(struct ref_store
*ref_store
,
1874 const char *refname
, struct object_id
*oid
,
1875 struct strbuf
*referent
, unsigned int *type
,
1878 struct strbuf full_path
= STRBUF_INIT
;
1879 struct strbuf content
= STRBUF_INIT
;
1881 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1883 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1884 *failure_errno
= errno
;
1888 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1892 strbuf_release(&full_path
);
1893 strbuf_release(&content
);
1897 static int is_special_ref(const char *refname
)
1900 * Special references are refs that have different semantics compared
1901 * to "normal" refs. These refs can thus not be stored in the ref
1902 * backend, but must always be accessed via the filesystem. The
1903 * following refs are special:
1905 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1906 * carries additional metadata like where it came from.
1908 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1911 * Reading, writing or deleting references must consistently go either
1912 * through the filesystem (special refs) or through the reference
1913 * backend (normal ones).
1915 static const char * const special_refs
[] = {
1921 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1922 if (!strcmp(refname
, special_refs
[i
]))
1928 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1929 struct object_id
*oid
, struct strbuf
*referent
,
1930 unsigned int *type
, int *failure_errno
)
1932 assert(failure_errno
);
1933 if (is_special_ref(refname
))
1934 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1935 type
, failure_errno
);
1937 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1938 type
, failure_errno
);
1941 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1942 struct strbuf
*referent
)
1944 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1947 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1948 const char *refname
,
1950 struct object_id
*oid
,
1953 static struct strbuf sb_refname
= STRBUF_INIT
;
1954 struct object_id unused_oid
;
1961 flags
= &unused_flags
;
1965 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1966 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1967 !refname_is_safe(refname
))
1971 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1972 * missing refs and refs that were present but invalid,
1973 * to complain about the latter to stderr.
1975 * We don't know whether the ref exists, so don't set
1978 *flags
|= REF_BAD_NAME
;
1981 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1982 unsigned int read_flags
= 0;
1985 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1986 &read_flags
, &failure_errno
)) {
1987 *flags
|= read_flags
;
1989 /* In reading mode, refs must eventually resolve */
1990 if (resolve_flags
& RESOLVE_REF_READING
)
1994 * Otherwise a missing ref is OK. But the files backend
1995 * may show errors besides ENOENT if there are
1996 * similarly-named refs.
1998 if (failure_errno
!= ENOENT
&&
1999 failure_errno
!= EISDIR
&&
2000 failure_errno
!= ENOTDIR
)
2004 if (*flags
& REF_BAD_NAME
)
2005 *flags
|= REF_ISBROKEN
;
2009 *flags
|= read_flags
;
2011 if (!(read_flags
& REF_ISSYMREF
)) {
2012 if (*flags
& REF_BAD_NAME
) {
2014 *flags
|= REF_ISBROKEN
;
2019 refname
= sb_refname
.buf
;
2020 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
2024 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
2025 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
2026 !refname_is_safe(refname
))
2029 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
2036 /* backend functions */
2037 int refs_init_db(struct ref_store
*refs
, int flags
, struct strbuf
*err
)
2039 return refs
->be
->init_db(refs
, flags
, err
);
2042 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
2043 struct object_id
*oid
, int *flags
)
2045 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
2046 resolve_flags
, oid
, flags
);
2049 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
2050 struct object_id
*oid
)
2052 struct ref_store
*refs
;
2055 refs
= get_submodule_ref_store(submodule
);
2060 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
2066 struct ref_store_hash_entry
2068 struct hashmap_entry ent
;
2070 struct ref_store
*refs
;
2072 /* NUL-terminated identifier of the ref store: */
2073 char name
[FLEX_ARRAY
];
2076 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
2077 const struct hashmap_entry
*eptr
,
2078 const struct hashmap_entry
*entry_or_key
,
2079 const void *keydata
)
2081 const struct ref_store_hash_entry
*e1
, *e2
;
2084 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2085 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2086 name
= keydata
? keydata
: e2
->name
;
2088 return strcmp(e1
->name
, name
);
2091 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2092 const char *name
, struct ref_store
*refs
)
2094 struct ref_store_hash_entry
*entry
;
2096 FLEX_ALLOC_STR(entry
, name
, name
);
2097 hashmap_entry_init(&entry
->ent
, strhash(name
));
2102 /* A hashmap of ref_stores, stored by submodule name: */
2103 static struct hashmap submodule_ref_stores
;
2105 /* A hashmap of ref_stores, stored by worktree id: */
2106 static struct hashmap worktree_ref_stores
;
2109 * Look up a ref store by name. If that ref_store hasn't been
2110 * registered yet, return NULL.
2112 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2115 struct ref_store_hash_entry
*entry
;
2118 if (!map
->tablesize
)
2119 /* It's initialized on demand in register_ref_store(). */
2122 hash
= strhash(name
);
2123 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2124 struct ref_store_hash_entry
, ent
);
2125 return entry
? entry
->refs
: NULL
;
2129 * Create, record, and return a ref_store instance for the specified
2132 static struct ref_store
*ref_store_init(struct repository
*repo
,
2136 const struct ref_storage_be
*be
;
2137 struct ref_store
*refs
;
2139 be
= find_ref_storage_backend(repo
->ref_storage_format
);
2141 BUG("reference backend is unknown");
2143 refs
= be
->init(repo
, gitdir
, flags
);
2147 struct ref_store
*get_main_ref_store(struct repository
*r
)
2149 if (r
->refs_private
)
2150 return r
->refs_private
;
2153 BUG("attempting to get main_ref_store outside of repository");
2155 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2156 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2157 return r
->refs_private
;
2161 * Associate a ref store with a name. It is a fatal error to call this
2162 * function twice for the same name.
2164 static void register_ref_store_map(struct hashmap
*map
,
2166 struct ref_store
*refs
,
2169 struct ref_store_hash_entry
*entry
;
2171 if (!map
->tablesize
)
2172 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2174 entry
= alloc_ref_store_hash_entry(name
, refs
);
2175 if (hashmap_put(map
, &entry
->ent
))
2176 BUG("%s ref_store '%s' initialized twice", type
, name
);
2179 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2181 struct strbuf submodule_sb
= STRBUF_INIT
;
2182 struct ref_store
*refs
;
2183 char *to_free
= NULL
;
2185 struct repository
*subrepo
;
2190 len
= strlen(submodule
);
2191 while (len
&& is_dir_sep(submodule
[len
- 1]))
2197 /* We need to strip off one or more trailing slashes */
2198 submodule
= to_free
= xmemdupz(submodule
, len
);
2200 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2204 strbuf_addstr(&submodule_sb
, submodule
);
2205 if (!is_nonbare_repository_dir(&submodule_sb
))
2208 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2211 subrepo
= xmalloc(sizeof(*subrepo
));
2213 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2214 * superprojects other than the_repository. This probably should be
2215 * done by making it take a struct repository * parameter instead of a
2218 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2223 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2224 REF_STORE_READ
| REF_STORE_ODB
);
2225 register_ref_store_map(&submodule_ref_stores
, "submodule",
2229 strbuf_release(&submodule_sb
);
2235 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2237 struct ref_store
*refs
;
2241 return get_main_ref_store(the_repository
);
2243 id
= wt
->id
? wt
->id
: "/";
2244 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2249 refs
= ref_store_init(the_repository
,
2250 git_common_path("worktrees/%s", wt
->id
),
2251 REF_STORE_ALL_CAPS
);
2253 refs
= ref_store_init(the_repository
,
2254 get_git_common_dir(),
2255 REF_STORE_ALL_CAPS
);
2258 register_ref_store_map(&worktree_ref_stores
, "worktree",
2263 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2264 const char *path
, const struct ref_storage_be
*be
)
2268 refs
->gitdir
= xstrdup(path
);
2271 /* backend functions */
2272 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2274 return refs
->be
->pack_refs(refs
, opts
);
2277 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2279 if (current_ref_iter
&&
2280 (current_ref_iter
->oid
== base
||
2281 oideq(current_ref_iter
->oid
, base
)))
2282 return ref_iterator_peel(current_ref_iter
, peeled
);
2284 return peel_object(base
, peeled
) ? -1 : 0;
2287 int refs_update_symref(struct ref_store
*refs
, const char *ref
,
2288 const char *target
, const char *logmsg
)
2290 struct ref_transaction
*transaction
;
2291 struct strbuf err
= STRBUF_INIT
;
2294 transaction
= ref_store_transaction_begin(refs
, &err
);
2296 ref_transaction_update(transaction
, ref
, NULL
, NULL
,
2297 target
, NULL
, REF_NO_DEREF
,
2299 ref_transaction_commit(transaction
, &err
)) {
2300 ret
= error("%s", err
.buf
);
2303 strbuf_release(&err
);
2305 ref_transaction_free(transaction
);
2310 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2313 return refs_update_symref(get_main_ref_store(the_repository
), ref_target
,
2314 refs_heads_master
, logmsg
);
2317 int ref_update_reject_duplicates(struct string_list
*refnames
,
2320 size_t i
, n
= refnames
->nr
;
2324 for (i
= 1; i
< n
; i
++) {
2325 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2326 refnames
->items
[i
].string
);
2330 _("multiple updates for ref '%s' not allowed"),
2331 refnames
->items
[i
].string
);
2333 } else if (cmp
> 0) {
2334 BUG("ref_update_reject_duplicates() received unsorted list");
2340 static int run_transaction_hook(struct ref_transaction
*transaction
,
2343 struct child_process proc
= CHILD_PROCESS_INIT
;
2344 struct strbuf buf
= STRBUF_INIT
;
2348 hook
= find_hook("reference-transaction");
2352 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2354 proc
.stdout_to_stderr
= 1;
2355 proc
.trace2_hook_name
= "reference-transaction";
2357 ret
= start_command(&proc
);
2361 sigchain_push(SIGPIPE
, SIG_IGN
);
2363 for (i
= 0; i
< transaction
->nr
; i
++) {
2364 struct ref_update
*update
= transaction
->updates
[i
];
2368 if (!(update
->flags
& REF_HAVE_OLD
))
2369 strbuf_addf(&buf
, "%s ", oid_to_hex(null_oid()));
2370 else if (update
->old_target
)
2371 strbuf_addf(&buf
, "ref:%s ", update
->old_target
);
2373 strbuf_addf(&buf
, "%s ", oid_to_hex(&update
->old_oid
));
2375 if (!(update
->flags
& REF_HAVE_NEW
))
2376 strbuf_addf(&buf
, "%s ", oid_to_hex(null_oid()));
2377 else if (update
->new_target
)
2378 strbuf_addf(&buf
, "ref:%s ", update
->new_target
);
2380 strbuf_addf(&buf
, "%s ", oid_to_hex(&update
->new_oid
));
2382 strbuf_addf(&buf
, "%s\n", update
->refname
);
2384 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2385 if (errno
!= EPIPE
) {
2386 /* Don't leak errno outside this API */
2395 sigchain_pop(SIGPIPE
);
2396 strbuf_release(&buf
);
2398 ret
|= finish_command(&proc
);
2402 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2405 struct ref_store
*refs
= transaction
->ref_store
;
2408 switch (transaction
->state
) {
2409 case REF_TRANSACTION_OPEN
:
2412 case REF_TRANSACTION_PREPARED
:
2413 BUG("prepare called twice on reference transaction");
2415 case REF_TRANSACTION_CLOSED
:
2416 BUG("prepare called on a closed reference transaction");
2419 BUG("unexpected reference transaction state");
2423 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2425 _("ref updates forbidden inside quarantine environment"));
2429 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2433 ret
= run_transaction_hook(transaction
, "prepared");
2435 ref_transaction_abort(transaction
, err
);
2436 die(_("ref updates aborted by hook"));
2442 int ref_transaction_abort(struct ref_transaction
*transaction
,
2445 struct ref_store
*refs
= transaction
->ref_store
;
2448 switch (transaction
->state
) {
2449 case REF_TRANSACTION_OPEN
:
2450 /* No need to abort explicitly. */
2452 case REF_TRANSACTION_PREPARED
:
2453 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2455 case REF_TRANSACTION_CLOSED
:
2456 BUG("abort called on a closed reference transaction");
2459 BUG("unexpected reference transaction state");
2463 run_transaction_hook(transaction
, "aborted");
2465 ref_transaction_free(transaction
);
2469 int ref_transaction_commit(struct ref_transaction
*transaction
,
2472 struct ref_store
*refs
= transaction
->ref_store
;
2475 switch (transaction
->state
) {
2476 case REF_TRANSACTION_OPEN
:
2477 /* Need to prepare first. */
2478 ret
= ref_transaction_prepare(transaction
, err
);
2482 case REF_TRANSACTION_PREPARED
:
2483 /* Fall through to finish. */
2485 case REF_TRANSACTION_CLOSED
:
2486 BUG("commit called on a closed reference transaction");
2489 BUG("unexpected reference transaction state");
2493 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2495 run_transaction_hook(transaction
, "committed");
2499 int refs_verify_refname_available(struct ref_store
*refs
,
2500 const char *refname
,
2501 const struct string_list
*extras
,
2502 const struct string_list
*skip
,
2506 const char *extra_refname
;
2507 struct strbuf dirname
= STRBUF_INIT
;
2508 struct strbuf referent
= STRBUF_INIT
;
2509 struct object_id oid
;
2511 struct ref_iterator
*iter
;
2516 * For the sake of comments in this function, suppose that
2517 * refname is "refs/foo/bar".
2522 strbuf_grow(&dirname
, strlen(refname
) + 1);
2523 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2525 * Just saying "Is a directory" when we e.g. can't
2526 * lock some multi-level ref isn't very informative,
2527 * the user won't be told *what* is a directory, so
2528 * let's not use strerror() below.
2531 /* Expand dirname to the new prefix, not including the trailing slash: */
2532 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2535 * We are still at a leading dir of the refname (e.g.,
2536 * "refs/foo"; if there is a reference with that name,
2537 * it is a conflict, *unless* it is in skip.
2539 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2542 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2543 &type
, &ignore_errno
)) {
2544 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2545 dirname
.buf
, refname
);
2549 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2550 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2551 refname
, dirname
.buf
);
2557 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2558 * There is no point in searching for a reference with that
2559 * name, because a refname isn't considered to conflict with
2560 * itself. But we still need to check for references whose
2561 * names are in the "refs/foo/bar/" namespace, because they
2564 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2565 strbuf_addch(&dirname
, '/');
2567 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2568 DO_FOR_EACH_INCLUDE_BROKEN
);
2569 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2571 string_list_has_string(skip
, iter
->refname
))
2574 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2575 iter
->refname
, refname
);
2576 ref_iterator_abort(iter
);
2580 if (ok
!= ITER_DONE
)
2581 BUG("error while iterating over references");
2583 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2585 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2586 refname
, extra_refname
);
2591 strbuf_release(&referent
);
2592 strbuf_release(&dirname
);
2596 struct do_for_each_reflog_help
{
2601 static int do_for_each_reflog_helper(struct repository
*r UNUSED
,
2602 const char *refname
,
2603 const struct object_id
*oid UNUSED
,
2607 struct do_for_each_reflog_help
*hp
= cb_data
;
2608 return hp
->fn(refname
, hp
->cb_data
);
2611 int refs_for_each_reflog(struct ref_store
*refs
, each_reflog_fn fn
, void *cb_data
)
2613 struct ref_iterator
*iter
;
2614 struct do_for_each_reflog_help hp
= { fn
, cb_data
};
2616 iter
= refs
->be
->reflog_iterator_begin(refs
);
2618 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2619 do_for_each_reflog_helper
, &hp
);
2622 int for_each_reflog(each_reflog_fn fn
, void *cb_data
)
2624 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2627 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2628 const char *refname
,
2629 each_reflog_ent_fn fn
,
2632 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2636 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2639 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2640 refname
, fn
, cb_data
);
2643 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2644 each_reflog_ent_fn fn
, void *cb_data
)
2646 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2649 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2652 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2656 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2658 return refs
->be
->reflog_exists(refs
, refname
);
2661 int reflog_exists(const char *refname
)
2663 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2666 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2669 return refs
->be
->create_reflog(refs
, refname
, err
);
2672 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2674 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2678 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2680 return refs
->be
->delete_reflog(refs
, refname
);
2683 int delete_reflog(const char *refname
)
2685 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2688 int refs_reflog_expire(struct ref_store
*refs
,
2689 const char *refname
,
2691 reflog_expiry_prepare_fn prepare_fn
,
2692 reflog_expiry_should_prune_fn should_prune_fn
,
2693 reflog_expiry_cleanup_fn cleanup_fn
,
2694 void *policy_cb_data
)
2696 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2697 prepare_fn
, should_prune_fn
,
2698 cleanup_fn
, policy_cb_data
);
2701 int reflog_expire(const char *refname
,
2703 reflog_expiry_prepare_fn prepare_fn
,
2704 reflog_expiry_should_prune_fn should_prune_fn
,
2705 reflog_expiry_cleanup_fn cleanup_fn
,
2706 void *policy_cb_data
)
2708 return refs_reflog_expire(get_main_ref_store(the_repository
),
2710 prepare_fn
, should_prune_fn
,
2711 cleanup_fn
, policy_cb_data
);
2714 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2717 struct ref_store
*refs
= transaction
->ref_store
;
2719 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2722 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2723 ref_transaction_for_each_queued_update_fn cb
,
2728 for (i
= 0; i
< transaction
->nr
; i
++) {
2729 struct ref_update
*update
= transaction
->updates
[i
];
2732 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2733 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2738 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2739 struct string_list
*refnames
, unsigned int flags
)
2741 struct ref_transaction
*transaction
;
2742 struct strbuf err
= STRBUF_INIT
;
2743 struct string_list_item
*item
;
2744 int ret
= 0, failures
= 0;
2750 msg
= normalize_reflog_message(logmsg
);
2753 * Since we don't check the references' old_oids, the
2754 * individual updates can't fail, so we can pack all of the
2755 * updates into a single transaction.
2757 transaction
= ref_store_transaction_begin(refs
, &err
);
2759 ret
= error("%s", err
.buf
);
2763 for_each_string_list_item(item
, refnames
) {
2764 ret
= ref_transaction_delete(transaction
, item
->string
,
2765 NULL
, flags
, msg
, &err
);
2767 warning(_("could not delete reference %s: %s"),
2768 item
->string
, err
.buf
);
2774 ret
= ref_transaction_commit(transaction
, &err
);
2776 if (refnames
->nr
== 1)
2777 error(_("could not delete reference %s: %s"),
2778 refnames
->items
[0].string
, err
.buf
);
2780 error(_("could not delete references: %s"), err
.buf
);
2784 if (!ret
&& failures
)
2786 ref_transaction_free(transaction
);
2787 strbuf_release(&err
);
2792 int delete_refs(const char *msg
, struct string_list
*refnames
,
2795 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2798 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2799 const char *newref
, const char *logmsg
)
2804 msg
= normalize_reflog_message(logmsg
);
2805 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2810 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2812 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2815 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2816 const char *newref
, const char *logmsg
)
2821 msg
= normalize_reflog_message(logmsg
);
2822 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2827 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2829 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2832 const char *ref_update_original_update_refname(struct ref_update
*update
)
2834 while (update
->parent_update
)
2835 update
= update
->parent_update
;
2837 return update
->refname
;
2840 int ref_update_has_null_new_value(struct ref_update
*update
)
2842 return !update
->new_target
&& is_null_oid(&update
->new_oid
);
2845 int ref_update_check_old_target(const char *referent
, struct ref_update
*update
,
2848 if (!update
->old_target
)
2849 BUG("called without old_target set");
2851 if (!strcmp(referent
, update
->old_target
))
2854 if (!strcmp(referent
, ""))
2855 strbuf_addf(err
, "verifying symref target: '%s': "
2856 "reference is missing but expected %s",
2857 ref_update_original_update_refname(update
),
2858 update
->old_target
);
2860 strbuf_addf(err
, "verifying symref target: '%s': "
2861 "is at %s but expected %s",
2862 ref_update_original_update_refname(update
),
2863 referent
, update
->old_target
);