2 * The backend-independent part of the reference module.
5 #include "git-compat-util.h"
8 #include "environment.h"
15 #include "refs/refs-internal.h"
16 #include "run-command.h"
18 #include "object-name.h"
19 #include "object-store-ll.h"
23 #include "submodule.h"
26 #include "repository.h"
31 #include "wildmatch.h"
34 * List of all available backends
36 static const struct ref_storage_be
*refs_backends
[] = {
37 [REF_STORAGE_FORMAT_FILES
] = &refs_be_files
,
38 [REF_STORAGE_FORMAT_REFTABLE
] = &refs_be_reftable
,
41 static const struct ref_storage_be
*find_ref_storage_backend(unsigned int ref_storage_format
)
43 if (ref_storage_format
< ARRAY_SIZE(refs_backends
))
44 return refs_backends
[ref_storage_format
];
48 unsigned int ref_storage_format_by_name(const char *name
)
50 for (unsigned int i
= 0; i
< ARRAY_SIZE(refs_backends
); i
++)
51 if (refs_backends
[i
] && !strcmp(refs_backends
[i
]->name
, name
))
53 return REF_STORAGE_FORMAT_UNKNOWN
;
56 const char *ref_storage_format_to_name(unsigned int ref_storage_format
)
58 const struct ref_storage_be
*be
= find_ref_storage_backend(ref_storage_format
);
65 * How to handle various characters in refnames:
66 * 0: An acceptable character for refs
68 * 2: ., look for a preceding . to reject .. in refs
69 * 3: {, look for a preceding @ to reject @{ in refs
70 * 4: A bad character: ASCII control characters, and
71 * ":", "?", "[", "\", "^", "~", SP, or TAB
72 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
74 static unsigned char refname_disposition
[256] = {
75 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
82 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
85 struct ref_namespace_info ref_namespace
[] = {
88 .decoration
= DECORATION_REF_HEAD
,
91 [NAMESPACE_BRANCHES
] = {
93 .decoration
= DECORATION_REF_LOCAL
,
97 .decoration
= DECORATION_REF_TAG
,
99 [NAMESPACE_REMOTE_REFS
] = {
101 * The default refspec for new remotes copies refs from
102 * refs/heads/ on the remote into refs/remotes/<remote>/.
103 * As such, "refs/remotes/" has special handling.
105 .ref
= "refs/remotes/",
106 .decoration
= DECORATION_REF_REMOTE
,
108 [NAMESPACE_STASH
] = {
110 * The single ref "refs/stash" stores the latest stash.
111 * Older stashes can be found in the reflog.
115 .decoration
= DECORATION_REF_STASH
,
117 [NAMESPACE_REPLACE
] = {
119 * This namespace allows Git to act as if one object ID
120 * points to the content of another. Unlike the other
121 * ref namespaces, this one can be changed by the
122 * GIT_REPLACE_REF_BASE environment variable. This
123 * .namespace value will be overwritten in setup_git_env().
125 .ref
= "refs/replace/",
126 .decoration
= DECORATION_GRAFTED
,
128 [NAMESPACE_NOTES
] = {
130 * The refs/notes/commit ref points to the tip of a
131 * parallel commit history that adds metadata to commits
132 * in the normal history. This ref can be overwritten
133 * by the core.notesRef config variable or the
134 * GIT_NOTES_REFS environment variable.
136 .ref
= "refs/notes/commit",
139 [NAMESPACE_PREFETCH
] = {
141 * Prefetch refs are written by the background 'fetch'
142 * maintenance task. It allows faster foreground fetches
143 * by advertising these previously-downloaded tips without
144 * updating refs/remotes/ without user intervention.
146 .ref
= "refs/prefetch/",
148 [NAMESPACE_REWRITTEN
] = {
150 * Rewritten refs are used by the 'label' command in the
151 * sequencer. These are particularly useful during an
152 * interactive rebase that uses the 'merge' command.
154 .ref
= "refs/rewritten/",
158 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
160 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
161 if (info
->ref_updated
)
164 info
->ref_updated
= 1;
168 * Try to read one refname component from the front of refname.
169 * Return the length of the component found, or -1 if the component is
170 * not legal. It is legal if it is something reasonable to have under
171 * ".git/refs/"; We do not like it if:
173 * - it begins with ".", or
174 * - it has double dots "..", or
175 * - it has ASCII control characters, or
176 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
177 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
178 * - it ends with a "/", or
179 * - it ends with ".lock", or
180 * - it contains a "@{" portion
182 * When sanitized is not NULL, instead of rejecting the input refname
183 * as an error, try to come up with a usable replacement for the input
186 static int check_refname_component(const char *refname
, int *flags
,
187 struct strbuf
*sanitized
)
191 size_t component_start
= 0; /* garbage - not a reasonable initial value */
194 component_start
= sanitized
->len
;
196 for (cp
= refname
; ; cp
++) {
198 unsigned char disp
= refname_disposition
[ch
];
200 if (sanitized
&& disp
!= 1)
201 strbuf_addch(sanitized
, ch
);
207 if (last
== '.') { /* Refname contains "..". */
209 /* collapse ".." to single "." */
210 strbuf_setlen(sanitized
, sanitized
->len
- 1);
216 if (last
== '@') { /* Refname contains "@{". */
218 sanitized
->buf
[sanitized
->len
-1] = '-';
226 sanitized
->buf
[sanitized
->len
-1] = '-';
231 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
232 /* refspec can't be a pattern */
234 sanitized
->buf
[sanitized
->len
-1] = '-';
240 * Unset the pattern flag so that we only accept
241 * a single asterisk for one side of refspec.
243 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
250 return 0; /* Component has zero length. */
252 if (refname
[0] == '.') { /* Component starts with '.'. */
254 sanitized
->buf
[component_start
] = '-';
258 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
259 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
262 /* Refname ends with ".lock". */
263 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
264 /* try again in case we have .lock.lock */
270 static int check_or_sanitize_refname(const char *refname
, int flags
,
271 struct strbuf
*sanitized
)
273 int component_len
, component_count
= 0;
275 if (!strcmp(refname
, "@")) {
276 /* Refname is a single character '@'. */
278 strbuf_addch(sanitized
, '-');
284 if (sanitized
&& sanitized
->len
)
285 strbuf_complete(sanitized
, '/');
287 /* We are at the start of a path component. */
288 component_len
= check_refname_component(refname
, &flags
,
290 if (sanitized
&& component_len
== 0)
291 ; /* OK, omit empty component */
292 else if (component_len
<= 0)
296 if (refname
[component_len
] == '\0')
298 /* Skip to next component. */
299 refname
+= component_len
+ 1;
302 if (refname
[component_len
- 1] == '.') {
303 /* Refname ends with '.'. */
305 ; /* omit ending dot */
309 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
310 return -1; /* Refname has only one component. */
314 int check_refname_format(const char *refname
, int flags
)
316 return check_or_sanitize_refname(refname
, flags
, NULL
);
319 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
321 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
322 BUG("sanitizing refname '%s' check returned error", refname
);
325 int refname_is_safe(const char *refname
)
329 if (skip_prefix(refname
, "refs/", &rest
)) {
332 size_t restlen
= strlen(rest
);
334 /* rest must not be empty, or start or end with "/" */
335 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
339 * Does the refname try to escape refs/?
340 * For example: refs/foo/../bar is safe but refs/foo/../../bar
343 buf
= xmallocz(restlen
);
344 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
350 if (!isupper(*refname
) && *refname
!= '_')
358 * Return true if refname, which has the specified oid and flags, can
359 * be resolved to an object in the database. If the referred-to object
360 * does not exist, emit a warning and return false.
362 int ref_resolves_to_object(const char *refname
,
363 struct repository
*repo
,
364 const struct object_id
*oid
,
367 if (flags
& REF_ISBROKEN
)
369 if (!repo_has_object_file(repo
, oid
)) {
370 error(_("%s does not point to a valid object!"), refname
);
376 char *refs_resolve_refdup(struct ref_store
*refs
,
377 const char *refname
, int resolve_flags
,
378 struct object_id
*oid
, int *flags
)
382 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
384 return xstrdup_or_null(result
);
387 /* The argument to for_each_filter_refs */
388 struct for_each_ref_filter
{
395 int refs_read_ref_full(struct ref_store
*refs
, const char *refname
,
396 int resolve_flags
, struct object_id
*oid
, int *flags
)
398 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
404 int refs_read_ref(struct ref_store
*refs
, const char *refname
, struct object_id
*oid
)
406 return refs_read_ref_full(refs
, refname
, RESOLVE_REF_READING
, oid
, NULL
);
409 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
411 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
415 static int for_each_filter_refs(const char *refname
,
416 const struct object_id
*oid
,
417 int flags
, void *data
)
419 struct for_each_ref_filter
*filter
= data
;
421 if (wildmatch(filter
->pattern
, refname
, 0))
424 skip_prefix(refname
, filter
->prefix
, &refname
);
425 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
428 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
430 struct object
*o
= lookup_unknown_object(the_repository
, name
);
432 if (o
->type
== OBJ_NONE
) {
433 int type
= oid_object_info(the_repository
, name
, NULL
);
434 if (type
< 0 || !object_as_type(o
, type
, 0))
438 if (o
->type
!= OBJ_TAG
)
441 o
= deref_tag_noverify(o
);
445 oidcpy(oid
, &o
->oid
);
449 struct warn_if_dangling_data
{
452 const struct string_list
*refnames
;
456 static int warn_if_dangling_symref(const char *refname
,
457 const struct object_id
*oid UNUSED
,
458 int flags
, void *cb_data
)
460 struct warn_if_dangling_data
*d
= cb_data
;
461 const char *resolves_to
;
463 if (!(flags
& REF_ISSYMREF
))
466 resolves_to
= refs_resolve_ref_unsafe(get_main_ref_store(the_repository
),
467 refname
, 0, NULL
, NULL
);
470 ? strcmp(resolves_to
, d
->refname
)
471 : !string_list_has_string(d
->refnames
, resolves_to
))) {
475 fprintf(d
->fp
, d
->msg_fmt
, refname
);
480 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
482 struct warn_if_dangling_data data
;
485 data
.refname
= refname
;
486 data
.refnames
= NULL
;
487 data
.msg_fmt
= msg_fmt
;
488 refs_for_each_rawref(get_main_ref_store(the_repository
),
489 warn_if_dangling_symref
, &data
);
492 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
494 struct warn_if_dangling_data data
;
498 data
.refnames
= refnames
;
499 data
.msg_fmt
= msg_fmt
;
500 refs_for_each_rawref(get_main_ref_store(the_repository
),
501 warn_if_dangling_symref
, &data
);
504 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
506 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
509 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
511 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
514 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
516 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
519 int refs_head_ref_namespaced(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
521 struct strbuf buf
= STRBUF_INIT
;
523 struct object_id oid
;
526 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
527 if (!refs_read_ref_full(refs
, buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
528 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
529 strbuf_release(&buf
);
534 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
537 struct strbuf normalized_pattern
= STRBUF_INIT
;
540 BUG("pattern must not start with '/'");
543 strbuf_addstr(&normalized_pattern
, prefix
);
544 else if (!starts_with(pattern
, "refs/") &&
545 strcmp(pattern
, "HEAD"))
546 strbuf_addstr(&normalized_pattern
, "refs/");
548 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
552 strbuf_addstr(&normalized_pattern
, pattern
);
553 strbuf_strip_suffix(&normalized_pattern
, "/");
555 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
556 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
557 strbuf_release(&normalized_pattern
);
560 int refs_for_each_glob_ref_in(struct ref_store
*refs
, each_ref_fn fn
,
561 const char *pattern
, const char *prefix
, void *cb_data
)
563 struct strbuf real_pattern
= STRBUF_INIT
;
564 struct for_each_ref_filter filter
;
567 if (!prefix
&& !starts_with(pattern
, "refs/"))
568 strbuf_addstr(&real_pattern
, "refs/");
570 strbuf_addstr(&real_pattern
, prefix
);
571 strbuf_addstr(&real_pattern
, pattern
);
573 if (!has_glob_specials(pattern
)) {
574 /* Append implied '/' '*' if not present. */
575 strbuf_complete(&real_pattern
, '/');
576 /* No need to check for '*', there is none. */
577 strbuf_addch(&real_pattern
, '*');
580 filter
.pattern
= real_pattern
.buf
;
581 filter
.prefix
= prefix
;
583 filter
.cb_data
= cb_data
;
584 ret
= refs_for_each_ref(refs
, for_each_filter_refs
, &filter
);
586 strbuf_release(&real_pattern
);
590 int refs_for_each_glob_ref(struct ref_store
*refs
, each_ref_fn fn
,
591 const char *pattern
, void *cb_data
)
593 return refs_for_each_glob_ref_in(refs
, fn
, pattern
, NULL
, cb_data
);
596 const char *prettify_refname(const char *name
)
598 if (skip_prefix(name
, "refs/heads/", &name
) ||
599 skip_prefix(name
, "refs/tags/", &name
) ||
600 skip_prefix(name
, "refs/remotes/", &name
))
605 static const char *ref_rev_parse_rules
[] = {
611 "refs/remotes/%.*s/HEAD",
615 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
618 * Is it possible that the caller meant full_name with abbrev_name?
619 * If so return a non-zero value to signal "yes"; the magnitude of
620 * the returned value gives the precedence used for disambiguation.
622 * If abbrev_name cannot mean full_name, return 0.
624 int refname_match(const char *abbrev_name
, const char *full_name
)
627 const int abbrev_name_len
= strlen(abbrev_name
);
628 const int num_rules
= NUM_REV_PARSE_RULES
;
630 for (p
= ref_rev_parse_rules
; *p
; p
++)
631 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
632 return &ref_rev_parse_rules
[num_rules
] - p
;
638 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
639 * the results to 'prefixes'
641 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
644 int len
= strlen(prefix
);
646 for (p
= ref_rev_parse_rules
; *p
; p
++)
647 strvec_pushf(prefixes
, *p
, len
, prefix
);
650 static const char default_branch_name_advice
[] = N_(
651 "Using '%s' as the name for the initial branch. This default branch name\n"
652 "is subject to change. To configure the initial branch name to use in all\n"
653 "of your new repositories, which will suppress this warning, call:\n"
655 "\tgit config --global init.defaultBranch <name>\n"
657 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
658 "'development'. The just-created branch can be renamed via this command:\n"
660 "\tgit branch -m <name>\n"
663 char *repo_default_branch_name(struct repository
*r
, int quiet
)
665 const char *config_key
= "init.defaultbranch";
666 const char *config_display_key
= "init.defaultBranch";
667 char *ret
= NULL
, *full_ref
;
668 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
672 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
673 die(_("could not retrieve `%s`"), config_display_key
);
676 ret
= xstrdup("master");
678 advise(_(default_branch_name_advice
), ret
);
681 full_ref
= xstrfmt("refs/heads/%s", ret
);
682 if (check_refname_format(full_ref
, 0))
683 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
689 const char *git_default_branch_name(int quiet
)
694 ret
= repo_default_branch_name(the_repository
, quiet
);
700 * *string and *len will only be substituted, and *string returned (for
701 * later free()ing) if the string passed in is a magic short-hand form
704 static char *substitute_branch_name(struct repository
*r
,
705 const char **string
, int *len
,
706 int nonfatal_dangling_mark
)
708 struct strbuf buf
= STRBUF_INIT
;
709 struct interpret_branch_name_options options
= {
710 .nonfatal_dangling_mark
= nonfatal_dangling_mark
712 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
716 *string
= strbuf_detach(&buf
, &size
);
718 return (char *)*string
;
724 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
725 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
727 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
728 nonfatal_dangling_mark
);
729 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
734 int expand_ref(struct repository
*repo
, const char *str
, int len
,
735 struct object_id
*oid
, char **ref
)
739 struct strbuf fullref
= STRBUF_INIT
;
742 for (p
= ref_rev_parse_rules
; *p
; p
++) {
743 struct object_id oid_from_ref
;
744 struct object_id
*this_result
;
746 struct ref_store
*refs
= get_main_ref_store(repo
);
748 this_result
= refs_found
? &oid_from_ref
: oid
;
749 strbuf_reset(&fullref
);
750 strbuf_addf(&fullref
, *p
, len
, str
);
751 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
757 if (!warn_ambiguous_refs
)
759 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
760 warning(_("ignoring dangling symref %s"), fullref
.buf
);
761 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
762 warning(_("ignoring broken ref %s"), fullref
.buf
);
765 strbuf_release(&fullref
);
769 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
770 struct object_id
*oid
, char **log
)
772 struct ref_store
*refs
= get_main_ref_store(r
);
773 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
776 struct strbuf path
= STRBUF_INIT
;
779 for (p
= ref_rev_parse_rules
; *p
; p
++) {
780 struct object_id hash
;
781 const char *ref
, *it
;
784 strbuf_addf(&path
, *p
, len
, str
);
785 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
787 oid
? &hash
: NULL
, NULL
);
790 if (refs_reflog_exists(refs
, path
.buf
))
792 else if (strcmp(ref
, path
.buf
) &&
793 refs_reflog_exists(refs
, ref
))
802 if (!warn_ambiguous_refs
)
805 strbuf_release(&path
);
810 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
812 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
815 int is_per_worktree_ref(const char *refname
)
817 return starts_with(refname
, "refs/worktree/") ||
818 starts_with(refname
, "refs/bisect/") ||
819 starts_with(refname
, "refs/rewritten/");
822 static int is_pseudoref_syntax(const char *refname
)
826 for (c
= refname
; *c
; c
++) {
827 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
832 * HEAD is not a pseudoref, but it certainly uses the
838 int is_pseudoref(struct ref_store
*refs
, const char *refname
)
840 static const char *const irregular_pseudorefs
[] = {
842 "BISECT_EXPECTED_REV",
843 "NOTES_MERGE_PARTIAL",
847 struct object_id oid
;
850 if (!is_pseudoref_syntax(refname
))
853 if (ends_with(refname
, "_HEAD")) {
854 refs_resolve_ref_unsafe(refs
, refname
,
855 RESOLVE_REF_READING
| RESOLVE_REF_NO_RECURSE
,
857 return !is_null_oid(&oid
);
860 for (i
= 0; i
< ARRAY_SIZE(irregular_pseudorefs
); i
++)
861 if (!strcmp(refname
, irregular_pseudorefs
[i
])) {
862 refs_resolve_ref_unsafe(refs
, refname
,
863 RESOLVE_REF_READING
| RESOLVE_REF_NO_RECURSE
,
865 return !is_null_oid(&oid
);
871 int is_headref(struct ref_store
*refs
, const char *refname
)
873 if (!strcmp(refname
, "HEAD"))
874 return refs_ref_exists(refs
, refname
);
879 static int is_current_worktree_ref(const char *ref
) {
880 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
883 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
884 const char **worktree_name
, int *worktree_name_length
,
885 const char **bare_refname
)
887 const char *name_dummy
;
888 int name_length_dummy
;
889 const char *ref_dummy
;
892 worktree_name
= &name_dummy
;
893 if (!worktree_name_length
)
894 worktree_name_length
= &name_length_dummy
;
896 bare_refname
= &ref_dummy
;
898 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
899 const char *slash
= strchr(*bare_refname
, '/');
901 *worktree_name
= *bare_refname
;
903 *worktree_name_length
= strlen(*worktree_name
);
905 /* This is an error condition, and the caller tell because the bare_refname is "" */
906 *bare_refname
= *worktree_name
+ *worktree_name_length
;
907 return REF_WORKTREE_OTHER
;
910 *worktree_name_length
= slash
- *bare_refname
;
911 *bare_refname
= slash
+ 1;
913 if (is_current_worktree_ref(*bare_refname
))
914 return REF_WORKTREE_OTHER
;
917 *worktree_name
= NULL
;
918 *worktree_name_length
= 0;
920 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
921 && is_current_worktree_ref(*bare_refname
))
922 return REF_WORKTREE_MAIN
;
924 *bare_refname
= maybe_worktree_ref
;
925 if (is_current_worktree_ref(maybe_worktree_ref
))
926 return REF_WORKTREE_CURRENT
;
928 return REF_WORKTREE_SHARED
;
931 long get_files_ref_lock_timeout_ms(void)
933 static int configured
= 0;
935 /* The default timeout is 100 ms: */
936 static int timeout_ms
= 100;
939 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
946 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
948 const struct object_id
*old_oid
,
951 struct ref_transaction
*transaction
;
952 struct strbuf err
= STRBUF_INIT
;
954 transaction
= ref_store_transaction_begin(refs
, &err
);
956 ref_transaction_delete(transaction
, refname
, old_oid
,
958 ref_transaction_commit(transaction
, &err
)) {
959 error("%s", err
.buf
);
960 ref_transaction_free(transaction
);
961 strbuf_release(&err
);
964 ref_transaction_free(transaction
);
965 strbuf_release(&err
);
969 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
974 while ((c
= *msg
++)) {
975 if (wasspace
&& isspace(c
))
977 wasspace
= isspace(c
);
985 static char *normalize_reflog_message(const char *msg
)
987 struct strbuf sb
= STRBUF_INIT
;
990 copy_reflog_msg(&sb
, msg
);
991 return strbuf_detach(&sb
, NULL
);
994 int should_autocreate_reflog(const char *refname
)
996 switch (log_all_ref_updates
) {
997 case LOG_REFS_ALWAYS
:
999 case LOG_REFS_NORMAL
:
1000 return starts_with(refname
, "refs/heads/") ||
1001 starts_with(refname
, "refs/remotes/") ||
1002 starts_with(refname
, "refs/notes/") ||
1003 !strcmp(refname
, "HEAD");
1009 int is_branch(const char *refname
)
1011 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
1014 struct read_ref_at_cb
{
1015 const char *refname
;
1016 timestamp_t at_time
;
1019 struct object_id
*oid
;
1022 struct object_id ooid
;
1023 struct object_id noid
;
1027 timestamp_t
*cutoff_time
;
1032 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
1033 timestamp_t timestamp
, int tz
, const char *message
)
1036 *cb
->msg
= xstrdup(message
);
1037 if (cb
->cutoff_time
)
1038 *cb
->cutoff_time
= timestamp
;
1040 *cb
->cutoff_tz
= tz
;
1042 *cb
->cutoff_cnt
= cb
->reccnt
;
1045 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1046 const char *email UNUSED
,
1047 timestamp_t timestamp
, int tz
,
1048 const char *message
, void *cb_data
)
1050 struct read_ref_at_cb
*cb
= cb_data
;
1053 cb
->date
= timestamp
;
1055 if (timestamp
<= cb
->at_time
|| cb
->cnt
== 0) {
1056 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1058 * we have not yet updated cb->[n|o]oid so they still
1059 * hold the values for the previous record.
1061 if (!is_null_oid(&cb
->ooid
)) {
1062 oidcpy(cb
->oid
, noid
);
1063 if (!oideq(&cb
->ooid
, noid
))
1064 warning(_("log for ref %s has gap after %s"),
1065 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1067 else if (cb
->date
== cb
->at_time
)
1068 oidcpy(cb
->oid
, noid
);
1069 else if (!oideq(noid
, cb
->oid
))
1070 warning(_("log for ref %s unexpectedly ended on %s"),
1071 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1072 DATE_MODE(RFC2822
)));
1074 oidcpy(&cb
->ooid
, ooid
);
1075 oidcpy(&cb
->noid
, noid
);
1080 oidcpy(&cb
->ooid
, ooid
);
1081 oidcpy(&cb
->noid
, noid
);
1087 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1088 const char *email UNUSED
,
1089 timestamp_t timestamp
, int tz
,
1090 const char *message
, void *cb_data
)
1092 struct read_ref_at_cb
*cb
= cb_data
;
1094 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1095 oidcpy(cb
->oid
, ooid
);
1096 if (cb
->at_time
&& is_null_oid(cb
->oid
))
1097 oidcpy(cb
->oid
, noid
);
1098 /* We just want the first entry */
1102 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1103 unsigned int flags
, timestamp_t at_time
, int cnt
,
1104 struct object_id
*oid
, char **msg
,
1105 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1107 struct read_ref_at_cb cb
;
1109 memset(&cb
, 0, sizeof(cb
));
1110 cb
.refname
= refname
;
1111 cb
.at_time
= at_time
;
1114 cb
.cutoff_time
= cutoff_time
;
1115 cb
.cutoff_tz
= cutoff_tz
;
1116 cb
.cutoff_cnt
= cutoff_cnt
;
1119 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1124 * The caller asked for ref@{0}, and we had no entries.
1125 * It's a bit subtle, but in practice all callers have
1126 * prepped the "oid" field with the current value of
1127 * the ref, which is the most reasonable fallback.
1129 * We'll put dummy values into the out-parameters (so
1130 * they're not just uninitialized garbage), and the
1131 * caller can take our return value as a hint that
1132 * we did not find any such reflog.
1134 set_read_ref_cutoffs(&cb
, 0, 0, "empty reflog");
1137 if (flags
& GET_OID_QUIETLY
)
1140 die(_("log for %s is empty"), refname
);
1145 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1150 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1153 struct ref_transaction
*tr
;
1156 CALLOC_ARRAY(tr
, 1);
1157 tr
->ref_store
= refs
;
1161 void ref_transaction_free(struct ref_transaction
*transaction
)
1168 switch (transaction
->state
) {
1169 case REF_TRANSACTION_OPEN
:
1170 case REF_TRANSACTION_CLOSED
:
1173 case REF_TRANSACTION_PREPARED
:
1174 BUG("free called on a prepared reference transaction");
1177 BUG("unexpected reference transaction state");
1181 for (i
= 0; i
< transaction
->nr
; i
++) {
1182 free(transaction
->updates
[i
]->msg
);
1183 free((char *)transaction
->updates
[i
]->new_target
);
1184 free((char *)transaction
->updates
[i
]->old_target
);
1185 free(transaction
->updates
[i
]);
1187 free(transaction
->updates
);
1191 struct ref_update
*ref_transaction_add_update(
1192 struct ref_transaction
*transaction
,
1193 const char *refname
, unsigned int flags
,
1194 const struct object_id
*new_oid
,
1195 const struct object_id
*old_oid
,
1196 const char *new_target
, const char *old_target
,
1199 struct ref_update
*update
;
1201 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1202 BUG("update called for transaction that is not open");
1204 if (old_oid
&& old_target
)
1205 BUG("only one of old_oid and old_target should be non NULL");
1206 if (new_oid
&& new_target
)
1207 BUG("only one of new_oid and new_target should be non NULL");
1209 FLEX_ALLOC_STR(update
, refname
, refname
);
1210 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1211 transaction
->updates
[transaction
->nr
++] = update
;
1213 update
->flags
= flags
;
1215 update
->new_target
= xstrdup_or_null(new_target
);
1216 update
->old_target
= xstrdup_or_null(old_target
);
1217 if ((flags
& REF_HAVE_NEW
) && new_oid
)
1218 oidcpy(&update
->new_oid
, new_oid
);
1219 if ((flags
& REF_HAVE_OLD
) && old_oid
)
1220 oidcpy(&update
->old_oid
, old_oid
);
1222 update
->msg
= normalize_reflog_message(msg
);
1226 int ref_transaction_update(struct ref_transaction
*transaction
,
1227 const char *refname
,
1228 const struct object_id
*new_oid
,
1229 const struct object_id
*old_oid
,
1230 const char *new_target
,
1231 const char *old_target
,
1232 unsigned int flags
, const char *msg
,
1237 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1238 ((new_oid
&& !is_null_oid(new_oid
)) ?
1239 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1240 !refname_is_safe(refname
))) {
1241 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1246 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1247 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1250 * Clear flags outside the allowed set; this should be a noop because
1251 * of the BUG() check above, but it works around a -Wnonnull warning
1252 * with some versions of "gcc -O3".
1254 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1256 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1257 flags
|= (new_target
? REF_HAVE_NEW
: 0) | (old_target
? REF_HAVE_OLD
: 0);
1259 ref_transaction_add_update(transaction
, refname
, flags
,
1260 new_oid
, old_oid
, new_target
,
1265 int ref_transaction_create(struct ref_transaction
*transaction
,
1266 const char *refname
,
1267 const struct object_id
*new_oid
,
1268 unsigned int flags
, const char *msg
,
1271 if (!new_oid
|| is_null_oid(new_oid
)) {
1272 strbuf_addf(err
, "'%s' has a null OID", refname
);
1275 return ref_transaction_update(transaction
, refname
, new_oid
,
1276 null_oid(), NULL
, NULL
, flags
,
1280 int ref_transaction_delete(struct ref_transaction
*transaction
,
1281 const char *refname
,
1282 const struct object_id
*old_oid
,
1283 unsigned int flags
, const char *msg
,
1286 if (old_oid
&& is_null_oid(old_oid
))
1287 BUG("delete called with old_oid set to zeros");
1288 return ref_transaction_update(transaction
, refname
,
1289 null_oid(), old_oid
,
1294 int ref_transaction_verify(struct ref_transaction
*transaction
,
1295 const char *refname
,
1296 const struct object_id
*old_oid
,
1301 BUG("verify called with old_oid set to NULL");
1302 return ref_transaction_update(transaction
, refname
,
1308 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1309 const char *refname
, const struct object_id
*new_oid
,
1310 const struct object_id
*old_oid
, unsigned int flags
,
1311 enum action_on_err onerr
)
1313 struct ref_transaction
*t
= NULL
;
1314 struct strbuf err
= STRBUF_INIT
;
1317 t
= ref_store_transaction_begin(refs
, &err
);
1319 ref_transaction_update(t
, refname
, new_oid
, old_oid
, NULL
, NULL
,
1320 flags
, msg
, &err
) ||
1321 ref_transaction_commit(t
, &err
)) {
1323 ref_transaction_free(t
);
1326 const char *str
= _("update_ref failed for ref '%s': %s");
1329 case UPDATE_REFS_MSG_ON_ERR
:
1330 error(str
, refname
, err
.buf
);
1332 case UPDATE_REFS_DIE_ON_ERR
:
1333 die(str
, refname
, err
.buf
);
1335 case UPDATE_REFS_QUIET_ON_ERR
:
1338 strbuf_release(&err
);
1341 strbuf_release(&err
);
1343 ref_transaction_free(t
);
1348 * Check that the string refname matches a rule of the form
1349 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1350 * "foo/%.*s/baz", and return the string "bar".
1352 static const char *match_parse_rule(const char *refname
, const char *rule
,
1356 * Check that rule matches refname up to the first percent in the rule.
1357 * We can bail immediately if not, but otherwise we leave "rule" at the
1358 * %-placeholder, and "refname" at the start of the potential matched
1361 while (*rule
!= '%') {
1363 BUG("rev-parse rule did not have percent");
1364 if (*refname
++ != *rule
++)
1369 * Check that our "%" is the expected placeholder. This assumes there
1370 * are no other percents (placeholder or quoted) in the string, but
1371 * that is sufficient for our rev-parse rules.
1373 if (!skip_prefix(rule
, "%.*s", &rule
))
1377 * And now check that our suffix (if any) matches.
1379 if (!strip_suffix(refname
, rule
, len
))
1382 return refname
; /* len set by strip_suffix() */
1385 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1386 const char *refname
, int strict
)
1389 struct strbuf resolved_buf
= STRBUF_INIT
;
1391 /* skip first rule, it will always match */
1392 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1394 int rules_to_fail
= i
;
1395 const char *short_name
;
1396 size_t short_name_len
;
1398 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1404 * in strict mode, all (except the matched one) rules
1405 * must fail to resolve to a valid non-ambiguous ref
1408 rules_to_fail
= NUM_REV_PARSE_RULES
;
1411 * check if the short name resolves to a valid ref,
1412 * but use only rules prior to the matched one
1414 for (j
= 0; j
< rules_to_fail
; j
++) {
1415 const char *rule
= ref_rev_parse_rules
[j
];
1417 /* skip matched rule */
1422 * the short name is ambiguous, if it resolves
1423 * (with this previous rule) to a valid ref
1424 * read_ref() returns 0 on success
1426 strbuf_reset(&resolved_buf
);
1427 strbuf_addf(&resolved_buf
, rule
,
1428 cast_size_t_to_int(short_name_len
),
1430 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1435 * short name is non-ambiguous if all previous rules
1436 * haven't resolved to a valid ref
1438 if (j
== rules_to_fail
) {
1439 strbuf_release(&resolved_buf
);
1440 return xmemdupz(short_name
, short_name_len
);
1444 strbuf_release(&resolved_buf
);
1445 return xstrdup(refname
);
1448 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1449 struct strvec
*hide_refs
)
1452 if (!strcmp("transfer.hiderefs", var
) ||
1453 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1454 !strcmp(key
, "hiderefs"))) {
1459 return config_error_nonbool(var
);
1461 /* drop const to remove trailing '/' characters */
1462 ref
= (char *)strvec_push(hide_refs
, value
);
1464 while (len
&& ref
[len
- 1] == '/')
1470 int ref_is_hidden(const char *refname
, const char *refname_full
,
1471 const struct strvec
*hide_refs
)
1475 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1476 const char *match
= hide_refs
->v
[i
];
1477 const char *subject
;
1481 if (*match
== '!') {
1486 if (*match
== '^') {
1487 subject
= refname_full
;
1493 /* refname can be NULL when namespaces are used. */
1495 skip_prefix(subject
, match
, &p
) &&
1502 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1504 const char **pattern
;
1505 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1507 * We can't feed any excludes from hidden refs config
1508 * sections, since later rules may override previous
1509 * ones. For example, with rules "refs/foo" and
1510 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1511 * everything underneath it), but the earlier exclusion
1512 * would cause us to skip all of "refs/foo". We
1513 * likewise don't implement the namespace stripping
1514 * required for '^' rules.
1516 * Both are possible to do, but complicated, so avoid
1517 * populating the jump list at all if we see either of
1520 if (**pattern
== '!' || **pattern
== '^')
1523 return hide_refs
->v
;
1526 const char *find_descendant_ref(const char *dirname
,
1527 const struct string_list
*extras
,
1528 const struct string_list
*skip
)
1536 * Look at the place where dirname would be inserted into
1537 * extras. If there is an entry at that position that starts
1538 * with dirname (remember, dirname includes the trailing
1539 * slash) and is not in skip, then we have a conflict.
1541 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1542 pos
< extras
->nr
; pos
++) {
1543 const char *extra_refname
= extras
->items
[pos
].string
;
1545 if (!starts_with(extra_refname
, dirname
))
1548 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1549 return extra_refname
;
1554 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1556 struct object_id oid
;
1559 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1561 return fn("HEAD", &oid
, flag
, cb_data
);
1566 struct ref_iterator
*refs_ref_iterator_begin(
1567 struct ref_store
*refs
,
1569 const char **exclude_patterns
,
1571 enum do_for_each_ref_flags flags
)
1573 struct ref_iterator
*iter
;
1575 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1576 static int ref_paranoia
= -1;
1578 if (ref_paranoia
< 0)
1579 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1581 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1582 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1586 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1588 * `iterator_begin()` already takes care of prefix, but we
1589 * might need to do some trimming:
1592 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1598 * Call fn for each reference in the specified submodule for which the
1599 * refname begins with prefix. If trim is non-zero, then trim that
1600 * many characters off the beginning of each refname before passing
1601 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1602 * include broken references in the iteration. If fn ever returns a
1603 * non-zero value, stop the iteration and return that value;
1604 * otherwise, return 0.
1606 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1607 each_repo_ref_fn fn
, int trim
, int flags
,
1610 struct ref_iterator
*iter
;
1611 struct ref_store
*refs
= get_main_ref_store(r
);
1616 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1618 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1621 struct do_for_each_ref_help
{
1626 static int do_for_each_ref_helper(struct repository
*r UNUSED
,
1627 const char *refname
,
1628 const struct object_id
*oid
,
1632 struct do_for_each_ref_help
*hp
= cb_data
;
1634 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1637 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1638 const char **exclude_patterns
,
1639 each_ref_fn fn
, int trim
,
1640 enum do_for_each_ref_flags flags
, void *cb_data
)
1642 struct ref_iterator
*iter
;
1643 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1648 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1651 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1652 do_for_each_ref_helper
, &hp
);
1655 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1657 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1660 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1661 each_ref_fn fn
, void *cb_data
)
1663 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1666 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1667 const char **exclude_patterns
,
1668 each_ref_fn fn
, void *cb_data
)
1670 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1673 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1675 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1676 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1677 strlen(git_replace_ref_base
),
1678 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1681 int refs_for_each_namespaced_ref(struct ref_store
*refs
,
1682 const char **exclude_patterns
,
1683 each_ref_fn fn
, void *cb_data
)
1685 struct strbuf buf
= STRBUF_INIT
;
1687 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1688 ret
= do_for_each_ref(refs
, buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1689 strbuf_release(&buf
);
1693 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1695 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1696 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1699 int refs_for_each_include_root_refs(struct ref_store
*refs
, each_ref_fn fn
,
1702 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1703 DO_FOR_EACH_INCLUDE_ROOT_REFS
, cb_data
);
1706 static int qsort_strcmp(const void *va
, const void *vb
)
1708 const char *a
= *(const char **)va
;
1709 const char *b
= *(const char **)vb
;
1711 return strcmp(a
, b
);
1714 static void find_longest_prefixes_1(struct string_list
*out
,
1715 struct strbuf
*prefix
,
1716 const char **patterns
, size_t nr
)
1720 for (i
= 0; i
< nr
; i
++) {
1721 char c
= patterns
[i
][prefix
->len
];
1722 if (!c
|| is_glob_special(c
)) {
1723 string_list_append(out
, prefix
->buf
);
1733 * Set "end" to the index of the element _after_ the last one
1736 for (end
= i
+ 1; end
< nr
; end
++) {
1737 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1741 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1742 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1743 strbuf_setlen(prefix
, prefix
->len
- 1);
1749 static void find_longest_prefixes(struct string_list
*out
,
1750 const char **patterns
)
1752 struct strvec sorted
= STRVEC_INIT
;
1753 struct strbuf prefix
= STRBUF_INIT
;
1755 strvec_pushv(&sorted
, patterns
);
1756 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1758 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1760 strvec_clear(&sorted
);
1761 strbuf_release(&prefix
);
1764 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1765 const char *namespace,
1766 const char **patterns
,
1767 const char **exclude_patterns
,
1768 each_ref_fn fn
, void *cb_data
)
1770 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1771 struct string_list_item
*prefix
;
1772 struct strbuf buf
= STRBUF_INIT
;
1773 int ret
= 0, namespace_len
;
1775 find_longest_prefixes(&prefixes
, patterns
);
1778 strbuf_addstr(&buf
, namespace);
1779 namespace_len
= buf
.len
;
1781 for_each_string_list_item(prefix
, &prefixes
) {
1782 strbuf_addstr(&buf
, prefix
->string
);
1783 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1784 exclude_patterns
, fn
, cb_data
);
1787 strbuf_setlen(&buf
, namespace_len
);
1790 string_list_clear(&prefixes
, 0);
1791 strbuf_release(&buf
);
1795 static int refs_read_special_head(struct ref_store
*ref_store
,
1796 const char *refname
, struct object_id
*oid
,
1797 struct strbuf
*referent
, unsigned int *type
,
1800 struct strbuf full_path
= STRBUF_INIT
;
1801 struct strbuf content
= STRBUF_INIT
;
1803 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1805 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1806 *failure_errno
= errno
;
1810 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1814 strbuf_release(&full_path
);
1815 strbuf_release(&content
);
1819 static int is_special_ref(const char *refname
)
1822 * Special references are refs that have different semantics compared
1823 * to "normal" refs. These refs can thus not be stored in the ref
1824 * backend, but must always be accessed via the filesystem. The
1825 * following refs are special:
1827 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1828 * carries additional metadata like where it came from.
1830 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1833 * Reading, writing or deleting references must consistently go either
1834 * through the filesystem (special refs) or through the reference
1835 * backend (normal ones).
1837 static const char * const special_refs
[] = {
1843 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1844 if (!strcmp(refname
, special_refs
[i
]))
1850 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1851 struct object_id
*oid
, struct strbuf
*referent
,
1852 unsigned int *type
, int *failure_errno
)
1854 assert(failure_errno
);
1855 if (is_special_ref(refname
))
1856 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1857 type
, failure_errno
);
1859 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1860 type
, failure_errno
);
1863 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1864 struct strbuf
*referent
)
1866 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1869 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1870 const char *refname
,
1872 struct object_id
*oid
,
1875 static struct strbuf sb_refname
= STRBUF_INIT
;
1876 struct object_id unused_oid
;
1883 flags
= &unused_flags
;
1887 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1888 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1889 !refname_is_safe(refname
))
1893 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1894 * missing refs and refs that were present but invalid,
1895 * to complain about the latter to stderr.
1897 * We don't know whether the ref exists, so don't set
1900 *flags
|= REF_BAD_NAME
;
1903 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1904 unsigned int read_flags
= 0;
1907 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1908 &read_flags
, &failure_errno
)) {
1909 *flags
|= read_flags
;
1911 /* In reading mode, refs must eventually resolve */
1912 if (resolve_flags
& RESOLVE_REF_READING
)
1916 * Otherwise a missing ref is OK. But the files backend
1917 * may show errors besides ENOENT if there are
1918 * similarly-named refs.
1920 if (failure_errno
!= ENOENT
&&
1921 failure_errno
!= EISDIR
&&
1922 failure_errno
!= ENOTDIR
)
1926 if (*flags
& REF_BAD_NAME
)
1927 *flags
|= REF_ISBROKEN
;
1931 *flags
|= read_flags
;
1933 if (!(read_flags
& REF_ISSYMREF
)) {
1934 if (*flags
& REF_BAD_NAME
) {
1936 *flags
|= REF_ISBROKEN
;
1941 refname
= sb_refname
.buf
;
1942 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1946 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1947 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1948 !refname_is_safe(refname
))
1951 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1958 /* backend functions */
1959 int refs_init_db(struct ref_store
*refs
, int flags
, struct strbuf
*err
)
1961 return refs
->be
->init_db(refs
, flags
, err
);
1964 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1965 struct object_id
*oid
)
1967 struct ref_store
*refs
;
1970 refs
= get_submodule_ref_store(submodule
);
1975 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1981 struct ref_store_hash_entry
1983 struct hashmap_entry ent
;
1985 struct ref_store
*refs
;
1987 /* NUL-terminated identifier of the ref store: */
1988 char name
[FLEX_ARRAY
];
1991 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
1992 const struct hashmap_entry
*eptr
,
1993 const struct hashmap_entry
*entry_or_key
,
1994 const void *keydata
)
1996 const struct ref_store_hash_entry
*e1
, *e2
;
1999 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2000 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2001 name
= keydata
? keydata
: e2
->name
;
2003 return strcmp(e1
->name
, name
);
2006 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2007 const char *name
, struct ref_store
*refs
)
2009 struct ref_store_hash_entry
*entry
;
2011 FLEX_ALLOC_STR(entry
, name
, name
);
2012 hashmap_entry_init(&entry
->ent
, strhash(name
));
2017 /* A hashmap of ref_stores, stored by submodule name: */
2018 static struct hashmap submodule_ref_stores
;
2020 /* A hashmap of ref_stores, stored by worktree id: */
2021 static struct hashmap worktree_ref_stores
;
2024 * Look up a ref store by name. If that ref_store hasn't been
2025 * registered yet, return NULL.
2027 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2030 struct ref_store_hash_entry
*entry
;
2033 if (!map
->tablesize
)
2034 /* It's initialized on demand in register_ref_store(). */
2037 hash
= strhash(name
);
2038 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2039 struct ref_store_hash_entry
, ent
);
2040 return entry
? entry
->refs
: NULL
;
2044 * Create, record, and return a ref_store instance for the specified
2047 static struct ref_store
*ref_store_init(struct repository
*repo
,
2051 const struct ref_storage_be
*be
;
2052 struct ref_store
*refs
;
2054 be
= find_ref_storage_backend(repo
->ref_storage_format
);
2056 BUG("reference backend is unknown");
2058 refs
= be
->init(repo
, gitdir
, flags
);
2062 struct ref_store
*get_main_ref_store(struct repository
*r
)
2064 if (r
->refs_private
)
2065 return r
->refs_private
;
2068 BUG("attempting to get main_ref_store outside of repository");
2070 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2071 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2072 return r
->refs_private
;
2076 * Associate a ref store with a name. It is a fatal error to call this
2077 * function twice for the same name.
2079 static void register_ref_store_map(struct hashmap
*map
,
2081 struct ref_store
*refs
,
2084 struct ref_store_hash_entry
*entry
;
2086 if (!map
->tablesize
)
2087 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2089 entry
= alloc_ref_store_hash_entry(name
, refs
);
2090 if (hashmap_put(map
, &entry
->ent
))
2091 BUG("%s ref_store '%s' initialized twice", type
, name
);
2094 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2096 struct strbuf submodule_sb
= STRBUF_INIT
;
2097 struct ref_store
*refs
;
2098 char *to_free
= NULL
;
2100 struct repository
*subrepo
;
2105 len
= strlen(submodule
);
2106 while (len
&& is_dir_sep(submodule
[len
- 1]))
2112 /* We need to strip off one or more trailing slashes */
2113 submodule
= to_free
= xmemdupz(submodule
, len
);
2115 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2119 strbuf_addstr(&submodule_sb
, submodule
);
2120 if (!is_nonbare_repository_dir(&submodule_sb
))
2123 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2126 subrepo
= xmalloc(sizeof(*subrepo
));
2128 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2129 * superprojects other than the_repository. This probably should be
2130 * done by making it take a struct repository * parameter instead of a
2133 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2138 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2139 REF_STORE_READ
| REF_STORE_ODB
);
2140 register_ref_store_map(&submodule_ref_stores
, "submodule",
2144 strbuf_release(&submodule_sb
);
2150 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2152 struct ref_store
*refs
;
2156 return get_main_ref_store(the_repository
);
2158 id
= wt
->id
? wt
->id
: "/";
2159 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2164 refs
= ref_store_init(the_repository
,
2165 git_common_path("worktrees/%s", wt
->id
),
2166 REF_STORE_ALL_CAPS
);
2168 refs
= ref_store_init(the_repository
,
2169 get_git_common_dir(),
2170 REF_STORE_ALL_CAPS
);
2173 register_ref_store_map(&worktree_ref_stores
, "worktree",
2178 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2179 const char *path
, const struct ref_storage_be
*be
)
2183 refs
->gitdir
= xstrdup(path
);
2186 /* backend functions */
2187 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2189 return refs
->be
->pack_refs(refs
, opts
);
2192 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2194 if (current_ref_iter
&&
2195 (current_ref_iter
->oid
== base
||
2196 oideq(current_ref_iter
->oid
, base
)))
2197 return ref_iterator_peel(current_ref_iter
, peeled
);
2199 return peel_object(base
, peeled
) ? -1 : 0;
2202 int refs_update_symref(struct ref_store
*refs
, const char *ref
,
2203 const char *target
, const char *logmsg
)
2205 struct ref_transaction
*transaction
;
2206 struct strbuf err
= STRBUF_INIT
;
2209 transaction
= ref_store_transaction_begin(refs
, &err
);
2211 ref_transaction_update(transaction
, ref
, NULL
, NULL
,
2212 target
, NULL
, REF_NO_DEREF
,
2214 ref_transaction_commit(transaction
, &err
)) {
2215 ret
= error("%s", err
.buf
);
2218 strbuf_release(&err
);
2220 ref_transaction_free(transaction
);
2225 int ref_update_reject_duplicates(struct string_list
*refnames
,
2228 size_t i
, n
= refnames
->nr
;
2232 for (i
= 1; i
< n
; i
++) {
2233 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2234 refnames
->items
[i
].string
);
2238 _("multiple updates for ref '%s' not allowed"),
2239 refnames
->items
[i
].string
);
2241 } else if (cmp
> 0) {
2242 BUG("ref_update_reject_duplicates() received unsorted list");
2248 static int run_transaction_hook(struct ref_transaction
*transaction
,
2251 struct child_process proc
= CHILD_PROCESS_INIT
;
2252 struct strbuf buf
= STRBUF_INIT
;
2256 hook
= find_hook("reference-transaction");
2260 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2262 proc
.stdout_to_stderr
= 1;
2263 proc
.trace2_hook_name
= "reference-transaction";
2265 ret
= start_command(&proc
);
2269 sigchain_push(SIGPIPE
, SIG_IGN
);
2271 for (i
= 0; i
< transaction
->nr
; i
++) {
2272 struct ref_update
*update
= transaction
->updates
[i
];
2276 if (!(update
->flags
& REF_HAVE_OLD
))
2277 strbuf_addf(&buf
, "%s ", oid_to_hex(null_oid()));
2278 else if (update
->old_target
)
2279 strbuf_addf(&buf
, "ref:%s ", update
->old_target
);
2281 strbuf_addf(&buf
, "%s ", oid_to_hex(&update
->old_oid
));
2283 if (!(update
->flags
& REF_HAVE_NEW
))
2284 strbuf_addf(&buf
, "%s ", oid_to_hex(null_oid()));
2285 else if (update
->new_target
)
2286 strbuf_addf(&buf
, "ref:%s ", update
->new_target
);
2288 strbuf_addf(&buf
, "%s ", oid_to_hex(&update
->new_oid
));
2290 strbuf_addf(&buf
, "%s\n", update
->refname
);
2292 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2293 if (errno
!= EPIPE
) {
2294 /* Don't leak errno outside this API */
2303 sigchain_pop(SIGPIPE
);
2304 strbuf_release(&buf
);
2306 ret
|= finish_command(&proc
);
2310 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2313 struct ref_store
*refs
= transaction
->ref_store
;
2316 switch (transaction
->state
) {
2317 case REF_TRANSACTION_OPEN
:
2320 case REF_TRANSACTION_PREPARED
:
2321 BUG("prepare called twice on reference transaction");
2323 case REF_TRANSACTION_CLOSED
:
2324 BUG("prepare called on a closed reference transaction");
2327 BUG("unexpected reference transaction state");
2331 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2333 _("ref updates forbidden inside quarantine environment"));
2337 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2341 ret
= run_transaction_hook(transaction
, "prepared");
2343 ref_transaction_abort(transaction
, err
);
2344 die(_("ref updates aborted by hook"));
2350 int ref_transaction_abort(struct ref_transaction
*transaction
,
2353 struct ref_store
*refs
= transaction
->ref_store
;
2356 switch (transaction
->state
) {
2357 case REF_TRANSACTION_OPEN
:
2358 /* No need to abort explicitly. */
2360 case REF_TRANSACTION_PREPARED
:
2361 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2363 case REF_TRANSACTION_CLOSED
:
2364 BUG("abort called on a closed reference transaction");
2367 BUG("unexpected reference transaction state");
2371 run_transaction_hook(transaction
, "aborted");
2373 ref_transaction_free(transaction
);
2377 int ref_transaction_commit(struct ref_transaction
*transaction
,
2380 struct ref_store
*refs
= transaction
->ref_store
;
2383 switch (transaction
->state
) {
2384 case REF_TRANSACTION_OPEN
:
2385 /* Need to prepare first. */
2386 ret
= ref_transaction_prepare(transaction
, err
);
2390 case REF_TRANSACTION_PREPARED
:
2391 /* Fall through to finish. */
2393 case REF_TRANSACTION_CLOSED
:
2394 BUG("commit called on a closed reference transaction");
2397 BUG("unexpected reference transaction state");
2401 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2403 run_transaction_hook(transaction
, "committed");
2407 int refs_verify_refname_available(struct ref_store
*refs
,
2408 const char *refname
,
2409 const struct string_list
*extras
,
2410 const struct string_list
*skip
,
2414 const char *extra_refname
;
2415 struct strbuf dirname
= STRBUF_INIT
;
2416 struct strbuf referent
= STRBUF_INIT
;
2417 struct object_id oid
;
2419 struct ref_iterator
*iter
;
2424 * For the sake of comments in this function, suppose that
2425 * refname is "refs/foo/bar".
2430 strbuf_grow(&dirname
, strlen(refname
) + 1);
2431 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2433 * Just saying "Is a directory" when we e.g. can't
2434 * lock some multi-level ref isn't very informative,
2435 * the user won't be told *what* is a directory, so
2436 * let's not use strerror() below.
2439 /* Expand dirname to the new prefix, not including the trailing slash: */
2440 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2443 * We are still at a leading dir of the refname (e.g.,
2444 * "refs/foo"; if there is a reference with that name,
2445 * it is a conflict, *unless* it is in skip.
2447 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2450 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2451 &type
, &ignore_errno
)) {
2452 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2453 dirname
.buf
, refname
);
2457 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2458 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2459 refname
, dirname
.buf
);
2465 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2466 * There is no point in searching for a reference with that
2467 * name, because a refname isn't considered to conflict with
2468 * itself. But we still need to check for references whose
2469 * names are in the "refs/foo/bar/" namespace, because they
2472 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2473 strbuf_addch(&dirname
, '/');
2475 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2476 DO_FOR_EACH_INCLUDE_BROKEN
);
2477 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2479 string_list_has_string(skip
, iter
->refname
))
2482 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2483 iter
->refname
, refname
);
2484 ref_iterator_abort(iter
);
2488 if (ok
!= ITER_DONE
)
2489 BUG("error while iterating over references");
2491 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2493 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2494 refname
, extra_refname
);
2499 strbuf_release(&referent
);
2500 strbuf_release(&dirname
);
2504 struct do_for_each_reflog_help
{
2509 static int do_for_each_reflog_helper(struct repository
*r UNUSED
,
2510 const char *refname
,
2511 const struct object_id
*oid UNUSED
,
2515 struct do_for_each_reflog_help
*hp
= cb_data
;
2516 return hp
->fn(refname
, hp
->cb_data
);
2519 int refs_for_each_reflog(struct ref_store
*refs
, each_reflog_fn fn
, void *cb_data
)
2521 struct ref_iterator
*iter
;
2522 struct do_for_each_reflog_help hp
= { fn
, cb_data
};
2524 iter
= refs
->be
->reflog_iterator_begin(refs
);
2526 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2527 do_for_each_reflog_helper
, &hp
);
2530 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2531 const char *refname
,
2532 each_reflog_ent_fn fn
,
2535 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2539 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2540 each_reflog_ent_fn fn
, void *cb_data
)
2542 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2545 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2547 return refs
->be
->reflog_exists(refs
, refname
);
2550 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2553 return refs
->be
->create_reflog(refs
, refname
, err
);
2556 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2558 return refs
->be
->delete_reflog(refs
, refname
);
2561 int refs_reflog_expire(struct ref_store
*refs
,
2562 const char *refname
,
2564 reflog_expiry_prepare_fn prepare_fn
,
2565 reflog_expiry_should_prune_fn should_prune_fn
,
2566 reflog_expiry_cleanup_fn cleanup_fn
,
2567 void *policy_cb_data
)
2569 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2570 prepare_fn
, should_prune_fn
,
2571 cleanup_fn
, policy_cb_data
);
2574 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2577 struct ref_store
*refs
= transaction
->ref_store
;
2579 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2582 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2583 ref_transaction_for_each_queued_update_fn cb
,
2588 for (i
= 0; i
< transaction
->nr
; i
++) {
2589 struct ref_update
*update
= transaction
->updates
[i
];
2592 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2593 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2598 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2599 struct string_list
*refnames
, unsigned int flags
)
2601 struct ref_transaction
*transaction
;
2602 struct strbuf err
= STRBUF_INIT
;
2603 struct string_list_item
*item
;
2604 int ret
= 0, failures
= 0;
2610 msg
= normalize_reflog_message(logmsg
);
2613 * Since we don't check the references' old_oids, the
2614 * individual updates can't fail, so we can pack all of the
2615 * updates into a single transaction.
2617 transaction
= ref_store_transaction_begin(refs
, &err
);
2619 ret
= error("%s", err
.buf
);
2623 for_each_string_list_item(item
, refnames
) {
2624 ret
= ref_transaction_delete(transaction
, item
->string
,
2625 NULL
, flags
, msg
, &err
);
2627 warning(_("could not delete reference %s: %s"),
2628 item
->string
, err
.buf
);
2634 ret
= ref_transaction_commit(transaction
, &err
);
2636 if (refnames
->nr
== 1)
2637 error(_("could not delete reference %s: %s"),
2638 refnames
->items
[0].string
, err
.buf
);
2640 error(_("could not delete references: %s"), err
.buf
);
2644 if (!ret
&& failures
)
2646 ref_transaction_free(transaction
);
2647 strbuf_release(&err
);
2652 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2653 const char *newref
, const char *logmsg
)
2658 msg
= normalize_reflog_message(logmsg
);
2659 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2664 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2665 const char *newref
, const char *logmsg
)
2670 msg
= normalize_reflog_message(logmsg
);
2671 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2676 const char *ref_update_original_update_refname(struct ref_update
*update
)
2678 while (update
->parent_update
)
2679 update
= update
->parent_update
;
2681 return update
->refname
;
2684 int ref_update_has_null_new_value(struct ref_update
*update
)
2686 return !update
->new_target
&& is_null_oid(&update
->new_oid
);
2689 int ref_update_check_old_target(const char *referent
, struct ref_update
*update
,
2692 if (!update
->old_target
)
2693 BUG("called without old_target set");
2695 if (!strcmp(referent
, update
->old_target
))
2698 if (!strcmp(referent
, ""))
2699 strbuf_addf(err
, "verifying symref target: '%s': "
2700 "reference is missing but expected %s",
2701 ref_update_original_update_refname(update
),
2702 update
->old_target
);
2704 strbuf_addf(err
, "verifying symref target: '%s': "
2705 "is at %s but expected %s",
2706 ref_update_original_update_refname(update
),
2707 referent
, update
->old_target
);