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 struct ref_storage_be
*refs_backends
= &refs_be_files
;
38 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
40 struct ref_storage_be
*be
;
41 for (be
= refs_backends
; be
; be
= be
->next
)
42 if (!strcmp(be
->name
, name
))
48 * How to handle various characters in refnames:
49 * 0: An acceptable character for refs
51 * 2: ., look for a preceding . to reject .. in refs
52 * 3: {, look for a preceding @ to reject @{ in refs
53 * 4: A bad character: ASCII control characters, and
54 * ":", "?", "[", "\", "^", "~", SP, or TAB
55 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
57 static unsigned char refname_disposition
[256] = {
58 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
59 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
60 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
61 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
62 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
63 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
64 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
65 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
68 struct ref_namespace_info ref_namespace
[] = {
71 .decoration
= DECORATION_REF_HEAD
,
74 [NAMESPACE_BRANCHES
] = {
76 .decoration
= DECORATION_REF_LOCAL
,
80 .decoration
= DECORATION_REF_TAG
,
82 [NAMESPACE_REMOTE_REFS
] = {
84 * The default refspec for new remotes copies refs from
85 * refs/heads/ on the remote into refs/remotes/<remote>/.
86 * As such, "refs/remotes/" has special handling.
88 .ref
= "refs/remotes/",
89 .decoration
= DECORATION_REF_REMOTE
,
93 * The single ref "refs/stash" stores the latest stash.
94 * Older stashes can be found in the reflog.
98 .decoration
= DECORATION_REF_STASH
,
100 [NAMESPACE_REPLACE
] = {
102 * This namespace allows Git to act as if one object ID
103 * points to the content of another. Unlike the other
104 * ref namespaces, this one can be changed by the
105 * GIT_REPLACE_REF_BASE environment variable. This
106 * .namespace value will be overwritten in setup_git_env().
108 .ref
= "refs/replace/",
109 .decoration
= DECORATION_GRAFTED
,
111 [NAMESPACE_NOTES
] = {
113 * The refs/notes/commit ref points to the tip of a
114 * parallel commit history that adds metadata to commits
115 * in the normal history. This ref can be overwritten
116 * by the core.notesRef config variable or the
117 * GIT_NOTES_REFS environment variable.
119 .ref
= "refs/notes/commit",
122 [NAMESPACE_PREFETCH
] = {
124 * Prefetch refs are written by the background 'fetch'
125 * maintenance task. It allows faster foreground fetches
126 * by advertising these previously-downloaded tips without
127 * updating refs/remotes/ without user intervention.
129 .ref
= "refs/prefetch/",
131 [NAMESPACE_REWRITTEN
] = {
133 * Rewritten refs are used by the 'label' command in the
134 * sequencer. These are particularly useful during an
135 * interactive rebase that uses the 'merge' command.
137 .ref
= "refs/rewritten/",
141 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
143 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
144 if (info
->ref_updated
)
147 info
->ref_updated
= 1;
151 * Try to read one refname component from the front of refname.
152 * Return the length of the component found, or -1 if the component is
153 * not legal. It is legal if it is something reasonable to have under
154 * ".git/refs/"; We do not like it if:
156 * - it begins with ".", or
157 * - it has double dots "..", or
158 * - it has ASCII control characters, or
159 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
160 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
161 * - it ends with a "/", or
162 * - it ends with ".lock", or
163 * - it contains a "@{" portion
165 * When sanitized is not NULL, instead of rejecting the input refname
166 * as an error, try to come up with a usable replacement for the input
169 static int check_refname_component(const char *refname
, int *flags
,
170 struct strbuf
*sanitized
)
174 size_t component_start
= 0; /* garbage - not a reasonable initial value */
177 component_start
= sanitized
->len
;
179 for (cp
= refname
; ; cp
++) {
181 unsigned char disp
= refname_disposition
[ch
];
183 if (sanitized
&& disp
!= 1)
184 strbuf_addch(sanitized
, ch
);
190 if (last
== '.') { /* Refname contains "..". */
192 /* collapse ".." to single "." */
193 strbuf_setlen(sanitized
, sanitized
->len
- 1);
199 if (last
== '@') { /* Refname contains "@{". */
201 sanitized
->buf
[sanitized
->len
-1] = '-';
209 sanitized
->buf
[sanitized
->len
-1] = '-';
214 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
215 /* refspec can't be a pattern */
217 sanitized
->buf
[sanitized
->len
-1] = '-';
223 * Unset the pattern flag so that we only accept
224 * a single asterisk for one side of refspec.
226 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
233 return 0; /* Component has zero length. */
235 if (refname
[0] == '.') { /* Component starts with '.'. */
237 sanitized
->buf
[component_start
] = '-';
241 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
242 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
245 /* Refname ends with ".lock". */
246 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
247 /* try again in case we have .lock.lock */
253 static int check_or_sanitize_refname(const char *refname
, int flags
,
254 struct strbuf
*sanitized
)
256 int component_len
, component_count
= 0;
258 if (!strcmp(refname
, "@")) {
259 /* Refname is a single character '@'. */
261 strbuf_addch(sanitized
, '-');
267 if (sanitized
&& sanitized
->len
)
268 strbuf_complete(sanitized
, '/');
270 /* We are at the start of a path component. */
271 component_len
= check_refname_component(refname
, &flags
,
273 if (sanitized
&& component_len
== 0)
274 ; /* OK, omit empty component */
275 else if (component_len
<= 0)
279 if (refname
[component_len
] == '\0')
281 /* Skip to next component. */
282 refname
+= component_len
+ 1;
285 if (refname
[component_len
- 1] == '.') {
286 /* Refname ends with '.'. */
288 ; /* omit ending dot */
292 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
293 return -1; /* Refname has only one component. */
297 int check_refname_format(const char *refname
, int flags
)
299 return check_or_sanitize_refname(refname
, flags
, NULL
);
302 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
304 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
305 BUG("sanitizing refname '%s' check returned error", refname
);
308 int refname_is_safe(const char *refname
)
312 if (skip_prefix(refname
, "refs/", &rest
)) {
315 size_t restlen
= strlen(rest
);
317 /* rest must not be empty, or start or end with "/" */
318 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
322 * Does the refname try to escape refs/?
323 * For example: refs/foo/../bar is safe but refs/foo/../../bar
326 buf
= xmallocz(restlen
);
327 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
333 if (!isupper(*refname
) && *refname
!= '_')
341 * Return true if refname, which has the specified oid and flags, can
342 * be resolved to an object in the database. If the referred-to object
343 * does not exist, emit a warning and return false.
345 int ref_resolves_to_object(const char *refname
,
346 struct repository
*repo
,
347 const struct object_id
*oid
,
350 if (flags
& REF_ISBROKEN
)
352 if (!repo_has_object_file(repo
, oid
)) {
353 error(_("%s does not point to a valid object!"), refname
);
359 char *refs_resolve_refdup(struct ref_store
*refs
,
360 const char *refname
, int resolve_flags
,
361 struct object_id
*oid
, int *flags
)
365 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
367 return xstrdup_or_null(result
);
370 char *resolve_refdup(const char *refname
, int resolve_flags
,
371 struct object_id
*oid
, int *flags
)
373 return refs_resolve_refdup(get_main_ref_store(the_repository
),
374 refname
, resolve_flags
,
378 /* The argument to for_each_filter_refs */
379 struct for_each_ref_filter
{
386 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
388 struct ref_store
*refs
= get_main_ref_store(the_repository
);
390 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
396 int read_ref(const char *refname
, struct object_id
*oid
)
398 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
401 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
403 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
407 int ref_exists(const char *refname
)
409 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
412 static int for_each_filter_refs(const char *refname
,
413 const struct object_id
*oid
,
414 int flags
, void *data
)
416 struct for_each_ref_filter
*filter
= data
;
418 if (wildmatch(filter
->pattern
, refname
, 0))
421 skip_prefix(refname
, filter
->prefix
, &refname
);
422 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
425 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
427 struct object
*o
= lookup_unknown_object(the_repository
, name
);
429 if (o
->type
== OBJ_NONE
) {
430 int type
= oid_object_info(the_repository
, name
, NULL
);
431 if (type
< 0 || !object_as_type(o
, type
, 0))
435 if (o
->type
!= OBJ_TAG
)
438 o
= deref_tag_noverify(o
);
442 oidcpy(oid
, &o
->oid
);
446 struct warn_if_dangling_data
{
449 const struct string_list
*refnames
;
453 static int warn_if_dangling_symref(const char *refname
,
454 const struct object_id
*oid UNUSED
,
455 int flags
, void *cb_data
)
457 struct warn_if_dangling_data
*d
= cb_data
;
458 const char *resolves_to
;
460 if (!(flags
& REF_ISSYMREF
))
463 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
466 ? strcmp(resolves_to
, d
->refname
)
467 : !string_list_has_string(d
->refnames
, resolves_to
))) {
471 fprintf(d
->fp
, d
->msg_fmt
, refname
);
476 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
478 struct warn_if_dangling_data data
;
481 data
.refname
= refname
;
482 data
.refnames
= NULL
;
483 data
.msg_fmt
= msg_fmt
;
484 for_each_rawref(warn_if_dangling_symref
, &data
);
487 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
489 struct warn_if_dangling_data data
;
493 data
.refnames
= refnames
;
494 data
.msg_fmt
= msg_fmt
;
495 for_each_rawref(warn_if_dangling_symref
, &data
);
498 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
500 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
503 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
505 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
508 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
510 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
513 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
515 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
518 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
520 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
523 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
525 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
528 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
530 struct strbuf buf
= STRBUF_INIT
;
532 struct object_id oid
;
535 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
536 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
537 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
538 strbuf_release(&buf
);
543 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
546 struct strbuf normalized_pattern
= STRBUF_INIT
;
549 BUG("pattern must not start with '/'");
552 strbuf_addstr(&normalized_pattern
, prefix
);
553 else if (!starts_with(pattern
, "refs/") &&
554 strcmp(pattern
, "HEAD"))
555 strbuf_addstr(&normalized_pattern
, "refs/");
557 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
561 strbuf_addstr(&normalized_pattern
, pattern
);
562 strbuf_strip_suffix(&normalized_pattern
, "/");
564 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
565 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
566 strbuf_release(&normalized_pattern
);
569 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
570 const char *prefix
, void *cb_data
)
572 struct strbuf real_pattern
= STRBUF_INIT
;
573 struct for_each_ref_filter filter
;
576 if (!prefix
&& !starts_with(pattern
, "refs/"))
577 strbuf_addstr(&real_pattern
, "refs/");
579 strbuf_addstr(&real_pattern
, prefix
);
580 strbuf_addstr(&real_pattern
, pattern
);
582 if (!has_glob_specials(pattern
)) {
583 /* Append implied '/' '*' if not present. */
584 strbuf_complete(&real_pattern
, '/');
585 /* No need to check for '*', there is none. */
586 strbuf_addch(&real_pattern
, '*');
589 filter
.pattern
= real_pattern
.buf
;
590 filter
.prefix
= prefix
;
592 filter
.cb_data
= cb_data
;
593 ret
= for_each_ref(for_each_filter_refs
, &filter
);
595 strbuf_release(&real_pattern
);
599 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
601 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
604 const char *prettify_refname(const char *name
)
606 if (skip_prefix(name
, "refs/heads/", &name
) ||
607 skip_prefix(name
, "refs/tags/", &name
) ||
608 skip_prefix(name
, "refs/remotes/", &name
))
613 static const char *ref_rev_parse_rules
[] = {
619 "refs/remotes/%.*s/HEAD",
623 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
626 * Is it possible that the caller meant full_name with abbrev_name?
627 * If so return a non-zero value to signal "yes"; the magnitude of
628 * the returned value gives the precedence used for disambiguation.
630 * If abbrev_name cannot mean full_name, return 0.
632 int refname_match(const char *abbrev_name
, const char *full_name
)
635 const int abbrev_name_len
= strlen(abbrev_name
);
636 const int num_rules
= NUM_REV_PARSE_RULES
;
638 for (p
= ref_rev_parse_rules
; *p
; p
++)
639 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
640 return &ref_rev_parse_rules
[num_rules
] - p
;
646 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
647 * the results to 'prefixes'
649 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
652 int len
= strlen(prefix
);
654 for (p
= ref_rev_parse_rules
; *p
; p
++)
655 strvec_pushf(prefixes
, *p
, len
, prefix
);
658 static const char default_branch_name_advice
[] = N_(
659 "Using '%s' as the name for the initial branch. This default branch name\n"
660 "is subject to change. To configure the initial branch name to use in all\n"
661 "of your new repositories, which will suppress this warning, call:\n"
663 "\tgit config --global init.defaultBranch <name>\n"
665 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
666 "'development'. The just-created branch can be renamed via this command:\n"
668 "\tgit branch -m <name>\n"
671 char *repo_default_branch_name(struct repository
*r
, int quiet
)
673 const char *config_key
= "init.defaultbranch";
674 const char *config_display_key
= "init.defaultBranch";
675 char *ret
= NULL
, *full_ref
;
676 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
680 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
681 die(_("could not retrieve `%s`"), config_display_key
);
684 ret
= xstrdup("master");
686 advise(_(default_branch_name_advice
), ret
);
689 full_ref
= xstrfmt("refs/heads/%s", ret
);
690 if (check_refname_format(full_ref
, 0))
691 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
697 const char *git_default_branch_name(int quiet
)
702 ret
= repo_default_branch_name(the_repository
, quiet
);
708 * *string and *len will only be substituted, and *string returned (for
709 * later free()ing) if the string passed in is a magic short-hand form
712 static char *substitute_branch_name(struct repository
*r
,
713 const char **string
, int *len
,
714 int nonfatal_dangling_mark
)
716 struct strbuf buf
= STRBUF_INIT
;
717 struct interpret_branch_name_options options
= {
718 .nonfatal_dangling_mark
= nonfatal_dangling_mark
720 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
724 *string
= strbuf_detach(&buf
, &size
);
726 return (char *)*string
;
732 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
733 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
735 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
736 nonfatal_dangling_mark
);
737 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
742 int expand_ref(struct repository
*repo
, const char *str
, int len
,
743 struct object_id
*oid
, char **ref
)
747 struct strbuf fullref
= STRBUF_INIT
;
750 for (p
= ref_rev_parse_rules
; *p
; p
++) {
751 struct object_id oid_from_ref
;
752 struct object_id
*this_result
;
754 struct ref_store
*refs
= get_main_ref_store(repo
);
756 this_result
= refs_found
? &oid_from_ref
: oid
;
757 strbuf_reset(&fullref
);
758 strbuf_addf(&fullref
, *p
, len
, str
);
759 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
765 if (!warn_ambiguous_refs
)
767 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
768 warning(_("ignoring dangling symref %s"), fullref
.buf
);
769 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
770 warning(_("ignoring broken ref %s"), fullref
.buf
);
773 strbuf_release(&fullref
);
777 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
778 struct object_id
*oid
, char **log
)
780 struct ref_store
*refs
= get_main_ref_store(r
);
781 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
784 struct strbuf path
= STRBUF_INIT
;
787 for (p
= ref_rev_parse_rules
; *p
; p
++) {
788 struct object_id hash
;
789 const char *ref
, *it
;
792 strbuf_addf(&path
, *p
, len
, str
);
793 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
795 oid
? &hash
: NULL
, NULL
);
798 if (refs_reflog_exists(refs
, path
.buf
))
800 else if (strcmp(ref
, path
.buf
) &&
801 refs_reflog_exists(refs
, ref
))
810 if (!warn_ambiguous_refs
)
813 strbuf_release(&path
);
818 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
820 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
823 int is_per_worktree_ref(const char *refname
)
825 return starts_with(refname
, "refs/worktree/") ||
826 starts_with(refname
, "refs/bisect/") ||
827 starts_with(refname
, "refs/rewritten/");
830 static int is_pseudoref_syntax(const char *refname
)
834 for (c
= refname
; *c
; c
++) {
835 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
840 * HEAD is not a pseudoref, but it certainly uses the
846 static int is_current_worktree_ref(const char *ref
) {
847 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
850 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
851 const char **worktree_name
, int *worktree_name_length
,
852 const char **bare_refname
)
854 const char *name_dummy
;
855 int name_length_dummy
;
856 const char *ref_dummy
;
859 worktree_name
= &name_dummy
;
860 if (!worktree_name_length
)
861 worktree_name_length
= &name_length_dummy
;
863 bare_refname
= &ref_dummy
;
865 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
866 const char *slash
= strchr(*bare_refname
, '/');
868 *worktree_name
= *bare_refname
;
870 *worktree_name_length
= strlen(*worktree_name
);
872 /* This is an error condition, and the caller tell because the bare_refname is "" */
873 *bare_refname
= *worktree_name
+ *worktree_name_length
;
874 return REF_WORKTREE_OTHER
;
877 *worktree_name_length
= slash
- *bare_refname
;
878 *bare_refname
= slash
+ 1;
880 if (is_current_worktree_ref(*bare_refname
))
881 return REF_WORKTREE_OTHER
;
884 *worktree_name
= NULL
;
885 *worktree_name_length
= 0;
887 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
888 && is_current_worktree_ref(*bare_refname
))
889 return REF_WORKTREE_MAIN
;
891 *bare_refname
= maybe_worktree_ref
;
892 if (is_current_worktree_ref(maybe_worktree_ref
))
893 return REF_WORKTREE_CURRENT
;
895 return REF_WORKTREE_SHARED
;
898 long get_files_ref_lock_timeout_ms(void)
900 static int configured
= 0;
902 /* The default timeout is 100 ms: */
903 static int timeout_ms
= 100;
906 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
913 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
915 const struct object_id
*old_oid
,
918 struct ref_transaction
*transaction
;
919 struct strbuf err
= STRBUF_INIT
;
921 transaction
= ref_store_transaction_begin(refs
, &err
);
923 ref_transaction_delete(transaction
, refname
, old_oid
,
925 ref_transaction_commit(transaction
, &err
)) {
926 error("%s", err
.buf
);
927 ref_transaction_free(transaction
);
928 strbuf_release(&err
);
931 ref_transaction_free(transaction
);
932 strbuf_release(&err
);
936 int delete_ref(const char *msg
, const char *refname
,
937 const struct object_id
*old_oid
, unsigned int flags
)
939 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
943 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
948 while ((c
= *msg
++)) {
949 if (wasspace
&& isspace(c
))
951 wasspace
= isspace(c
);
959 static char *normalize_reflog_message(const char *msg
)
961 struct strbuf sb
= STRBUF_INIT
;
964 copy_reflog_msg(&sb
, msg
);
965 return strbuf_detach(&sb
, NULL
);
968 int should_autocreate_reflog(const char *refname
)
970 switch (log_all_ref_updates
) {
971 case LOG_REFS_ALWAYS
:
973 case LOG_REFS_NORMAL
:
974 return starts_with(refname
, "refs/heads/") ||
975 starts_with(refname
, "refs/remotes/") ||
976 starts_with(refname
, "refs/notes/") ||
977 !strcmp(refname
, "HEAD");
983 int is_branch(const char *refname
)
985 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
988 struct read_ref_at_cb
{
993 struct object_id
*oid
;
996 struct object_id ooid
;
997 struct object_id noid
;
1001 timestamp_t
*cutoff_time
;
1006 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
1007 timestamp_t timestamp
, int tz
, const char *message
)
1010 *cb
->msg
= xstrdup(message
);
1011 if (cb
->cutoff_time
)
1012 *cb
->cutoff_time
= timestamp
;
1014 *cb
->cutoff_tz
= tz
;
1016 *cb
->cutoff_cnt
= cb
->reccnt
;
1019 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1020 const char *email UNUSED
,
1021 timestamp_t timestamp
, int tz
,
1022 const char *message
, void *cb_data
)
1024 struct read_ref_at_cb
*cb
= cb_data
;
1028 cb
->date
= timestamp
;
1031 * It is not possible for cb->cnt == 0 on the first iteration because
1032 * that special case is handled in read_ref_at().
1036 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
1037 if (timestamp
<= cb
->at_time
|| reached_count
) {
1038 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1040 * we have not yet updated cb->[n|o]oid so they still
1041 * hold the values for the previous record.
1043 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
1044 warning(_("log for ref %s has gap after %s"),
1045 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1047 oidcpy(cb
->oid
, ooid
);
1048 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
1049 oidcpy(cb
->oid
, noid
);
1050 else if (!oideq(noid
, cb
->oid
))
1051 warning(_("log for ref %s unexpectedly ended on %s"),
1052 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1053 DATE_MODE(RFC2822
)));
1057 oidcpy(&cb
->ooid
, ooid
);
1058 oidcpy(&cb
->noid
, noid
);
1059 return cb
->found_it
;
1062 static int read_ref_at_ent_newest(struct object_id
*ooid UNUSED
,
1063 struct object_id
*noid
,
1064 const char *email UNUSED
,
1065 timestamp_t timestamp
, int tz
,
1066 const char *message
, void *cb_data
)
1068 struct read_ref_at_cb
*cb
= cb_data
;
1070 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1071 oidcpy(cb
->oid
, noid
);
1072 /* We just want the first entry */
1076 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1077 const char *email UNUSED
,
1078 timestamp_t timestamp
, int tz
,
1079 const char *message
, void *cb_data
)
1081 struct read_ref_at_cb
*cb
= cb_data
;
1083 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1084 oidcpy(cb
->oid
, ooid
);
1085 if (is_null_oid(cb
->oid
))
1086 oidcpy(cb
->oid
, noid
);
1087 /* We just want the first entry */
1091 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1092 unsigned int flags
, timestamp_t at_time
, int cnt
,
1093 struct object_id
*oid
, char **msg
,
1094 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1096 struct read_ref_at_cb cb
;
1098 memset(&cb
, 0, sizeof(cb
));
1099 cb
.refname
= refname
;
1100 cb
.at_time
= at_time
;
1103 cb
.cutoff_time
= cutoff_time
;
1104 cb
.cutoff_tz
= cutoff_tz
;
1105 cb
.cutoff_cnt
= cutoff_cnt
;
1109 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
1113 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1116 if (flags
& GET_OID_QUIETLY
)
1119 die(_("log for %s is empty"), refname
);
1124 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1129 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1132 struct ref_transaction
*tr
;
1135 CALLOC_ARRAY(tr
, 1);
1136 tr
->ref_store
= refs
;
1140 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1142 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1145 void ref_transaction_free(struct ref_transaction
*transaction
)
1152 switch (transaction
->state
) {
1153 case REF_TRANSACTION_OPEN
:
1154 case REF_TRANSACTION_CLOSED
:
1157 case REF_TRANSACTION_PREPARED
:
1158 BUG("free called on a prepared reference transaction");
1161 BUG("unexpected reference transaction state");
1165 for (i
= 0; i
< transaction
->nr
; i
++) {
1166 free(transaction
->updates
[i
]->msg
);
1167 free(transaction
->updates
[i
]);
1169 free(transaction
->updates
);
1173 struct ref_update
*ref_transaction_add_update(
1174 struct ref_transaction
*transaction
,
1175 const char *refname
, unsigned int flags
,
1176 const struct object_id
*new_oid
,
1177 const struct object_id
*old_oid
,
1180 struct ref_update
*update
;
1182 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1183 BUG("update called for transaction that is not open");
1185 FLEX_ALLOC_STR(update
, refname
, refname
);
1186 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1187 transaction
->updates
[transaction
->nr
++] = update
;
1189 update
->flags
= flags
;
1191 if (flags
& REF_HAVE_NEW
)
1192 oidcpy(&update
->new_oid
, new_oid
);
1193 if (flags
& REF_HAVE_OLD
)
1194 oidcpy(&update
->old_oid
, old_oid
);
1195 update
->msg
= normalize_reflog_message(msg
);
1199 int ref_transaction_update(struct ref_transaction
*transaction
,
1200 const char *refname
,
1201 const struct object_id
*new_oid
,
1202 const struct object_id
*old_oid
,
1203 unsigned int flags
, const char *msg
,
1208 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1209 ((new_oid
&& !is_null_oid(new_oid
)) ?
1210 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1211 !refname_is_safe(refname
))) {
1212 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1217 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1218 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1221 * Clear flags outside the allowed set; this should be a noop because
1222 * of the BUG() check above, but it works around a -Wnonnull warning
1223 * with some versions of "gcc -O3".
1225 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1227 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1229 ref_transaction_add_update(transaction
, refname
, flags
,
1230 new_oid
, old_oid
, msg
);
1234 int ref_transaction_create(struct ref_transaction
*transaction
,
1235 const char *refname
,
1236 const struct object_id
*new_oid
,
1237 unsigned int flags
, const char *msg
,
1240 if (!new_oid
|| is_null_oid(new_oid
)) {
1241 strbuf_addf(err
, "'%s' has a null OID", refname
);
1244 return ref_transaction_update(transaction
, refname
, new_oid
,
1245 null_oid(), flags
, msg
, err
);
1248 int ref_transaction_delete(struct ref_transaction
*transaction
,
1249 const char *refname
,
1250 const struct object_id
*old_oid
,
1251 unsigned int flags
, const char *msg
,
1254 if (old_oid
&& is_null_oid(old_oid
))
1255 BUG("delete called with old_oid set to zeros");
1256 return ref_transaction_update(transaction
, refname
,
1257 null_oid(), old_oid
,
1261 int ref_transaction_verify(struct ref_transaction
*transaction
,
1262 const char *refname
,
1263 const struct object_id
*old_oid
,
1268 BUG("verify called with old_oid set to NULL");
1269 return ref_transaction_update(transaction
, refname
,
1274 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1275 const char *refname
, const struct object_id
*new_oid
,
1276 const struct object_id
*old_oid
, unsigned int flags
,
1277 enum action_on_err onerr
)
1279 struct ref_transaction
*t
= NULL
;
1280 struct strbuf err
= STRBUF_INIT
;
1283 t
= ref_store_transaction_begin(refs
, &err
);
1285 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1287 ref_transaction_commit(t
, &err
)) {
1289 ref_transaction_free(t
);
1292 const char *str
= _("update_ref failed for ref '%s': %s");
1295 case UPDATE_REFS_MSG_ON_ERR
:
1296 error(str
, refname
, err
.buf
);
1298 case UPDATE_REFS_DIE_ON_ERR
:
1299 die(str
, refname
, err
.buf
);
1301 case UPDATE_REFS_QUIET_ON_ERR
:
1304 strbuf_release(&err
);
1307 strbuf_release(&err
);
1309 ref_transaction_free(t
);
1313 int update_ref(const char *msg
, const char *refname
,
1314 const struct object_id
*new_oid
,
1315 const struct object_id
*old_oid
,
1316 unsigned int flags
, enum action_on_err onerr
)
1318 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1319 old_oid
, flags
, onerr
);
1323 * Check that the string refname matches a rule of the form
1324 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1325 * "foo/%.*s/baz", and return the string "bar".
1327 static const char *match_parse_rule(const char *refname
, const char *rule
,
1331 * Check that rule matches refname up to the first percent in the rule.
1332 * We can bail immediately if not, but otherwise we leave "rule" at the
1333 * %-placeholder, and "refname" at the start of the potential matched
1336 while (*rule
!= '%') {
1338 BUG("rev-parse rule did not have percent");
1339 if (*refname
++ != *rule
++)
1344 * Check that our "%" is the expected placeholder. This assumes there
1345 * are no other percents (placeholder or quoted) in the string, but
1346 * that is sufficient for our rev-parse rules.
1348 if (!skip_prefix(rule
, "%.*s", &rule
))
1352 * And now check that our suffix (if any) matches.
1354 if (!strip_suffix(refname
, rule
, len
))
1357 return refname
; /* len set by strip_suffix() */
1360 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1361 const char *refname
, int strict
)
1364 struct strbuf resolved_buf
= STRBUF_INIT
;
1366 /* skip first rule, it will always match */
1367 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1369 int rules_to_fail
= i
;
1370 const char *short_name
;
1371 size_t short_name_len
;
1373 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1379 * in strict mode, all (except the matched one) rules
1380 * must fail to resolve to a valid non-ambiguous ref
1383 rules_to_fail
= NUM_REV_PARSE_RULES
;
1386 * check if the short name resolves to a valid ref,
1387 * but use only rules prior to the matched one
1389 for (j
= 0; j
< rules_to_fail
; j
++) {
1390 const char *rule
= ref_rev_parse_rules
[j
];
1392 /* skip matched rule */
1397 * the short name is ambiguous, if it resolves
1398 * (with this previous rule) to a valid ref
1399 * read_ref() returns 0 on success
1401 strbuf_reset(&resolved_buf
);
1402 strbuf_addf(&resolved_buf
, rule
,
1403 cast_size_t_to_int(short_name_len
),
1405 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1410 * short name is non-ambiguous if all previous rules
1411 * haven't resolved to a valid ref
1413 if (j
== rules_to_fail
) {
1414 strbuf_release(&resolved_buf
);
1415 return xmemdupz(short_name
, short_name_len
);
1419 strbuf_release(&resolved_buf
);
1420 return xstrdup(refname
);
1423 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1425 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1429 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1430 struct strvec
*hide_refs
)
1433 if (!strcmp("transfer.hiderefs", var
) ||
1434 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1435 !strcmp(key
, "hiderefs"))) {
1440 return config_error_nonbool(var
);
1442 /* drop const to remove trailing '/' characters */
1443 ref
= (char *)strvec_push(hide_refs
, value
);
1445 while (len
&& ref
[len
- 1] == '/')
1451 int ref_is_hidden(const char *refname
, const char *refname_full
,
1452 const struct strvec
*hide_refs
)
1456 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1457 const char *match
= hide_refs
->v
[i
];
1458 const char *subject
;
1462 if (*match
== '!') {
1467 if (*match
== '^') {
1468 subject
= refname_full
;
1474 /* refname can be NULL when namespaces are used. */
1476 skip_prefix(subject
, match
, &p
) &&
1483 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1485 const char **pattern
;
1486 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1488 * We can't feed any excludes from hidden refs config
1489 * sections, since later rules may override previous
1490 * ones. For example, with rules "refs/foo" and
1491 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1492 * everything underneath it), but the earlier exclusion
1493 * would cause us to skip all of "refs/foo". We
1494 * likewise don't implement the namespace stripping
1495 * required for '^' rules.
1497 * Both are possible to do, but complicated, so avoid
1498 * populating the jump list at all if we see either of
1501 if (**pattern
== '!' || **pattern
== '^')
1504 return hide_refs
->v
;
1507 const char *find_descendant_ref(const char *dirname
,
1508 const struct string_list
*extras
,
1509 const struct string_list
*skip
)
1517 * Look at the place where dirname would be inserted into
1518 * extras. If there is an entry at that position that starts
1519 * with dirname (remember, dirname includes the trailing
1520 * slash) and is not in skip, then we have a conflict.
1522 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1523 pos
< extras
->nr
; pos
++) {
1524 const char *extra_refname
= extras
->items
[pos
].string
;
1526 if (!starts_with(extra_refname
, dirname
))
1529 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1530 return extra_refname
;
1535 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1537 struct object_id oid
;
1540 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1542 return fn("HEAD", &oid
, flag
, cb_data
);
1547 int head_ref(each_ref_fn fn
, void *cb_data
)
1549 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1552 struct ref_iterator
*refs_ref_iterator_begin(
1553 struct ref_store
*refs
,
1555 const char **exclude_patterns
,
1557 enum do_for_each_ref_flags flags
)
1559 struct ref_iterator
*iter
;
1561 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1562 static int ref_paranoia
= -1;
1564 if (ref_paranoia
< 0)
1565 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1567 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1568 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1572 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1574 * `iterator_begin()` already takes care of prefix, but we
1575 * might need to do some trimming:
1578 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1580 /* Sanity check for subclasses: */
1582 BUG("reference iterator is not ordered");
1588 * Call fn for each reference in the specified submodule for which the
1589 * refname begins with prefix. If trim is non-zero, then trim that
1590 * many characters off the beginning of each refname before passing
1591 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1592 * include broken references in the iteration. If fn ever returns a
1593 * non-zero value, stop the iteration and return that value;
1594 * otherwise, return 0.
1596 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1597 each_repo_ref_fn fn
, int trim
, int flags
,
1600 struct ref_iterator
*iter
;
1601 struct ref_store
*refs
= get_main_ref_store(r
);
1606 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1608 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1611 struct do_for_each_ref_help
{
1616 static int do_for_each_ref_helper(struct repository
*r UNUSED
,
1617 const char *refname
,
1618 const struct object_id
*oid
,
1622 struct do_for_each_ref_help
*hp
= cb_data
;
1624 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1627 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1628 const char **exclude_patterns
,
1629 each_ref_fn fn
, int trim
,
1630 enum do_for_each_ref_flags flags
, void *cb_data
)
1632 struct ref_iterator
*iter
;
1633 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1638 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1641 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1642 do_for_each_ref_helper
, &hp
);
1645 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1647 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1650 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1652 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1655 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1656 each_ref_fn fn
, void *cb_data
)
1658 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1661 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1663 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1666 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1668 return do_for_each_ref(get_main_ref_store(the_repository
),
1669 prefix
, NULL
, fn
, 0, 0, cb_data
);
1672 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1673 const char **exclude_patterns
,
1674 each_ref_fn fn
, void *cb_data
)
1676 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1679 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1681 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1682 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1683 strlen(git_replace_ref_base
),
1684 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1687 int for_each_namespaced_ref(const char **exclude_patterns
,
1688 each_ref_fn fn
, void *cb_data
)
1690 struct strbuf buf
= STRBUF_INIT
;
1692 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1693 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1694 buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1695 strbuf_release(&buf
);
1699 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1701 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1702 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1705 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1707 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1710 static int qsort_strcmp(const void *va
, const void *vb
)
1712 const char *a
= *(const char **)va
;
1713 const char *b
= *(const char **)vb
;
1715 return strcmp(a
, b
);
1718 static void find_longest_prefixes_1(struct string_list
*out
,
1719 struct strbuf
*prefix
,
1720 const char **patterns
, size_t nr
)
1724 for (i
= 0; i
< nr
; i
++) {
1725 char c
= patterns
[i
][prefix
->len
];
1726 if (!c
|| is_glob_special(c
)) {
1727 string_list_append(out
, prefix
->buf
);
1737 * Set "end" to the index of the element _after_ the last one
1740 for (end
= i
+ 1; end
< nr
; end
++) {
1741 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1745 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1746 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1747 strbuf_setlen(prefix
, prefix
->len
- 1);
1753 static void find_longest_prefixes(struct string_list
*out
,
1754 const char **patterns
)
1756 struct strvec sorted
= STRVEC_INIT
;
1757 struct strbuf prefix
= STRBUF_INIT
;
1759 strvec_pushv(&sorted
, patterns
);
1760 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1762 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1764 strvec_clear(&sorted
);
1765 strbuf_release(&prefix
);
1768 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1769 const char *namespace,
1770 const char **patterns
,
1771 const char **exclude_patterns
,
1772 each_ref_fn fn
, void *cb_data
)
1774 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1775 struct string_list_item
*prefix
;
1776 struct strbuf buf
= STRBUF_INIT
;
1777 int ret
= 0, namespace_len
;
1779 find_longest_prefixes(&prefixes
, patterns
);
1782 strbuf_addstr(&buf
, namespace);
1783 namespace_len
= buf
.len
;
1785 for_each_string_list_item(prefix
, &prefixes
) {
1786 strbuf_addstr(&buf
, prefix
->string
);
1787 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1788 exclude_patterns
, fn
, cb_data
);
1791 strbuf_setlen(&buf
, namespace_len
);
1794 string_list_clear(&prefixes
, 0);
1795 strbuf_release(&buf
);
1799 static int refs_read_special_head(struct ref_store
*ref_store
,
1800 const char *refname
, struct object_id
*oid
,
1801 struct strbuf
*referent
, unsigned int *type
,
1804 struct strbuf full_path
= STRBUF_INIT
;
1805 struct strbuf content
= STRBUF_INIT
;
1807 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1809 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1810 *failure_errno
= errno
;
1814 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1818 strbuf_release(&full_path
);
1819 strbuf_release(&content
);
1823 static int is_special_ref(const char *refname
)
1826 * Special references get written and read directly via the filesystem
1827 * by the subsystems that create them. Thus, they must not go through
1828 * the reference backend but must instead be read directly. It is
1829 * arguable whether this behaviour is sensible, or whether it's simply
1830 * a leaky abstraction enabled by us only having a single reference
1831 * backend implementation. But at least for a subset of references it
1832 * indeed does make sense to treat them specially:
1834 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1835 * carries additional metadata like where it came from.
1837 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1840 * There are some exceptions that you might expect to see on this list
1841 * but which are handled exclusively via the reference backend:
1843 * - BISECT_EXPECTED_REV
1845 * - CHERRY_PICK_HEAD
1851 * - "rebase-apply/" and "rebase-merge/" contain all of the state for
1852 * rebases, including some reference-like files. These are
1853 * exclusively read and written via the filesystem and never go
1854 * through the refdb.
1856 * Writing or deleting references must consistently go either through
1857 * the filesystem (special refs) or through the reference backend
1860 static const char * const special_refs
[] = {
1868 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1869 if (!strcmp(refname
, special_refs
[i
]))
1875 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1876 struct object_id
*oid
, struct strbuf
*referent
,
1877 unsigned int *type
, int *failure_errno
)
1879 assert(failure_errno
);
1880 if (is_special_ref(refname
))
1881 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1882 type
, failure_errno
);
1884 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1885 type
, failure_errno
);
1888 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1889 struct strbuf
*referent
)
1891 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1894 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1895 const char *refname
,
1897 struct object_id
*oid
,
1900 static struct strbuf sb_refname
= STRBUF_INIT
;
1901 struct object_id unused_oid
;
1908 flags
= &unused_flags
;
1912 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1913 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1914 !refname_is_safe(refname
))
1918 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1919 * missing refs and refs that were present but invalid,
1920 * to complain about the latter to stderr.
1922 * We don't know whether the ref exists, so don't set
1925 *flags
|= REF_BAD_NAME
;
1928 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1929 unsigned int read_flags
= 0;
1932 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1933 &read_flags
, &failure_errno
)) {
1934 *flags
|= read_flags
;
1936 /* In reading mode, refs must eventually resolve */
1937 if (resolve_flags
& RESOLVE_REF_READING
)
1941 * Otherwise a missing ref is OK. But the files backend
1942 * may show errors besides ENOENT if there are
1943 * similarly-named refs.
1945 if (failure_errno
!= ENOENT
&&
1946 failure_errno
!= EISDIR
&&
1947 failure_errno
!= ENOTDIR
)
1951 if (*flags
& REF_BAD_NAME
)
1952 *flags
|= REF_ISBROKEN
;
1956 *flags
|= read_flags
;
1958 if (!(read_flags
& REF_ISSYMREF
)) {
1959 if (*flags
& REF_BAD_NAME
) {
1961 *flags
|= REF_ISBROKEN
;
1966 refname
= sb_refname
.buf
;
1967 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1971 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1972 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1973 !refname_is_safe(refname
))
1976 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1983 /* backend functions */
1984 int refs_init_db(struct strbuf
*err
)
1986 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1988 return refs
->be
->init_db(refs
, err
);
1991 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1992 struct object_id
*oid
, int *flags
)
1994 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1995 resolve_flags
, oid
, flags
);
1998 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1999 struct object_id
*oid
)
2001 struct ref_store
*refs
;
2004 refs
= get_submodule_ref_store(submodule
);
2009 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
2015 struct ref_store_hash_entry
2017 struct hashmap_entry ent
;
2019 struct ref_store
*refs
;
2021 /* NUL-terminated identifier of the ref store: */
2022 char name
[FLEX_ARRAY
];
2025 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
2026 const struct hashmap_entry
*eptr
,
2027 const struct hashmap_entry
*entry_or_key
,
2028 const void *keydata
)
2030 const struct ref_store_hash_entry
*e1
, *e2
;
2033 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2034 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2035 name
= keydata
? keydata
: e2
->name
;
2037 return strcmp(e1
->name
, name
);
2040 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2041 const char *name
, struct ref_store
*refs
)
2043 struct ref_store_hash_entry
*entry
;
2045 FLEX_ALLOC_STR(entry
, name
, name
);
2046 hashmap_entry_init(&entry
->ent
, strhash(name
));
2051 /* A hashmap of ref_stores, stored by submodule name: */
2052 static struct hashmap submodule_ref_stores
;
2054 /* A hashmap of ref_stores, stored by worktree id: */
2055 static struct hashmap worktree_ref_stores
;
2058 * Look up a ref store by name. If that ref_store hasn't been
2059 * registered yet, return NULL.
2061 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2064 struct ref_store_hash_entry
*entry
;
2067 if (!map
->tablesize
)
2068 /* It's initialized on demand in register_ref_store(). */
2071 hash
= strhash(name
);
2072 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2073 struct ref_store_hash_entry
, ent
);
2074 return entry
? entry
->refs
: NULL
;
2078 * Create, record, and return a ref_store instance for the specified
2081 static struct ref_store
*ref_store_init(struct repository
*repo
,
2085 const char *be_name
= "files";
2086 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
2087 struct ref_store
*refs
;
2090 BUG("reference backend %s is unknown", be_name
);
2092 refs
= be
->init(repo
, gitdir
, flags
);
2096 struct ref_store
*get_main_ref_store(struct repository
*r
)
2098 if (r
->refs_private
)
2099 return r
->refs_private
;
2102 BUG("attempting to get main_ref_store outside of repository");
2104 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2105 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2106 return r
->refs_private
;
2110 * Associate a ref store with a name. It is a fatal error to call this
2111 * function twice for the same name.
2113 static void register_ref_store_map(struct hashmap
*map
,
2115 struct ref_store
*refs
,
2118 struct ref_store_hash_entry
*entry
;
2120 if (!map
->tablesize
)
2121 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2123 entry
= alloc_ref_store_hash_entry(name
, refs
);
2124 if (hashmap_put(map
, &entry
->ent
))
2125 BUG("%s ref_store '%s' initialized twice", type
, name
);
2128 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2130 struct strbuf submodule_sb
= STRBUF_INIT
;
2131 struct ref_store
*refs
;
2132 char *to_free
= NULL
;
2134 struct repository
*subrepo
;
2139 len
= strlen(submodule
);
2140 while (len
&& is_dir_sep(submodule
[len
- 1]))
2146 /* We need to strip off one or more trailing slashes */
2147 submodule
= to_free
= xmemdupz(submodule
, len
);
2149 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2153 strbuf_addstr(&submodule_sb
, submodule
);
2154 if (!is_nonbare_repository_dir(&submodule_sb
))
2157 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2160 subrepo
= xmalloc(sizeof(*subrepo
));
2162 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2163 * superprojects other than the_repository. This probably should be
2164 * done by making it take a struct repository * parameter instead of a
2167 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2172 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2173 REF_STORE_READ
| REF_STORE_ODB
);
2174 register_ref_store_map(&submodule_ref_stores
, "submodule",
2178 strbuf_release(&submodule_sb
);
2184 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2186 struct ref_store
*refs
;
2190 return get_main_ref_store(the_repository
);
2192 id
= wt
->id
? wt
->id
: "/";
2193 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2198 refs
= ref_store_init(the_repository
,
2199 git_common_path("worktrees/%s", wt
->id
),
2200 REF_STORE_ALL_CAPS
);
2202 refs
= ref_store_init(the_repository
,
2203 get_git_common_dir(),
2204 REF_STORE_ALL_CAPS
);
2207 register_ref_store_map(&worktree_ref_stores
, "worktree",
2212 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2213 const char *path
, const struct ref_storage_be
*be
)
2217 refs
->gitdir
= xstrdup(path
);
2220 /* backend functions */
2221 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2223 return refs
->be
->pack_refs(refs
, opts
);
2226 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2228 if (current_ref_iter
&&
2229 (current_ref_iter
->oid
== base
||
2230 oideq(current_ref_iter
->oid
, base
)))
2231 return ref_iterator_peel(current_ref_iter
, peeled
);
2233 return peel_object(base
, peeled
) ? -1 : 0;
2236 int refs_create_symref(struct ref_store
*refs
,
2237 const char *ref_target
,
2238 const char *refs_heads_master
,
2244 msg
= normalize_reflog_message(logmsg
);
2245 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2251 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2254 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2255 refs_heads_master
, logmsg
);
2258 int ref_update_reject_duplicates(struct string_list
*refnames
,
2261 size_t i
, n
= refnames
->nr
;
2265 for (i
= 1; i
< n
; i
++) {
2266 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2267 refnames
->items
[i
].string
);
2271 _("multiple updates for ref '%s' not allowed"),
2272 refnames
->items
[i
].string
);
2274 } else if (cmp
> 0) {
2275 BUG("ref_update_reject_duplicates() received unsorted list");
2281 static int run_transaction_hook(struct ref_transaction
*transaction
,
2284 struct child_process proc
= CHILD_PROCESS_INIT
;
2285 struct strbuf buf
= STRBUF_INIT
;
2289 hook
= find_hook("reference-transaction");
2293 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2295 proc
.stdout_to_stderr
= 1;
2296 proc
.trace2_hook_name
= "reference-transaction";
2298 ret
= start_command(&proc
);
2302 sigchain_push(SIGPIPE
, SIG_IGN
);
2304 for (i
= 0; i
< transaction
->nr
; i
++) {
2305 struct ref_update
*update
= transaction
->updates
[i
];
2308 strbuf_addf(&buf
, "%s %s %s\n",
2309 oid_to_hex(&update
->old_oid
),
2310 oid_to_hex(&update
->new_oid
),
2313 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2314 if (errno
!= EPIPE
) {
2315 /* Don't leak errno outside this API */
2324 sigchain_pop(SIGPIPE
);
2325 strbuf_release(&buf
);
2327 ret
|= finish_command(&proc
);
2331 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2334 struct ref_store
*refs
= transaction
->ref_store
;
2337 switch (transaction
->state
) {
2338 case REF_TRANSACTION_OPEN
:
2341 case REF_TRANSACTION_PREPARED
:
2342 BUG("prepare called twice on reference transaction");
2344 case REF_TRANSACTION_CLOSED
:
2345 BUG("prepare called on a closed reference transaction");
2348 BUG("unexpected reference transaction state");
2352 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2354 _("ref updates forbidden inside quarantine environment"));
2358 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2362 ret
= run_transaction_hook(transaction
, "prepared");
2364 ref_transaction_abort(transaction
, err
);
2365 die(_("ref updates aborted by hook"));
2371 int ref_transaction_abort(struct ref_transaction
*transaction
,
2374 struct ref_store
*refs
= transaction
->ref_store
;
2377 switch (transaction
->state
) {
2378 case REF_TRANSACTION_OPEN
:
2379 /* No need to abort explicitly. */
2381 case REF_TRANSACTION_PREPARED
:
2382 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2384 case REF_TRANSACTION_CLOSED
:
2385 BUG("abort called on a closed reference transaction");
2388 BUG("unexpected reference transaction state");
2392 run_transaction_hook(transaction
, "aborted");
2394 ref_transaction_free(transaction
);
2398 int ref_transaction_commit(struct ref_transaction
*transaction
,
2401 struct ref_store
*refs
= transaction
->ref_store
;
2404 switch (transaction
->state
) {
2405 case REF_TRANSACTION_OPEN
:
2406 /* Need to prepare first. */
2407 ret
= ref_transaction_prepare(transaction
, err
);
2411 case REF_TRANSACTION_PREPARED
:
2412 /* Fall through to finish. */
2414 case REF_TRANSACTION_CLOSED
:
2415 BUG("commit called on a closed reference transaction");
2418 BUG("unexpected reference transaction state");
2422 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2424 run_transaction_hook(transaction
, "committed");
2428 int refs_verify_refname_available(struct ref_store
*refs
,
2429 const char *refname
,
2430 const struct string_list
*extras
,
2431 const struct string_list
*skip
,
2435 const char *extra_refname
;
2436 struct strbuf dirname
= STRBUF_INIT
;
2437 struct strbuf referent
= STRBUF_INIT
;
2438 struct object_id oid
;
2440 struct ref_iterator
*iter
;
2445 * For the sake of comments in this function, suppose that
2446 * refname is "refs/foo/bar".
2451 strbuf_grow(&dirname
, strlen(refname
) + 1);
2452 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2454 * Just saying "Is a directory" when we e.g. can't
2455 * lock some multi-level ref isn't very informative,
2456 * the user won't be told *what* is a directory, so
2457 * let's not use strerror() below.
2460 /* Expand dirname to the new prefix, not including the trailing slash: */
2461 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2464 * We are still at a leading dir of the refname (e.g.,
2465 * "refs/foo"; if there is a reference with that name,
2466 * it is a conflict, *unless* it is in skip.
2468 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2471 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2472 &type
, &ignore_errno
)) {
2473 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2474 dirname
.buf
, refname
);
2478 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2479 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2480 refname
, dirname
.buf
);
2486 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2487 * There is no point in searching for a reference with that
2488 * name, because a refname isn't considered to conflict with
2489 * itself. But we still need to check for references whose
2490 * names are in the "refs/foo/bar/" namespace, because they
2493 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2494 strbuf_addch(&dirname
, '/');
2496 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2497 DO_FOR_EACH_INCLUDE_BROKEN
);
2498 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2500 string_list_has_string(skip
, iter
->refname
))
2503 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2504 iter
->refname
, refname
);
2505 ref_iterator_abort(iter
);
2509 if (ok
!= ITER_DONE
)
2510 BUG("error while iterating over references");
2512 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2514 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2515 refname
, extra_refname
);
2520 strbuf_release(&referent
);
2521 strbuf_release(&dirname
);
2525 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2527 struct ref_iterator
*iter
;
2528 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2530 iter
= refs
->be
->reflog_iterator_begin(refs
);
2532 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2533 do_for_each_ref_helper
, &hp
);
2536 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2538 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2541 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2542 const char *refname
,
2543 each_reflog_ent_fn fn
,
2546 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2550 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2553 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2554 refname
, fn
, cb_data
);
2557 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2558 each_reflog_ent_fn fn
, void *cb_data
)
2560 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2563 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2566 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2570 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2572 return refs
->be
->reflog_exists(refs
, refname
);
2575 int reflog_exists(const char *refname
)
2577 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2580 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2583 return refs
->be
->create_reflog(refs
, refname
, err
);
2586 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2588 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2592 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2594 return refs
->be
->delete_reflog(refs
, refname
);
2597 int delete_reflog(const char *refname
)
2599 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2602 int refs_reflog_expire(struct ref_store
*refs
,
2603 const char *refname
,
2605 reflog_expiry_prepare_fn prepare_fn
,
2606 reflog_expiry_should_prune_fn should_prune_fn
,
2607 reflog_expiry_cleanup_fn cleanup_fn
,
2608 void *policy_cb_data
)
2610 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2611 prepare_fn
, should_prune_fn
,
2612 cleanup_fn
, policy_cb_data
);
2615 int reflog_expire(const char *refname
,
2617 reflog_expiry_prepare_fn prepare_fn
,
2618 reflog_expiry_should_prune_fn should_prune_fn
,
2619 reflog_expiry_cleanup_fn cleanup_fn
,
2620 void *policy_cb_data
)
2622 return refs_reflog_expire(get_main_ref_store(the_repository
),
2624 prepare_fn
, should_prune_fn
,
2625 cleanup_fn
, policy_cb_data
);
2628 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2631 struct ref_store
*refs
= transaction
->ref_store
;
2633 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2636 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2637 ref_transaction_for_each_queued_update_fn cb
,
2642 for (i
= 0; i
< transaction
->nr
; i
++) {
2643 struct ref_update
*update
= transaction
->updates
[i
];
2646 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2647 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2652 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2653 struct string_list
*refnames
, unsigned int flags
)
2655 struct ref_transaction
*transaction
;
2656 struct strbuf err
= STRBUF_INIT
;
2657 struct string_list_item
*item
;
2658 int ret
= 0, failures
= 0;
2664 msg
= normalize_reflog_message(logmsg
);
2667 * Since we don't check the references' old_oids, the
2668 * individual updates can't fail, so we can pack all of the
2669 * updates into a single transaction.
2671 transaction
= ref_store_transaction_begin(refs
, &err
);
2673 ret
= error("%s", err
.buf
);
2677 for_each_string_list_item(item
, refnames
) {
2678 ret
= ref_transaction_delete(transaction
, item
->string
,
2679 NULL
, flags
, msg
, &err
);
2681 warning(_("could not delete reference %s: %s"),
2682 item
->string
, err
.buf
);
2688 ret
= ref_transaction_commit(transaction
, &err
);
2690 if (refnames
->nr
== 1)
2691 error(_("could not delete reference %s: %s"),
2692 refnames
->items
[0].string
, err
.buf
);
2694 error(_("could not delete references: %s"), err
.buf
);
2698 if (!ret
&& failures
)
2700 ref_transaction_free(transaction
);
2701 strbuf_release(&err
);
2706 int delete_refs(const char *msg
, struct string_list
*refnames
,
2709 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2712 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2713 const char *newref
, const char *logmsg
)
2718 msg
= normalize_reflog_message(logmsg
);
2719 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2724 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2726 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2729 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2730 const char *newref
, const char *logmsg
)
2735 msg
= normalize_reflog_message(logmsg
);
2736 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2741 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2743 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);