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 * - CHERRY_PICK_HEAD
1849 * - "rebase-apply/" and "rebase-merge/" contain all of the state for
1850 * rebases, including some reference-like files. These are
1851 * exclusively read and written via the filesystem and never go
1852 * through the refdb.
1854 * Writing or deleting references must consistently go either through
1855 * the filesystem (special refs) or through the reference backend
1858 static const char * const special_refs
[] = {
1860 "BISECT_EXPECTED_REV",
1867 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1868 if (!strcmp(refname
, special_refs
[i
]))
1874 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1875 struct object_id
*oid
, struct strbuf
*referent
,
1876 unsigned int *type
, int *failure_errno
)
1878 assert(failure_errno
);
1879 if (is_special_ref(refname
))
1880 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1881 type
, failure_errno
);
1883 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1884 type
, failure_errno
);
1887 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1888 struct strbuf
*referent
)
1890 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1893 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1894 const char *refname
,
1896 struct object_id
*oid
,
1899 static struct strbuf sb_refname
= STRBUF_INIT
;
1900 struct object_id unused_oid
;
1907 flags
= &unused_flags
;
1911 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1912 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1913 !refname_is_safe(refname
))
1917 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1918 * missing refs and refs that were present but invalid,
1919 * to complain about the latter to stderr.
1921 * We don't know whether the ref exists, so don't set
1924 *flags
|= REF_BAD_NAME
;
1927 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1928 unsigned int read_flags
= 0;
1931 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1932 &read_flags
, &failure_errno
)) {
1933 *flags
|= read_flags
;
1935 /* In reading mode, refs must eventually resolve */
1936 if (resolve_flags
& RESOLVE_REF_READING
)
1940 * Otherwise a missing ref is OK. But the files backend
1941 * may show errors besides ENOENT if there are
1942 * similarly-named refs.
1944 if (failure_errno
!= ENOENT
&&
1945 failure_errno
!= EISDIR
&&
1946 failure_errno
!= ENOTDIR
)
1950 if (*flags
& REF_BAD_NAME
)
1951 *flags
|= REF_ISBROKEN
;
1955 *flags
|= read_flags
;
1957 if (!(read_flags
& REF_ISSYMREF
)) {
1958 if (*flags
& REF_BAD_NAME
) {
1960 *flags
|= REF_ISBROKEN
;
1965 refname
= sb_refname
.buf
;
1966 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1970 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1971 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1972 !refname_is_safe(refname
))
1975 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1982 /* backend functions */
1983 int refs_init_db(struct strbuf
*err
)
1985 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1987 return refs
->be
->init_db(refs
, err
);
1990 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1991 struct object_id
*oid
, int *flags
)
1993 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1994 resolve_flags
, oid
, flags
);
1997 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1998 struct object_id
*oid
)
2000 struct ref_store
*refs
;
2003 refs
= get_submodule_ref_store(submodule
);
2008 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
2014 struct ref_store_hash_entry
2016 struct hashmap_entry ent
;
2018 struct ref_store
*refs
;
2020 /* NUL-terminated identifier of the ref store: */
2021 char name
[FLEX_ARRAY
];
2024 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
2025 const struct hashmap_entry
*eptr
,
2026 const struct hashmap_entry
*entry_or_key
,
2027 const void *keydata
)
2029 const struct ref_store_hash_entry
*e1
, *e2
;
2032 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2033 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2034 name
= keydata
? keydata
: e2
->name
;
2036 return strcmp(e1
->name
, name
);
2039 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2040 const char *name
, struct ref_store
*refs
)
2042 struct ref_store_hash_entry
*entry
;
2044 FLEX_ALLOC_STR(entry
, name
, name
);
2045 hashmap_entry_init(&entry
->ent
, strhash(name
));
2050 /* A hashmap of ref_stores, stored by submodule name: */
2051 static struct hashmap submodule_ref_stores
;
2053 /* A hashmap of ref_stores, stored by worktree id: */
2054 static struct hashmap worktree_ref_stores
;
2057 * Look up a ref store by name. If that ref_store hasn't been
2058 * registered yet, return NULL.
2060 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2063 struct ref_store_hash_entry
*entry
;
2066 if (!map
->tablesize
)
2067 /* It's initialized on demand in register_ref_store(). */
2070 hash
= strhash(name
);
2071 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2072 struct ref_store_hash_entry
, ent
);
2073 return entry
? entry
->refs
: NULL
;
2077 * Create, record, and return a ref_store instance for the specified
2080 static struct ref_store
*ref_store_init(struct repository
*repo
,
2084 const char *be_name
= "files";
2085 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
2086 struct ref_store
*refs
;
2089 BUG("reference backend %s is unknown", be_name
);
2091 refs
= be
->init(repo
, gitdir
, flags
);
2095 struct ref_store
*get_main_ref_store(struct repository
*r
)
2097 if (r
->refs_private
)
2098 return r
->refs_private
;
2101 BUG("attempting to get main_ref_store outside of repository");
2103 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2104 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2105 return r
->refs_private
;
2109 * Associate a ref store with a name. It is a fatal error to call this
2110 * function twice for the same name.
2112 static void register_ref_store_map(struct hashmap
*map
,
2114 struct ref_store
*refs
,
2117 struct ref_store_hash_entry
*entry
;
2119 if (!map
->tablesize
)
2120 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2122 entry
= alloc_ref_store_hash_entry(name
, refs
);
2123 if (hashmap_put(map
, &entry
->ent
))
2124 BUG("%s ref_store '%s' initialized twice", type
, name
);
2127 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2129 struct strbuf submodule_sb
= STRBUF_INIT
;
2130 struct ref_store
*refs
;
2131 char *to_free
= NULL
;
2133 struct repository
*subrepo
;
2138 len
= strlen(submodule
);
2139 while (len
&& is_dir_sep(submodule
[len
- 1]))
2145 /* We need to strip off one or more trailing slashes */
2146 submodule
= to_free
= xmemdupz(submodule
, len
);
2148 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2152 strbuf_addstr(&submodule_sb
, submodule
);
2153 if (!is_nonbare_repository_dir(&submodule_sb
))
2156 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2159 subrepo
= xmalloc(sizeof(*subrepo
));
2161 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2162 * superprojects other than the_repository. This probably should be
2163 * done by making it take a struct repository * parameter instead of a
2166 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2171 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2172 REF_STORE_READ
| REF_STORE_ODB
);
2173 register_ref_store_map(&submodule_ref_stores
, "submodule",
2177 strbuf_release(&submodule_sb
);
2183 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2185 struct ref_store
*refs
;
2189 return get_main_ref_store(the_repository
);
2191 id
= wt
->id
? wt
->id
: "/";
2192 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2197 refs
= ref_store_init(the_repository
,
2198 git_common_path("worktrees/%s", wt
->id
),
2199 REF_STORE_ALL_CAPS
);
2201 refs
= ref_store_init(the_repository
,
2202 get_git_common_dir(),
2203 REF_STORE_ALL_CAPS
);
2206 register_ref_store_map(&worktree_ref_stores
, "worktree",
2211 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2212 const char *path
, const struct ref_storage_be
*be
)
2216 refs
->gitdir
= xstrdup(path
);
2219 /* backend functions */
2220 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2222 return refs
->be
->pack_refs(refs
, opts
);
2225 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2227 if (current_ref_iter
&&
2228 (current_ref_iter
->oid
== base
||
2229 oideq(current_ref_iter
->oid
, base
)))
2230 return ref_iterator_peel(current_ref_iter
, peeled
);
2232 return peel_object(base
, peeled
) ? -1 : 0;
2235 int refs_create_symref(struct ref_store
*refs
,
2236 const char *ref_target
,
2237 const char *refs_heads_master
,
2243 msg
= normalize_reflog_message(logmsg
);
2244 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2250 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2253 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2254 refs_heads_master
, logmsg
);
2257 int ref_update_reject_duplicates(struct string_list
*refnames
,
2260 size_t i
, n
= refnames
->nr
;
2264 for (i
= 1; i
< n
; i
++) {
2265 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2266 refnames
->items
[i
].string
);
2270 _("multiple updates for ref '%s' not allowed"),
2271 refnames
->items
[i
].string
);
2273 } else if (cmp
> 0) {
2274 BUG("ref_update_reject_duplicates() received unsorted list");
2280 static int run_transaction_hook(struct ref_transaction
*transaction
,
2283 struct child_process proc
= CHILD_PROCESS_INIT
;
2284 struct strbuf buf
= STRBUF_INIT
;
2288 hook
= find_hook("reference-transaction");
2292 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2294 proc
.stdout_to_stderr
= 1;
2295 proc
.trace2_hook_name
= "reference-transaction";
2297 ret
= start_command(&proc
);
2301 sigchain_push(SIGPIPE
, SIG_IGN
);
2303 for (i
= 0; i
< transaction
->nr
; i
++) {
2304 struct ref_update
*update
= transaction
->updates
[i
];
2307 strbuf_addf(&buf
, "%s %s %s\n",
2308 oid_to_hex(&update
->old_oid
),
2309 oid_to_hex(&update
->new_oid
),
2312 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2313 if (errno
!= EPIPE
) {
2314 /* Don't leak errno outside this API */
2323 sigchain_pop(SIGPIPE
);
2324 strbuf_release(&buf
);
2326 ret
|= finish_command(&proc
);
2330 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2333 struct ref_store
*refs
= transaction
->ref_store
;
2336 switch (transaction
->state
) {
2337 case REF_TRANSACTION_OPEN
:
2340 case REF_TRANSACTION_PREPARED
:
2341 BUG("prepare called twice on reference transaction");
2343 case REF_TRANSACTION_CLOSED
:
2344 BUG("prepare called on a closed reference transaction");
2347 BUG("unexpected reference transaction state");
2351 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2353 _("ref updates forbidden inside quarantine environment"));
2357 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2361 ret
= run_transaction_hook(transaction
, "prepared");
2363 ref_transaction_abort(transaction
, err
);
2364 die(_("ref updates aborted by hook"));
2370 int ref_transaction_abort(struct ref_transaction
*transaction
,
2373 struct ref_store
*refs
= transaction
->ref_store
;
2376 switch (transaction
->state
) {
2377 case REF_TRANSACTION_OPEN
:
2378 /* No need to abort explicitly. */
2380 case REF_TRANSACTION_PREPARED
:
2381 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2383 case REF_TRANSACTION_CLOSED
:
2384 BUG("abort called on a closed reference transaction");
2387 BUG("unexpected reference transaction state");
2391 run_transaction_hook(transaction
, "aborted");
2393 ref_transaction_free(transaction
);
2397 int ref_transaction_commit(struct ref_transaction
*transaction
,
2400 struct ref_store
*refs
= transaction
->ref_store
;
2403 switch (transaction
->state
) {
2404 case REF_TRANSACTION_OPEN
:
2405 /* Need to prepare first. */
2406 ret
= ref_transaction_prepare(transaction
, err
);
2410 case REF_TRANSACTION_PREPARED
:
2411 /* Fall through to finish. */
2413 case REF_TRANSACTION_CLOSED
:
2414 BUG("commit called on a closed reference transaction");
2417 BUG("unexpected reference transaction state");
2421 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2423 run_transaction_hook(transaction
, "committed");
2427 int refs_verify_refname_available(struct ref_store
*refs
,
2428 const char *refname
,
2429 const struct string_list
*extras
,
2430 const struct string_list
*skip
,
2434 const char *extra_refname
;
2435 struct strbuf dirname
= STRBUF_INIT
;
2436 struct strbuf referent
= STRBUF_INIT
;
2437 struct object_id oid
;
2439 struct ref_iterator
*iter
;
2444 * For the sake of comments in this function, suppose that
2445 * refname is "refs/foo/bar".
2450 strbuf_grow(&dirname
, strlen(refname
) + 1);
2451 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2453 * Just saying "Is a directory" when we e.g. can't
2454 * lock some multi-level ref isn't very informative,
2455 * the user won't be told *what* is a directory, so
2456 * let's not use strerror() below.
2459 /* Expand dirname to the new prefix, not including the trailing slash: */
2460 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2463 * We are still at a leading dir of the refname (e.g.,
2464 * "refs/foo"; if there is a reference with that name,
2465 * it is a conflict, *unless* it is in skip.
2467 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2470 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2471 &type
, &ignore_errno
)) {
2472 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2473 dirname
.buf
, refname
);
2477 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2478 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2479 refname
, dirname
.buf
);
2485 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2486 * There is no point in searching for a reference with that
2487 * name, because a refname isn't considered to conflict with
2488 * itself. But we still need to check for references whose
2489 * names are in the "refs/foo/bar/" namespace, because they
2492 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2493 strbuf_addch(&dirname
, '/');
2495 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2496 DO_FOR_EACH_INCLUDE_BROKEN
);
2497 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2499 string_list_has_string(skip
, iter
->refname
))
2502 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2503 iter
->refname
, refname
);
2504 ref_iterator_abort(iter
);
2508 if (ok
!= ITER_DONE
)
2509 BUG("error while iterating over references");
2511 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2513 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2514 refname
, extra_refname
);
2519 strbuf_release(&referent
);
2520 strbuf_release(&dirname
);
2524 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2526 struct ref_iterator
*iter
;
2527 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2529 iter
= refs
->be
->reflog_iterator_begin(refs
);
2531 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2532 do_for_each_ref_helper
, &hp
);
2535 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2537 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2540 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2541 const char *refname
,
2542 each_reflog_ent_fn fn
,
2545 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2549 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2552 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2553 refname
, fn
, cb_data
);
2556 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2557 each_reflog_ent_fn fn
, void *cb_data
)
2559 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2562 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2565 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2569 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2571 return refs
->be
->reflog_exists(refs
, refname
);
2574 int reflog_exists(const char *refname
)
2576 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2579 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2582 return refs
->be
->create_reflog(refs
, refname
, err
);
2585 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2587 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2591 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2593 return refs
->be
->delete_reflog(refs
, refname
);
2596 int delete_reflog(const char *refname
)
2598 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2601 int refs_reflog_expire(struct ref_store
*refs
,
2602 const char *refname
,
2604 reflog_expiry_prepare_fn prepare_fn
,
2605 reflog_expiry_should_prune_fn should_prune_fn
,
2606 reflog_expiry_cleanup_fn cleanup_fn
,
2607 void *policy_cb_data
)
2609 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2610 prepare_fn
, should_prune_fn
,
2611 cleanup_fn
, policy_cb_data
);
2614 int reflog_expire(const char *refname
,
2616 reflog_expiry_prepare_fn prepare_fn
,
2617 reflog_expiry_should_prune_fn should_prune_fn
,
2618 reflog_expiry_cleanup_fn cleanup_fn
,
2619 void *policy_cb_data
)
2621 return refs_reflog_expire(get_main_ref_store(the_repository
),
2623 prepare_fn
, should_prune_fn
,
2624 cleanup_fn
, policy_cb_data
);
2627 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2630 struct ref_store
*refs
= transaction
->ref_store
;
2632 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2635 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2636 ref_transaction_for_each_queued_update_fn cb
,
2641 for (i
= 0; i
< transaction
->nr
; i
++) {
2642 struct ref_update
*update
= transaction
->updates
[i
];
2645 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2646 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2651 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2652 struct string_list
*refnames
, unsigned int flags
)
2657 msg
= normalize_reflog_message(logmsg
);
2658 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2663 int delete_refs(const char *msg
, struct string_list
*refnames
,
2666 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2669 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2670 const char *newref
, const char *logmsg
)
2675 msg
= normalize_reflog_message(logmsg
);
2676 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2681 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2683 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2686 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2687 const char *newref
, const char *logmsg
)
2692 msg
= normalize_reflog_message(logmsg
);
2693 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2698 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2700 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);