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 static int is_current_worktree_ref(const char *ref
) {
864 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
867 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
868 const char **worktree_name
, int *worktree_name_length
,
869 const char **bare_refname
)
871 const char *name_dummy
;
872 int name_length_dummy
;
873 const char *ref_dummy
;
876 worktree_name
= &name_dummy
;
877 if (!worktree_name_length
)
878 worktree_name_length
= &name_length_dummy
;
880 bare_refname
= &ref_dummy
;
882 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
883 const char *slash
= strchr(*bare_refname
, '/');
885 *worktree_name
= *bare_refname
;
887 *worktree_name_length
= strlen(*worktree_name
);
889 /* This is an error condition, and the caller tell because the bare_refname is "" */
890 *bare_refname
= *worktree_name
+ *worktree_name_length
;
891 return REF_WORKTREE_OTHER
;
894 *worktree_name_length
= slash
- *bare_refname
;
895 *bare_refname
= slash
+ 1;
897 if (is_current_worktree_ref(*bare_refname
))
898 return REF_WORKTREE_OTHER
;
901 *worktree_name
= NULL
;
902 *worktree_name_length
= 0;
904 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
905 && is_current_worktree_ref(*bare_refname
))
906 return REF_WORKTREE_MAIN
;
908 *bare_refname
= maybe_worktree_ref
;
909 if (is_current_worktree_ref(maybe_worktree_ref
))
910 return REF_WORKTREE_CURRENT
;
912 return REF_WORKTREE_SHARED
;
915 long get_files_ref_lock_timeout_ms(void)
917 static int configured
= 0;
919 /* The default timeout is 100 ms: */
920 static int timeout_ms
= 100;
923 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
930 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
932 const struct object_id
*old_oid
,
935 struct ref_transaction
*transaction
;
936 struct strbuf err
= STRBUF_INIT
;
938 transaction
= ref_store_transaction_begin(refs
, &err
);
940 ref_transaction_delete(transaction
, refname
, old_oid
,
942 ref_transaction_commit(transaction
, &err
)) {
943 error("%s", err
.buf
);
944 ref_transaction_free(transaction
);
945 strbuf_release(&err
);
948 ref_transaction_free(transaction
);
949 strbuf_release(&err
);
953 int delete_ref(const char *msg
, const char *refname
,
954 const struct object_id
*old_oid
, unsigned int flags
)
956 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
960 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
965 while ((c
= *msg
++)) {
966 if (wasspace
&& isspace(c
))
968 wasspace
= isspace(c
);
976 static char *normalize_reflog_message(const char *msg
)
978 struct strbuf sb
= STRBUF_INIT
;
981 copy_reflog_msg(&sb
, msg
);
982 return strbuf_detach(&sb
, NULL
);
985 int should_autocreate_reflog(const char *refname
)
987 switch (log_all_ref_updates
) {
988 case LOG_REFS_ALWAYS
:
990 case LOG_REFS_NORMAL
:
991 return starts_with(refname
, "refs/heads/") ||
992 starts_with(refname
, "refs/remotes/") ||
993 starts_with(refname
, "refs/notes/") ||
994 !strcmp(refname
, "HEAD");
1000 int is_branch(const char *refname
)
1002 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
1005 struct read_ref_at_cb
{
1006 const char *refname
;
1007 timestamp_t at_time
;
1010 struct object_id
*oid
;
1013 struct object_id ooid
;
1014 struct object_id noid
;
1018 timestamp_t
*cutoff_time
;
1023 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
1024 timestamp_t timestamp
, int tz
, const char *message
)
1027 *cb
->msg
= xstrdup(message
);
1028 if (cb
->cutoff_time
)
1029 *cb
->cutoff_time
= timestamp
;
1031 *cb
->cutoff_tz
= tz
;
1033 *cb
->cutoff_cnt
= cb
->reccnt
;
1036 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1037 const char *email UNUSED
,
1038 timestamp_t timestamp
, int tz
,
1039 const char *message
, void *cb_data
)
1041 struct read_ref_at_cb
*cb
= cb_data
;
1045 cb
->date
= timestamp
;
1048 * It is not possible for cb->cnt == 0 on the first iteration because
1049 * that special case is handled in read_ref_at().
1053 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
1054 if (timestamp
<= cb
->at_time
|| reached_count
) {
1055 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1057 * we have not yet updated cb->[n|o]oid so they still
1058 * hold the values for the previous record.
1060 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
1061 warning(_("log for ref %s has gap after %s"),
1062 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1064 oidcpy(cb
->oid
, ooid
);
1065 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
1066 oidcpy(cb
->oid
, noid
);
1067 else if (!oideq(noid
, cb
->oid
))
1068 warning(_("log for ref %s unexpectedly ended on %s"),
1069 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1070 DATE_MODE(RFC2822
)));
1074 oidcpy(&cb
->ooid
, ooid
);
1075 oidcpy(&cb
->noid
, noid
);
1076 return cb
->found_it
;
1079 static int read_ref_at_ent_newest(struct object_id
*ooid UNUSED
,
1080 struct object_id
*noid
,
1081 const char *email UNUSED
,
1082 timestamp_t timestamp
, int tz
,
1083 const char *message
, void *cb_data
)
1085 struct read_ref_at_cb
*cb
= cb_data
;
1087 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1088 oidcpy(cb
->oid
, noid
);
1089 /* We just want the first entry */
1093 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1094 const char *email UNUSED
,
1095 timestamp_t timestamp
, int tz
,
1096 const char *message
, void *cb_data
)
1098 struct read_ref_at_cb
*cb
= cb_data
;
1100 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1101 oidcpy(cb
->oid
, ooid
);
1102 if (is_null_oid(cb
->oid
))
1103 oidcpy(cb
->oid
, noid
);
1104 /* We just want the first entry */
1108 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1109 unsigned int flags
, timestamp_t at_time
, int cnt
,
1110 struct object_id
*oid
, char **msg
,
1111 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1113 struct read_ref_at_cb cb
;
1115 memset(&cb
, 0, sizeof(cb
));
1116 cb
.refname
= refname
;
1117 cb
.at_time
= at_time
;
1120 cb
.cutoff_time
= cutoff_time
;
1121 cb
.cutoff_tz
= cutoff_tz
;
1122 cb
.cutoff_cnt
= cutoff_cnt
;
1126 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
1130 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1133 if (flags
& GET_OID_QUIETLY
)
1136 die(_("log for %s is empty"), refname
);
1141 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1146 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1149 struct ref_transaction
*tr
;
1152 CALLOC_ARRAY(tr
, 1);
1153 tr
->ref_store
= refs
;
1157 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1159 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1162 void ref_transaction_free(struct ref_transaction
*transaction
)
1169 switch (transaction
->state
) {
1170 case REF_TRANSACTION_OPEN
:
1171 case REF_TRANSACTION_CLOSED
:
1174 case REF_TRANSACTION_PREPARED
:
1175 BUG("free called on a prepared reference transaction");
1178 BUG("unexpected reference transaction state");
1182 for (i
= 0; i
< transaction
->nr
; i
++) {
1183 free(transaction
->updates
[i
]->msg
);
1184 free(transaction
->updates
[i
]);
1186 free(transaction
->updates
);
1190 struct ref_update
*ref_transaction_add_update(
1191 struct ref_transaction
*transaction
,
1192 const char *refname
, unsigned int flags
,
1193 const struct object_id
*new_oid
,
1194 const struct object_id
*old_oid
,
1197 struct ref_update
*update
;
1199 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1200 BUG("update called for transaction that is not open");
1202 FLEX_ALLOC_STR(update
, refname
, refname
);
1203 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1204 transaction
->updates
[transaction
->nr
++] = update
;
1206 update
->flags
= flags
;
1208 if (flags
& REF_HAVE_NEW
)
1209 oidcpy(&update
->new_oid
, new_oid
);
1210 if (flags
& REF_HAVE_OLD
)
1211 oidcpy(&update
->old_oid
, old_oid
);
1212 update
->msg
= normalize_reflog_message(msg
);
1216 int ref_transaction_update(struct ref_transaction
*transaction
,
1217 const char *refname
,
1218 const struct object_id
*new_oid
,
1219 const struct object_id
*old_oid
,
1220 unsigned int flags
, const char *msg
,
1225 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1226 ((new_oid
&& !is_null_oid(new_oid
)) ?
1227 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1228 !refname_is_safe(refname
))) {
1229 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1234 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1235 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1238 * Clear flags outside the allowed set; this should be a noop because
1239 * of the BUG() check above, but it works around a -Wnonnull warning
1240 * with some versions of "gcc -O3".
1242 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1244 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1246 ref_transaction_add_update(transaction
, refname
, flags
,
1247 new_oid
, old_oid
, msg
);
1251 int ref_transaction_create(struct ref_transaction
*transaction
,
1252 const char *refname
,
1253 const struct object_id
*new_oid
,
1254 unsigned int flags
, const char *msg
,
1257 if (!new_oid
|| is_null_oid(new_oid
)) {
1258 strbuf_addf(err
, "'%s' has a null OID", refname
);
1261 return ref_transaction_update(transaction
, refname
, new_oid
,
1262 null_oid(), flags
, msg
, err
);
1265 int ref_transaction_delete(struct ref_transaction
*transaction
,
1266 const char *refname
,
1267 const struct object_id
*old_oid
,
1268 unsigned int flags
, const char *msg
,
1271 if (old_oid
&& is_null_oid(old_oid
))
1272 BUG("delete called with old_oid set to zeros");
1273 return ref_transaction_update(transaction
, refname
,
1274 null_oid(), old_oid
,
1278 int ref_transaction_verify(struct ref_transaction
*transaction
,
1279 const char *refname
,
1280 const struct object_id
*old_oid
,
1285 BUG("verify called with old_oid set to NULL");
1286 return ref_transaction_update(transaction
, refname
,
1291 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1292 const char *refname
, const struct object_id
*new_oid
,
1293 const struct object_id
*old_oid
, unsigned int flags
,
1294 enum action_on_err onerr
)
1296 struct ref_transaction
*t
= NULL
;
1297 struct strbuf err
= STRBUF_INIT
;
1300 t
= ref_store_transaction_begin(refs
, &err
);
1302 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1304 ref_transaction_commit(t
, &err
)) {
1306 ref_transaction_free(t
);
1309 const char *str
= _("update_ref failed for ref '%s': %s");
1312 case UPDATE_REFS_MSG_ON_ERR
:
1313 error(str
, refname
, err
.buf
);
1315 case UPDATE_REFS_DIE_ON_ERR
:
1316 die(str
, refname
, err
.buf
);
1318 case UPDATE_REFS_QUIET_ON_ERR
:
1321 strbuf_release(&err
);
1324 strbuf_release(&err
);
1326 ref_transaction_free(t
);
1330 int update_ref(const char *msg
, const char *refname
,
1331 const struct object_id
*new_oid
,
1332 const struct object_id
*old_oid
,
1333 unsigned int flags
, enum action_on_err onerr
)
1335 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1336 old_oid
, flags
, onerr
);
1340 * Check that the string refname matches a rule of the form
1341 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1342 * "foo/%.*s/baz", and return the string "bar".
1344 static const char *match_parse_rule(const char *refname
, const char *rule
,
1348 * Check that rule matches refname up to the first percent in the rule.
1349 * We can bail immediately if not, but otherwise we leave "rule" at the
1350 * %-placeholder, and "refname" at the start of the potential matched
1353 while (*rule
!= '%') {
1355 BUG("rev-parse rule did not have percent");
1356 if (*refname
++ != *rule
++)
1361 * Check that our "%" is the expected placeholder. This assumes there
1362 * are no other percents (placeholder or quoted) in the string, but
1363 * that is sufficient for our rev-parse rules.
1365 if (!skip_prefix(rule
, "%.*s", &rule
))
1369 * And now check that our suffix (if any) matches.
1371 if (!strip_suffix(refname
, rule
, len
))
1374 return refname
; /* len set by strip_suffix() */
1377 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1378 const char *refname
, int strict
)
1381 struct strbuf resolved_buf
= STRBUF_INIT
;
1383 /* skip first rule, it will always match */
1384 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1386 int rules_to_fail
= i
;
1387 const char *short_name
;
1388 size_t short_name_len
;
1390 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1396 * in strict mode, all (except the matched one) rules
1397 * must fail to resolve to a valid non-ambiguous ref
1400 rules_to_fail
= NUM_REV_PARSE_RULES
;
1403 * check if the short name resolves to a valid ref,
1404 * but use only rules prior to the matched one
1406 for (j
= 0; j
< rules_to_fail
; j
++) {
1407 const char *rule
= ref_rev_parse_rules
[j
];
1409 /* skip matched rule */
1414 * the short name is ambiguous, if it resolves
1415 * (with this previous rule) to a valid ref
1416 * read_ref() returns 0 on success
1418 strbuf_reset(&resolved_buf
);
1419 strbuf_addf(&resolved_buf
, rule
,
1420 cast_size_t_to_int(short_name_len
),
1422 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1427 * short name is non-ambiguous if all previous rules
1428 * haven't resolved to a valid ref
1430 if (j
== rules_to_fail
) {
1431 strbuf_release(&resolved_buf
);
1432 return xmemdupz(short_name
, short_name_len
);
1436 strbuf_release(&resolved_buf
);
1437 return xstrdup(refname
);
1440 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1442 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1446 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1447 struct strvec
*hide_refs
)
1450 if (!strcmp("transfer.hiderefs", var
) ||
1451 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1452 !strcmp(key
, "hiderefs"))) {
1457 return config_error_nonbool(var
);
1459 /* drop const to remove trailing '/' characters */
1460 ref
= (char *)strvec_push(hide_refs
, value
);
1462 while (len
&& ref
[len
- 1] == '/')
1468 int ref_is_hidden(const char *refname
, const char *refname_full
,
1469 const struct strvec
*hide_refs
)
1473 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1474 const char *match
= hide_refs
->v
[i
];
1475 const char *subject
;
1479 if (*match
== '!') {
1484 if (*match
== '^') {
1485 subject
= refname_full
;
1491 /* refname can be NULL when namespaces are used. */
1493 skip_prefix(subject
, match
, &p
) &&
1500 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1502 const char **pattern
;
1503 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1505 * We can't feed any excludes from hidden refs config
1506 * sections, since later rules may override previous
1507 * ones. For example, with rules "refs/foo" and
1508 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1509 * everything underneath it), but the earlier exclusion
1510 * would cause us to skip all of "refs/foo". We
1511 * likewise don't implement the namespace stripping
1512 * required for '^' rules.
1514 * Both are possible to do, but complicated, so avoid
1515 * populating the jump list at all if we see either of
1518 if (**pattern
== '!' || **pattern
== '^')
1521 return hide_refs
->v
;
1524 const char *find_descendant_ref(const char *dirname
,
1525 const struct string_list
*extras
,
1526 const struct string_list
*skip
)
1534 * Look at the place where dirname would be inserted into
1535 * extras. If there is an entry at that position that starts
1536 * with dirname (remember, dirname includes the trailing
1537 * slash) and is not in skip, then we have a conflict.
1539 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1540 pos
< extras
->nr
; pos
++) {
1541 const char *extra_refname
= extras
->items
[pos
].string
;
1543 if (!starts_with(extra_refname
, dirname
))
1546 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1547 return extra_refname
;
1552 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1554 struct object_id oid
;
1557 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1559 return fn("HEAD", &oid
, flag
, cb_data
);
1564 int head_ref(each_ref_fn fn
, void *cb_data
)
1566 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1569 struct ref_iterator
*refs_ref_iterator_begin(
1570 struct ref_store
*refs
,
1572 const char **exclude_patterns
,
1574 enum do_for_each_ref_flags flags
)
1576 struct ref_iterator
*iter
;
1578 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1579 static int ref_paranoia
= -1;
1581 if (ref_paranoia
< 0)
1582 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1584 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1585 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1589 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1591 * `iterator_begin()` already takes care of prefix, but we
1592 * might need to do some trimming:
1595 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1601 * Call fn for each reference in the specified submodule for which the
1602 * refname begins with prefix. If trim is non-zero, then trim that
1603 * many characters off the beginning of each refname before passing
1604 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1605 * include broken references in the iteration. If fn ever returns a
1606 * non-zero value, stop the iteration and return that value;
1607 * otherwise, return 0.
1609 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1610 each_repo_ref_fn fn
, int trim
, int flags
,
1613 struct ref_iterator
*iter
;
1614 struct ref_store
*refs
= get_main_ref_store(r
);
1619 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1621 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1624 struct do_for_each_ref_help
{
1629 static int do_for_each_ref_helper(struct repository
*r UNUSED
,
1630 const char *refname
,
1631 const struct object_id
*oid
,
1635 struct do_for_each_ref_help
*hp
= cb_data
;
1637 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1640 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1641 const char **exclude_patterns
,
1642 each_ref_fn fn
, int trim
,
1643 enum do_for_each_ref_flags flags
, void *cb_data
)
1645 struct ref_iterator
*iter
;
1646 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1651 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1654 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1655 do_for_each_ref_helper
, &hp
);
1658 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1660 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1663 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1665 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1668 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1669 each_ref_fn fn
, void *cb_data
)
1671 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1674 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1676 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1679 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1681 return do_for_each_ref(get_main_ref_store(the_repository
),
1682 prefix
, NULL
, fn
, 0, 0, cb_data
);
1685 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1686 const char **exclude_patterns
,
1687 each_ref_fn fn
, void *cb_data
)
1689 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1692 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1694 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1695 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1696 strlen(git_replace_ref_base
),
1697 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1700 int for_each_namespaced_ref(const char **exclude_patterns
,
1701 each_ref_fn fn
, void *cb_data
)
1703 struct strbuf buf
= STRBUF_INIT
;
1705 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1706 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1707 buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1708 strbuf_release(&buf
);
1712 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1714 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1715 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1718 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1720 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1723 static int qsort_strcmp(const void *va
, const void *vb
)
1725 const char *a
= *(const char **)va
;
1726 const char *b
= *(const char **)vb
;
1728 return strcmp(a
, b
);
1731 static void find_longest_prefixes_1(struct string_list
*out
,
1732 struct strbuf
*prefix
,
1733 const char **patterns
, size_t nr
)
1737 for (i
= 0; i
< nr
; i
++) {
1738 char c
= patterns
[i
][prefix
->len
];
1739 if (!c
|| is_glob_special(c
)) {
1740 string_list_append(out
, prefix
->buf
);
1750 * Set "end" to the index of the element _after_ the last one
1753 for (end
= i
+ 1; end
< nr
; end
++) {
1754 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1758 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1759 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1760 strbuf_setlen(prefix
, prefix
->len
- 1);
1766 static void find_longest_prefixes(struct string_list
*out
,
1767 const char **patterns
)
1769 struct strvec sorted
= STRVEC_INIT
;
1770 struct strbuf prefix
= STRBUF_INIT
;
1772 strvec_pushv(&sorted
, patterns
);
1773 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1775 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1777 strvec_clear(&sorted
);
1778 strbuf_release(&prefix
);
1781 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1782 const char *namespace,
1783 const char **patterns
,
1784 const char **exclude_patterns
,
1785 each_ref_fn fn
, void *cb_data
)
1787 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1788 struct string_list_item
*prefix
;
1789 struct strbuf buf
= STRBUF_INIT
;
1790 int ret
= 0, namespace_len
;
1792 find_longest_prefixes(&prefixes
, patterns
);
1795 strbuf_addstr(&buf
, namespace);
1796 namespace_len
= buf
.len
;
1798 for_each_string_list_item(prefix
, &prefixes
) {
1799 strbuf_addstr(&buf
, prefix
->string
);
1800 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1801 exclude_patterns
, fn
, cb_data
);
1804 strbuf_setlen(&buf
, namespace_len
);
1807 string_list_clear(&prefixes
, 0);
1808 strbuf_release(&buf
);
1812 static int refs_read_special_head(struct ref_store
*ref_store
,
1813 const char *refname
, struct object_id
*oid
,
1814 struct strbuf
*referent
, unsigned int *type
,
1817 struct strbuf full_path
= STRBUF_INIT
;
1818 struct strbuf content
= STRBUF_INIT
;
1820 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1822 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1823 *failure_errno
= errno
;
1827 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1831 strbuf_release(&full_path
);
1832 strbuf_release(&content
);
1836 static int is_special_ref(const char *refname
)
1839 * Special references are refs that have different semantics compared
1840 * to "normal" refs. These refs can thus not be stored in the ref
1841 * backend, but must always be accessed via the filesystem. The
1842 * following refs are special:
1844 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1845 * carries additional metadata like where it came from.
1847 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1850 * Reading, writing or deleting references must consistently go either
1851 * through the filesystem (special refs) or through the reference
1852 * backend (normal ones).
1854 static const char * const special_refs
[] = {
1860 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1861 if (!strcmp(refname
, special_refs
[i
]))
1867 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1868 struct object_id
*oid
, struct strbuf
*referent
,
1869 unsigned int *type
, int *failure_errno
)
1871 assert(failure_errno
);
1872 if (is_special_ref(refname
))
1873 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1874 type
, failure_errno
);
1876 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1877 type
, failure_errno
);
1880 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1881 struct strbuf
*referent
)
1883 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1886 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1887 const char *refname
,
1889 struct object_id
*oid
,
1892 static struct strbuf sb_refname
= STRBUF_INIT
;
1893 struct object_id unused_oid
;
1900 flags
= &unused_flags
;
1904 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1905 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1906 !refname_is_safe(refname
))
1910 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1911 * missing refs and refs that were present but invalid,
1912 * to complain about the latter to stderr.
1914 * We don't know whether the ref exists, so don't set
1917 *flags
|= REF_BAD_NAME
;
1920 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1921 unsigned int read_flags
= 0;
1924 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1925 &read_flags
, &failure_errno
)) {
1926 *flags
|= read_flags
;
1928 /* In reading mode, refs must eventually resolve */
1929 if (resolve_flags
& RESOLVE_REF_READING
)
1933 * Otherwise a missing ref is OK. But the files backend
1934 * may show errors besides ENOENT if there are
1935 * similarly-named refs.
1937 if (failure_errno
!= ENOENT
&&
1938 failure_errno
!= EISDIR
&&
1939 failure_errno
!= ENOTDIR
)
1943 if (*flags
& REF_BAD_NAME
)
1944 *flags
|= REF_ISBROKEN
;
1948 *flags
|= read_flags
;
1950 if (!(read_flags
& REF_ISSYMREF
)) {
1951 if (*flags
& REF_BAD_NAME
) {
1953 *flags
|= REF_ISBROKEN
;
1958 refname
= sb_refname
.buf
;
1959 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1963 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1964 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1965 !refname_is_safe(refname
))
1968 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1975 /* backend functions */
1976 int refs_init_db(struct ref_store
*refs
, int flags
, struct strbuf
*err
)
1978 return refs
->be
->init_db(refs
, flags
, err
);
1981 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1982 struct object_id
*oid
, int *flags
)
1984 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1985 resolve_flags
, oid
, flags
);
1988 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1989 struct object_id
*oid
)
1991 struct ref_store
*refs
;
1994 refs
= get_submodule_ref_store(submodule
);
1999 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
2005 struct ref_store_hash_entry
2007 struct hashmap_entry ent
;
2009 struct ref_store
*refs
;
2011 /* NUL-terminated identifier of the ref store: */
2012 char name
[FLEX_ARRAY
];
2015 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
2016 const struct hashmap_entry
*eptr
,
2017 const struct hashmap_entry
*entry_or_key
,
2018 const void *keydata
)
2020 const struct ref_store_hash_entry
*e1
, *e2
;
2023 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2024 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2025 name
= keydata
? keydata
: e2
->name
;
2027 return strcmp(e1
->name
, name
);
2030 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2031 const char *name
, struct ref_store
*refs
)
2033 struct ref_store_hash_entry
*entry
;
2035 FLEX_ALLOC_STR(entry
, name
, name
);
2036 hashmap_entry_init(&entry
->ent
, strhash(name
));
2041 /* A hashmap of ref_stores, stored by submodule name: */
2042 static struct hashmap submodule_ref_stores
;
2044 /* A hashmap of ref_stores, stored by worktree id: */
2045 static struct hashmap worktree_ref_stores
;
2048 * Look up a ref store by name. If that ref_store hasn't been
2049 * registered yet, return NULL.
2051 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2054 struct ref_store_hash_entry
*entry
;
2057 if (!map
->tablesize
)
2058 /* It's initialized on demand in register_ref_store(). */
2061 hash
= strhash(name
);
2062 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2063 struct ref_store_hash_entry
, ent
);
2064 return entry
? entry
->refs
: NULL
;
2068 * Create, record, and return a ref_store instance for the specified
2071 static struct ref_store
*ref_store_init(struct repository
*repo
,
2075 const struct ref_storage_be
*be
;
2076 struct ref_store
*refs
;
2078 be
= find_ref_storage_backend(repo
->ref_storage_format
);
2080 BUG("reference backend is unknown");
2082 refs
= be
->init(repo
, gitdir
, flags
);
2086 struct ref_store
*get_main_ref_store(struct repository
*r
)
2088 if (r
->refs_private
)
2089 return r
->refs_private
;
2092 BUG("attempting to get main_ref_store outside of repository");
2094 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2095 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2096 return r
->refs_private
;
2100 * Associate a ref store with a name. It is a fatal error to call this
2101 * function twice for the same name.
2103 static void register_ref_store_map(struct hashmap
*map
,
2105 struct ref_store
*refs
,
2108 struct ref_store_hash_entry
*entry
;
2110 if (!map
->tablesize
)
2111 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2113 entry
= alloc_ref_store_hash_entry(name
, refs
);
2114 if (hashmap_put(map
, &entry
->ent
))
2115 BUG("%s ref_store '%s' initialized twice", type
, name
);
2118 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2120 struct strbuf submodule_sb
= STRBUF_INIT
;
2121 struct ref_store
*refs
;
2122 char *to_free
= NULL
;
2124 struct repository
*subrepo
;
2129 len
= strlen(submodule
);
2130 while (len
&& is_dir_sep(submodule
[len
- 1]))
2136 /* We need to strip off one or more trailing slashes */
2137 submodule
= to_free
= xmemdupz(submodule
, len
);
2139 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2143 strbuf_addstr(&submodule_sb
, submodule
);
2144 if (!is_nonbare_repository_dir(&submodule_sb
))
2147 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2150 subrepo
= xmalloc(sizeof(*subrepo
));
2152 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2153 * superprojects other than the_repository. This probably should be
2154 * done by making it take a struct repository * parameter instead of a
2157 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2162 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2163 REF_STORE_READ
| REF_STORE_ODB
);
2164 register_ref_store_map(&submodule_ref_stores
, "submodule",
2168 strbuf_release(&submodule_sb
);
2174 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2176 struct ref_store
*refs
;
2180 return get_main_ref_store(the_repository
);
2182 id
= wt
->id
? wt
->id
: "/";
2183 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2188 refs
= ref_store_init(the_repository
,
2189 git_common_path("worktrees/%s", wt
->id
),
2190 REF_STORE_ALL_CAPS
);
2192 refs
= ref_store_init(the_repository
,
2193 get_git_common_dir(),
2194 REF_STORE_ALL_CAPS
);
2197 register_ref_store_map(&worktree_ref_stores
, "worktree",
2202 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2203 const char *path
, const struct ref_storage_be
*be
)
2207 refs
->gitdir
= xstrdup(path
);
2210 /* backend functions */
2211 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2213 return refs
->be
->pack_refs(refs
, opts
);
2216 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2218 if (current_ref_iter
&&
2219 (current_ref_iter
->oid
== base
||
2220 oideq(current_ref_iter
->oid
, base
)))
2221 return ref_iterator_peel(current_ref_iter
, peeled
);
2223 return peel_object(base
, peeled
) ? -1 : 0;
2226 int refs_create_symref(struct ref_store
*refs
,
2227 const char *ref_target
,
2228 const char *refs_heads_master
,
2234 msg
= normalize_reflog_message(logmsg
);
2235 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2241 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2244 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2245 refs_heads_master
, logmsg
);
2248 int ref_update_reject_duplicates(struct string_list
*refnames
,
2251 size_t i
, n
= refnames
->nr
;
2255 for (i
= 1; i
< n
; i
++) {
2256 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2257 refnames
->items
[i
].string
);
2261 _("multiple updates for ref '%s' not allowed"),
2262 refnames
->items
[i
].string
);
2264 } else if (cmp
> 0) {
2265 BUG("ref_update_reject_duplicates() received unsorted list");
2271 static int run_transaction_hook(struct ref_transaction
*transaction
,
2274 struct child_process proc
= CHILD_PROCESS_INIT
;
2275 struct strbuf buf
= STRBUF_INIT
;
2279 hook
= find_hook("reference-transaction");
2283 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2285 proc
.stdout_to_stderr
= 1;
2286 proc
.trace2_hook_name
= "reference-transaction";
2288 ret
= start_command(&proc
);
2292 sigchain_push(SIGPIPE
, SIG_IGN
);
2294 for (i
= 0; i
< transaction
->nr
; i
++) {
2295 struct ref_update
*update
= transaction
->updates
[i
];
2298 strbuf_addf(&buf
, "%s %s %s\n",
2299 oid_to_hex(&update
->old_oid
),
2300 oid_to_hex(&update
->new_oid
),
2303 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2304 if (errno
!= EPIPE
) {
2305 /* Don't leak errno outside this API */
2314 sigchain_pop(SIGPIPE
);
2315 strbuf_release(&buf
);
2317 ret
|= finish_command(&proc
);
2321 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2324 struct ref_store
*refs
= transaction
->ref_store
;
2327 switch (transaction
->state
) {
2328 case REF_TRANSACTION_OPEN
:
2331 case REF_TRANSACTION_PREPARED
:
2332 BUG("prepare called twice on reference transaction");
2334 case REF_TRANSACTION_CLOSED
:
2335 BUG("prepare called on a closed reference transaction");
2338 BUG("unexpected reference transaction state");
2342 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2344 _("ref updates forbidden inside quarantine environment"));
2348 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2352 ret
= run_transaction_hook(transaction
, "prepared");
2354 ref_transaction_abort(transaction
, err
);
2355 die(_("ref updates aborted by hook"));
2361 int ref_transaction_abort(struct ref_transaction
*transaction
,
2364 struct ref_store
*refs
= transaction
->ref_store
;
2367 switch (transaction
->state
) {
2368 case REF_TRANSACTION_OPEN
:
2369 /* No need to abort explicitly. */
2371 case REF_TRANSACTION_PREPARED
:
2372 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2374 case REF_TRANSACTION_CLOSED
:
2375 BUG("abort called on a closed reference transaction");
2378 BUG("unexpected reference transaction state");
2382 run_transaction_hook(transaction
, "aborted");
2384 ref_transaction_free(transaction
);
2388 int ref_transaction_commit(struct ref_transaction
*transaction
,
2391 struct ref_store
*refs
= transaction
->ref_store
;
2394 switch (transaction
->state
) {
2395 case REF_TRANSACTION_OPEN
:
2396 /* Need to prepare first. */
2397 ret
= ref_transaction_prepare(transaction
, err
);
2401 case REF_TRANSACTION_PREPARED
:
2402 /* Fall through to finish. */
2404 case REF_TRANSACTION_CLOSED
:
2405 BUG("commit called on a closed reference transaction");
2408 BUG("unexpected reference transaction state");
2412 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2414 run_transaction_hook(transaction
, "committed");
2418 int refs_verify_refname_available(struct ref_store
*refs
,
2419 const char *refname
,
2420 const struct string_list
*extras
,
2421 const struct string_list
*skip
,
2425 const char *extra_refname
;
2426 struct strbuf dirname
= STRBUF_INIT
;
2427 struct strbuf referent
= STRBUF_INIT
;
2428 struct object_id oid
;
2430 struct ref_iterator
*iter
;
2435 * For the sake of comments in this function, suppose that
2436 * refname is "refs/foo/bar".
2441 strbuf_grow(&dirname
, strlen(refname
) + 1);
2442 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2444 * Just saying "Is a directory" when we e.g. can't
2445 * lock some multi-level ref isn't very informative,
2446 * the user won't be told *what* is a directory, so
2447 * let's not use strerror() below.
2450 /* Expand dirname to the new prefix, not including the trailing slash: */
2451 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2454 * We are still at a leading dir of the refname (e.g.,
2455 * "refs/foo"; if there is a reference with that name,
2456 * it is a conflict, *unless* it is in skip.
2458 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2461 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2462 &type
, &ignore_errno
)) {
2463 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2464 dirname
.buf
, refname
);
2468 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2469 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2470 refname
, dirname
.buf
);
2476 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2477 * There is no point in searching for a reference with that
2478 * name, because a refname isn't considered to conflict with
2479 * itself. But we still need to check for references whose
2480 * names are in the "refs/foo/bar/" namespace, because they
2483 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2484 strbuf_addch(&dirname
, '/');
2486 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2487 DO_FOR_EACH_INCLUDE_BROKEN
);
2488 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2490 string_list_has_string(skip
, iter
->refname
))
2493 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2494 iter
->refname
, refname
);
2495 ref_iterator_abort(iter
);
2499 if (ok
!= ITER_DONE
)
2500 BUG("error while iterating over references");
2502 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2504 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2505 refname
, extra_refname
);
2510 strbuf_release(&referent
);
2511 strbuf_release(&dirname
);
2515 struct do_for_each_reflog_help
{
2520 static int do_for_each_reflog_helper(struct repository
*r UNUSED
,
2521 const char *refname
,
2522 const struct object_id
*oid UNUSED
,
2526 struct do_for_each_reflog_help
*hp
= cb_data
;
2527 return hp
->fn(refname
, hp
->cb_data
);
2530 int refs_for_each_reflog(struct ref_store
*refs
, each_reflog_fn fn
, void *cb_data
)
2532 struct ref_iterator
*iter
;
2533 struct do_for_each_reflog_help hp
= { fn
, cb_data
};
2535 iter
= refs
->be
->reflog_iterator_begin(refs
);
2537 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2538 do_for_each_reflog_helper
, &hp
);
2541 int for_each_reflog(each_reflog_fn fn
, void *cb_data
)
2543 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2546 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2547 const char *refname
,
2548 each_reflog_ent_fn fn
,
2551 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2555 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2558 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2559 refname
, fn
, cb_data
);
2562 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2563 each_reflog_ent_fn fn
, void *cb_data
)
2565 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2568 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2571 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2575 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2577 return refs
->be
->reflog_exists(refs
, refname
);
2580 int reflog_exists(const char *refname
)
2582 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2585 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2588 return refs
->be
->create_reflog(refs
, refname
, err
);
2591 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2593 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2597 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2599 return refs
->be
->delete_reflog(refs
, refname
);
2602 int delete_reflog(const char *refname
)
2604 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2607 int refs_reflog_expire(struct ref_store
*refs
,
2608 const char *refname
,
2610 reflog_expiry_prepare_fn prepare_fn
,
2611 reflog_expiry_should_prune_fn should_prune_fn
,
2612 reflog_expiry_cleanup_fn cleanup_fn
,
2613 void *policy_cb_data
)
2615 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2616 prepare_fn
, should_prune_fn
,
2617 cleanup_fn
, policy_cb_data
);
2620 int reflog_expire(const char *refname
,
2622 reflog_expiry_prepare_fn prepare_fn
,
2623 reflog_expiry_should_prune_fn should_prune_fn
,
2624 reflog_expiry_cleanup_fn cleanup_fn
,
2625 void *policy_cb_data
)
2627 return refs_reflog_expire(get_main_ref_store(the_repository
),
2629 prepare_fn
, should_prune_fn
,
2630 cleanup_fn
, policy_cb_data
);
2633 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2636 struct ref_store
*refs
= transaction
->ref_store
;
2638 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2641 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2642 ref_transaction_for_each_queued_update_fn cb
,
2647 for (i
= 0; i
< transaction
->nr
; i
++) {
2648 struct ref_update
*update
= transaction
->updates
[i
];
2651 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2652 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2657 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2658 struct string_list
*refnames
, unsigned int flags
)
2660 struct ref_transaction
*transaction
;
2661 struct strbuf err
= STRBUF_INIT
;
2662 struct string_list_item
*item
;
2663 int ret
= 0, failures
= 0;
2669 msg
= normalize_reflog_message(logmsg
);
2672 * Since we don't check the references' old_oids, the
2673 * individual updates can't fail, so we can pack all of the
2674 * updates into a single transaction.
2676 transaction
= ref_store_transaction_begin(refs
, &err
);
2678 ret
= error("%s", err
.buf
);
2682 for_each_string_list_item(item
, refnames
) {
2683 ret
= ref_transaction_delete(transaction
, item
->string
,
2684 NULL
, flags
, msg
, &err
);
2686 warning(_("could not delete reference %s: %s"),
2687 item
->string
, err
.buf
);
2693 ret
= ref_transaction_commit(transaction
, &err
);
2695 if (refnames
->nr
== 1)
2696 error(_("could not delete reference %s: %s"),
2697 refnames
->items
[0].string
, err
.buf
);
2699 error(_("could not delete references: %s"), err
.buf
);
2703 if (!ret
&& failures
)
2705 ref_transaction_free(transaction
);
2706 strbuf_release(&err
);
2711 int delete_refs(const char *msg
, struct string_list
*refnames
,
2714 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2717 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2718 const char *newref
, const char *logmsg
)
2723 msg
= normalize_reflog_message(logmsg
);
2724 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2729 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2731 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2734 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2735 const char *newref
, const char *logmsg
)
2740 msg
= normalize_reflog_message(logmsg
);
2741 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2746 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2748 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);