2 * The backend-independent part of the reference module.
5 #include "git-compat-util.h"
8 #include "environment.h"
15 #include "refs/refs-internal.h"
16 #include "run-command.h"
18 #include "object-name.h"
19 #include "object-store-ll.h"
23 #include "submodule.h"
26 #include "repository.h"
31 #include "wildmatch.h"
34 * List of all available backends
36 static const struct ref_storage_be
*refs_backends
[] = {
37 [REF_STORAGE_FORMAT_FILES
] = &refs_be_files
,
38 [REF_STORAGE_FORMAT_REFTABLE
] = &refs_be_reftable
,
41 static const struct ref_storage_be
*find_ref_storage_backend(unsigned int ref_storage_format
)
43 if (ref_storage_format
< ARRAY_SIZE(refs_backends
))
44 return refs_backends
[ref_storage_format
];
48 unsigned int ref_storage_format_by_name(const char *name
)
50 for (unsigned int i
= 0; i
< ARRAY_SIZE(refs_backends
); i
++)
51 if (refs_backends
[i
] && !strcmp(refs_backends
[i
]->name
, name
))
53 return REF_STORAGE_FORMAT_UNKNOWN
;
56 const char *ref_storage_format_to_name(unsigned int ref_storage_format
)
58 const struct ref_storage_be
*be
= find_ref_storage_backend(ref_storage_format
);
65 * How to handle various characters in refnames:
66 * 0: An acceptable character for refs
68 * 2: ., look for a preceding . to reject .. in refs
69 * 3: {, look for a preceding @ to reject @{ in refs
70 * 4: A bad character: ASCII control characters, and
71 * ":", "?", "[", "\", "^", "~", SP, or TAB
72 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
74 static unsigned char refname_disposition
[256] = {
75 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
82 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
85 struct ref_namespace_info ref_namespace
[] = {
88 .decoration
= DECORATION_REF_HEAD
,
91 [NAMESPACE_BRANCHES
] = {
93 .decoration
= DECORATION_REF_LOCAL
,
97 .decoration
= DECORATION_REF_TAG
,
99 [NAMESPACE_REMOTE_REFS
] = {
101 * The default refspec for new remotes copies refs from
102 * refs/heads/ on the remote into refs/remotes/<remote>/.
103 * As such, "refs/remotes/" has special handling.
105 .ref
= "refs/remotes/",
106 .decoration
= DECORATION_REF_REMOTE
,
108 [NAMESPACE_STASH
] = {
110 * The single ref "refs/stash" stores the latest stash.
111 * Older stashes can be found in the reflog.
115 .decoration
= DECORATION_REF_STASH
,
117 [NAMESPACE_REPLACE
] = {
119 * This namespace allows Git to act as if one object ID
120 * points to the content of another. Unlike the other
121 * ref namespaces, this one can be changed by the
122 * GIT_REPLACE_REF_BASE environment variable. This
123 * .namespace value will be overwritten in setup_git_env().
125 .ref
= "refs/replace/",
126 .decoration
= DECORATION_GRAFTED
,
128 [NAMESPACE_NOTES
] = {
130 * The refs/notes/commit ref points to the tip of a
131 * parallel commit history that adds metadata to commits
132 * in the normal history. This ref can be overwritten
133 * by the core.notesRef config variable or the
134 * GIT_NOTES_REFS environment variable.
136 .ref
= "refs/notes/commit",
139 [NAMESPACE_PREFETCH
] = {
141 * Prefetch refs are written by the background 'fetch'
142 * maintenance task. It allows faster foreground fetches
143 * by advertising these previously-downloaded tips without
144 * updating refs/remotes/ without user intervention.
146 .ref
= "refs/prefetch/",
148 [NAMESPACE_REWRITTEN
] = {
150 * Rewritten refs are used by the 'label' command in the
151 * sequencer. These are particularly useful during an
152 * interactive rebase that uses the 'merge' command.
154 .ref
= "refs/rewritten/",
158 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
160 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
161 if (info
->ref_updated
)
164 info
->ref_updated
= 1;
168 * Try to read one refname component from the front of refname.
169 * Return the length of the component found, or -1 if the component is
170 * not legal. It is legal if it is something reasonable to have under
171 * ".git/refs/"; We do not like it if:
173 * - it begins with ".", or
174 * - it has double dots "..", or
175 * - it has ASCII control characters, or
176 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
177 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
178 * - it ends with a "/", or
179 * - it ends with ".lock", or
180 * - it contains a "@{" portion
182 * When sanitized is not NULL, instead of rejecting the input refname
183 * as an error, try to come up with a usable replacement for the input
186 static int check_refname_component(const char *refname
, int *flags
,
187 struct strbuf
*sanitized
)
191 size_t component_start
= 0; /* garbage - not a reasonable initial value */
194 component_start
= sanitized
->len
;
196 for (cp
= refname
; ; cp
++) {
198 unsigned char disp
= refname_disposition
[ch
];
200 if (sanitized
&& disp
!= 1)
201 strbuf_addch(sanitized
, ch
);
207 if (last
== '.') { /* Refname contains "..". */
209 /* collapse ".." to single "." */
210 strbuf_setlen(sanitized
, sanitized
->len
- 1);
216 if (last
== '@') { /* Refname contains "@{". */
218 sanitized
->buf
[sanitized
->len
-1] = '-';
226 sanitized
->buf
[sanitized
->len
-1] = '-';
231 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
232 /* refspec can't be a pattern */
234 sanitized
->buf
[sanitized
->len
-1] = '-';
240 * Unset the pattern flag so that we only accept
241 * a single asterisk for one side of refspec.
243 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
250 return 0; /* Component has zero length. */
252 if (refname
[0] == '.') { /* Component starts with '.'. */
254 sanitized
->buf
[component_start
] = '-';
258 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
259 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
262 /* Refname ends with ".lock". */
263 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
264 /* try again in case we have .lock.lock */
270 static int check_or_sanitize_refname(const char *refname
, int flags
,
271 struct strbuf
*sanitized
)
273 int component_len
, component_count
= 0;
275 if (!strcmp(refname
, "@")) {
276 /* Refname is a single character '@'. */
278 strbuf_addch(sanitized
, '-');
284 if (sanitized
&& sanitized
->len
)
285 strbuf_complete(sanitized
, '/');
287 /* We are at the start of a path component. */
288 component_len
= check_refname_component(refname
, &flags
,
290 if (sanitized
&& component_len
== 0)
291 ; /* OK, omit empty component */
292 else if (component_len
<= 0)
296 if (refname
[component_len
] == '\0')
298 /* Skip to next component. */
299 refname
+= component_len
+ 1;
302 if (refname
[component_len
- 1] == '.') {
303 /* Refname ends with '.'. */
305 ; /* omit ending dot */
309 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
310 return -1; /* Refname has only one component. */
314 int check_refname_format(const char *refname
, int flags
)
316 return check_or_sanitize_refname(refname
, flags
, NULL
);
319 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
321 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
322 BUG("sanitizing refname '%s' check returned error", refname
);
325 int refname_is_safe(const char *refname
)
329 if (skip_prefix(refname
, "refs/", &rest
)) {
332 size_t restlen
= strlen(rest
);
334 /* rest must not be empty, or start or end with "/" */
335 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
339 * Does the refname try to escape refs/?
340 * For example: refs/foo/../bar is safe but refs/foo/../../bar
343 buf
= xmallocz(restlen
);
344 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
350 if (!isupper(*refname
) && *refname
!= '_')
358 * Return true if refname, which has the specified oid and flags, can
359 * be resolved to an object in the database. If the referred-to object
360 * does not exist, emit a warning and return false.
362 int ref_resolves_to_object(const char *refname
,
363 struct repository
*repo
,
364 const struct object_id
*oid
,
367 if (flags
& REF_ISBROKEN
)
369 if (!repo_has_object_file(repo
, oid
)) {
370 error(_("%s does not point to a valid object!"), refname
);
376 char *refs_resolve_refdup(struct ref_store
*refs
,
377 const char *refname
, int resolve_flags
,
378 struct object_id
*oid
, int *flags
)
382 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
384 return xstrdup_or_null(result
);
387 char *resolve_refdup(const char *refname
, int resolve_flags
,
388 struct object_id
*oid
, int *flags
)
390 return refs_resolve_refdup(get_main_ref_store(the_repository
),
391 refname
, resolve_flags
,
395 /* The argument to for_each_filter_refs */
396 struct for_each_ref_filter
{
403 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
405 struct ref_store
*refs
= get_main_ref_store(the_repository
);
407 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
413 int read_ref(const char *refname
, struct object_id
*oid
)
415 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
418 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
420 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
424 int ref_exists(const char *refname
)
426 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
429 static int for_each_filter_refs(const char *refname
,
430 const struct object_id
*oid
,
431 int flags
, void *data
)
433 struct for_each_ref_filter
*filter
= data
;
435 if (wildmatch(filter
->pattern
, refname
, 0))
438 skip_prefix(refname
, filter
->prefix
, &refname
);
439 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
442 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
444 struct object
*o
= lookup_unknown_object(the_repository
, name
);
446 if (o
->type
== OBJ_NONE
) {
447 int type
= oid_object_info(the_repository
, name
, NULL
);
448 if (type
< 0 || !object_as_type(o
, type
, 0))
452 if (o
->type
!= OBJ_TAG
)
455 o
= deref_tag_noverify(o
);
459 oidcpy(oid
, &o
->oid
);
463 struct warn_if_dangling_data
{
466 const struct string_list
*refnames
;
470 static int warn_if_dangling_symref(const char *refname
,
471 const struct object_id
*oid UNUSED
,
472 int flags
, void *cb_data
)
474 struct warn_if_dangling_data
*d
= cb_data
;
475 const char *resolves_to
;
477 if (!(flags
& REF_ISSYMREF
))
480 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
483 ? strcmp(resolves_to
, d
->refname
)
484 : !string_list_has_string(d
->refnames
, resolves_to
))) {
488 fprintf(d
->fp
, d
->msg_fmt
, refname
);
493 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
495 struct warn_if_dangling_data data
;
498 data
.refname
= refname
;
499 data
.refnames
= NULL
;
500 data
.msg_fmt
= msg_fmt
;
501 for_each_rawref(warn_if_dangling_symref
, &data
);
504 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
506 struct warn_if_dangling_data data
;
510 data
.refnames
= refnames
;
511 data
.msg_fmt
= msg_fmt
;
512 for_each_rawref(warn_if_dangling_symref
, &data
);
515 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
517 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
520 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
522 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
525 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
527 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
530 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
532 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
535 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
537 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
540 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
542 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
545 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
547 struct strbuf buf
= STRBUF_INIT
;
549 struct object_id oid
;
552 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
553 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
554 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
555 strbuf_release(&buf
);
560 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
563 struct strbuf normalized_pattern
= STRBUF_INIT
;
566 BUG("pattern must not start with '/'");
569 strbuf_addstr(&normalized_pattern
, prefix
);
570 else if (!starts_with(pattern
, "refs/") &&
571 strcmp(pattern
, "HEAD"))
572 strbuf_addstr(&normalized_pattern
, "refs/");
574 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
578 strbuf_addstr(&normalized_pattern
, pattern
);
579 strbuf_strip_suffix(&normalized_pattern
, "/");
581 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
582 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
583 strbuf_release(&normalized_pattern
);
586 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
587 const char *prefix
, void *cb_data
)
589 struct strbuf real_pattern
= STRBUF_INIT
;
590 struct for_each_ref_filter filter
;
593 if (!prefix
&& !starts_with(pattern
, "refs/"))
594 strbuf_addstr(&real_pattern
, "refs/");
596 strbuf_addstr(&real_pattern
, prefix
);
597 strbuf_addstr(&real_pattern
, pattern
);
599 if (!has_glob_specials(pattern
)) {
600 /* Append implied '/' '*' if not present. */
601 strbuf_complete(&real_pattern
, '/');
602 /* No need to check for '*', there is none. */
603 strbuf_addch(&real_pattern
, '*');
606 filter
.pattern
= real_pattern
.buf
;
607 filter
.prefix
= prefix
;
609 filter
.cb_data
= cb_data
;
610 ret
= for_each_ref(for_each_filter_refs
, &filter
);
612 strbuf_release(&real_pattern
);
616 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
618 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
621 const char *prettify_refname(const char *name
)
623 if (skip_prefix(name
, "refs/heads/", &name
) ||
624 skip_prefix(name
, "refs/tags/", &name
) ||
625 skip_prefix(name
, "refs/remotes/", &name
))
630 static const char *ref_rev_parse_rules
[] = {
636 "refs/remotes/%.*s/HEAD",
640 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
643 * Is it possible that the caller meant full_name with abbrev_name?
644 * If so return a non-zero value to signal "yes"; the magnitude of
645 * the returned value gives the precedence used for disambiguation.
647 * If abbrev_name cannot mean full_name, return 0.
649 int refname_match(const char *abbrev_name
, const char *full_name
)
652 const int abbrev_name_len
= strlen(abbrev_name
);
653 const int num_rules
= NUM_REV_PARSE_RULES
;
655 for (p
= ref_rev_parse_rules
; *p
; p
++)
656 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
657 return &ref_rev_parse_rules
[num_rules
] - p
;
663 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
664 * the results to 'prefixes'
666 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
669 int len
= strlen(prefix
);
671 for (p
= ref_rev_parse_rules
; *p
; p
++)
672 strvec_pushf(prefixes
, *p
, len
, prefix
);
675 static const char default_branch_name_advice
[] = N_(
676 "Using '%s' as the name for the initial branch. This default branch name\n"
677 "is subject to change. To configure the initial branch name to use in all\n"
678 "of your new repositories, which will suppress this warning, call:\n"
680 "\tgit config --global init.defaultBranch <name>\n"
682 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
683 "'development'. The just-created branch can be renamed via this command:\n"
685 "\tgit branch -m <name>\n"
688 char *repo_default_branch_name(struct repository
*r
, int quiet
)
690 const char *config_key
= "init.defaultbranch";
691 const char *config_display_key
= "init.defaultBranch";
692 char *ret
= NULL
, *full_ref
;
693 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
697 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
698 die(_("could not retrieve `%s`"), config_display_key
);
701 ret
= xstrdup("master");
703 advise(_(default_branch_name_advice
), ret
);
706 full_ref
= xstrfmt("refs/heads/%s", ret
);
707 if (check_refname_format(full_ref
, 0))
708 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
714 const char *git_default_branch_name(int quiet
)
719 ret
= repo_default_branch_name(the_repository
, quiet
);
725 * *string and *len will only be substituted, and *string returned (for
726 * later free()ing) if the string passed in is a magic short-hand form
729 static char *substitute_branch_name(struct repository
*r
,
730 const char **string
, int *len
,
731 int nonfatal_dangling_mark
)
733 struct strbuf buf
= STRBUF_INIT
;
734 struct interpret_branch_name_options options
= {
735 .nonfatal_dangling_mark
= nonfatal_dangling_mark
737 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
741 *string
= strbuf_detach(&buf
, &size
);
743 return (char *)*string
;
749 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
750 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
752 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
753 nonfatal_dangling_mark
);
754 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
759 int expand_ref(struct repository
*repo
, const char *str
, int len
,
760 struct object_id
*oid
, char **ref
)
764 struct strbuf fullref
= STRBUF_INIT
;
767 for (p
= ref_rev_parse_rules
; *p
; p
++) {
768 struct object_id oid_from_ref
;
769 struct object_id
*this_result
;
771 struct ref_store
*refs
= get_main_ref_store(repo
);
773 this_result
= refs_found
? &oid_from_ref
: oid
;
774 strbuf_reset(&fullref
);
775 strbuf_addf(&fullref
, *p
, len
, str
);
776 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
782 if (!warn_ambiguous_refs
)
784 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
785 warning(_("ignoring dangling symref %s"), fullref
.buf
);
786 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
787 warning(_("ignoring broken ref %s"), fullref
.buf
);
790 strbuf_release(&fullref
);
794 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
795 struct object_id
*oid
, char **log
)
797 struct ref_store
*refs
= get_main_ref_store(r
);
798 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
801 struct strbuf path
= STRBUF_INIT
;
804 for (p
= ref_rev_parse_rules
; *p
; p
++) {
805 struct object_id hash
;
806 const char *ref
, *it
;
809 strbuf_addf(&path
, *p
, len
, str
);
810 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
812 oid
? &hash
: NULL
, NULL
);
815 if (refs_reflog_exists(refs
, path
.buf
))
817 else if (strcmp(ref
, path
.buf
) &&
818 refs_reflog_exists(refs
, ref
))
827 if (!warn_ambiguous_refs
)
830 strbuf_release(&path
);
835 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
837 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
840 int is_per_worktree_ref(const char *refname
)
842 return starts_with(refname
, "refs/worktree/") ||
843 starts_with(refname
, "refs/bisect/") ||
844 starts_with(refname
, "refs/rewritten/");
847 static int is_pseudoref_syntax(const char *refname
)
851 for (c
= refname
; *c
; c
++) {
852 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
857 * HEAD is not a pseudoref, but it certainly uses the
863 static int is_current_worktree_ref(const char *ref
) {
864 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
867 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
868 const char **worktree_name
, int *worktree_name_length
,
869 const char **bare_refname
)
871 const char *name_dummy
;
872 int name_length_dummy
;
873 const char *ref_dummy
;
876 worktree_name
= &name_dummy
;
877 if (!worktree_name_length
)
878 worktree_name_length
= &name_length_dummy
;
880 bare_refname
= &ref_dummy
;
882 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
883 const char *slash
= strchr(*bare_refname
, '/');
885 *worktree_name
= *bare_refname
;
887 *worktree_name_length
= strlen(*worktree_name
);
889 /* This is an error condition, and the caller tell because the bare_refname is "" */
890 *bare_refname
= *worktree_name
+ *worktree_name_length
;
891 return REF_WORKTREE_OTHER
;
894 *worktree_name_length
= slash
- *bare_refname
;
895 *bare_refname
= slash
+ 1;
897 if (is_current_worktree_ref(*bare_refname
))
898 return REF_WORKTREE_OTHER
;
901 *worktree_name
= NULL
;
902 *worktree_name_length
= 0;
904 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
905 && is_current_worktree_ref(*bare_refname
))
906 return REF_WORKTREE_MAIN
;
908 *bare_refname
= maybe_worktree_ref
;
909 if (is_current_worktree_ref(maybe_worktree_ref
))
910 return REF_WORKTREE_CURRENT
;
912 return REF_WORKTREE_SHARED
;
915 long get_files_ref_lock_timeout_ms(void)
917 static int configured
= 0;
919 /* The default timeout is 100 ms: */
920 static int timeout_ms
= 100;
923 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
930 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
932 const struct object_id
*old_oid
,
935 struct ref_transaction
*transaction
;
936 struct strbuf err
= STRBUF_INIT
;
938 transaction
= ref_store_transaction_begin(refs
, &err
);
940 ref_transaction_delete(transaction
, refname
, old_oid
,
942 ref_transaction_commit(transaction
, &err
)) {
943 error("%s", err
.buf
);
944 ref_transaction_free(transaction
);
945 strbuf_release(&err
);
948 ref_transaction_free(transaction
);
949 strbuf_release(&err
);
953 int delete_ref(const char *msg
, const char *refname
,
954 const struct object_id
*old_oid
, unsigned int flags
)
956 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
960 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
965 while ((c
= *msg
++)) {
966 if (wasspace
&& isspace(c
))
968 wasspace
= isspace(c
);
976 static char *normalize_reflog_message(const char *msg
)
978 struct strbuf sb
= STRBUF_INIT
;
981 copy_reflog_msg(&sb
, msg
);
982 return strbuf_detach(&sb
, NULL
);
985 int should_autocreate_reflog(const char *refname
)
987 switch (log_all_ref_updates
) {
988 case LOG_REFS_ALWAYS
:
990 case LOG_REFS_NORMAL
:
991 return starts_with(refname
, "refs/heads/") ||
992 starts_with(refname
, "refs/remotes/") ||
993 starts_with(refname
, "refs/notes/") ||
994 !strcmp(refname
, "HEAD");
1000 int is_branch(const char *refname
)
1002 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
1005 struct read_ref_at_cb
{
1006 const char *refname
;
1007 timestamp_t at_time
;
1010 struct object_id
*oid
;
1013 struct object_id ooid
;
1014 struct object_id noid
;
1018 timestamp_t
*cutoff_time
;
1023 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
1024 timestamp_t timestamp
, int tz
, const char *message
)
1027 *cb
->msg
= xstrdup(message
);
1028 if (cb
->cutoff_time
)
1029 *cb
->cutoff_time
= timestamp
;
1031 *cb
->cutoff_tz
= tz
;
1033 *cb
->cutoff_cnt
= cb
->reccnt
;
1036 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1037 const char *email UNUSED
,
1038 timestamp_t timestamp
, int tz
,
1039 const char *message
, void *cb_data
)
1041 struct read_ref_at_cb
*cb
= cb_data
;
1044 cb
->date
= timestamp
;
1046 if (timestamp
<= cb
->at_time
|| cb
->cnt
== 0) {
1047 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1049 * we have not yet updated cb->[n|o]oid so they still
1050 * hold the values for the previous record.
1052 if (!is_null_oid(&cb
->ooid
)) {
1053 oidcpy(cb
->oid
, noid
);
1054 if (!oideq(&cb
->ooid
, noid
))
1055 warning(_("log for ref %s has gap after %s"),
1056 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1058 else if (cb
->date
== cb
->at_time
)
1059 oidcpy(cb
->oid
, noid
);
1060 else if (!oideq(noid
, cb
->oid
))
1061 warning(_("log for ref %s unexpectedly ended on %s"),
1062 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1063 DATE_MODE(RFC2822
)));
1065 oidcpy(&cb
->ooid
, ooid
);
1066 oidcpy(&cb
->noid
, noid
);
1071 oidcpy(&cb
->ooid
, ooid
);
1072 oidcpy(&cb
->noid
, noid
);
1078 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1079 const char *email UNUSED
,
1080 timestamp_t timestamp
, int tz
,
1081 const char *message
, void *cb_data
)
1083 struct read_ref_at_cb
*cb
= cb_data
;
1085 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1086 oidcpy(cb
->oid
, ooid
);
1087 if (cb
->at_time
&& is_null_oid(cb
->oid
))
1088 oidcpy(cb
->oid
, noid
);
1089 /* We just want the first entry */
1093 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1094 unsigned int flags
, timestamp_t at_time
, int cnt
,
1095 struct object_id
*oid
, char **msg
,
1096 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1098 struct read_ref_at_cb cb
;
1100 memset(&cb
, 0, sizeof(cb
));
1101 cb
.refname
= refname
;
1102 cb
.at_time
= at_time
;
1105 cb
.cutoff_time
= cutoff_time
;
1106 cb
.cutoff_tz
= cutoff_tz
;
1107 cb
.cutoff_cnt
= cutoff_cnt
;
1110 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1115 * The caller asked for ref@{0}, and we had no entries.
1116 * It's a bit subtle, but in practice all callers have
1117 * prepped the "oid" field with the current value of
1118 * the ref, which is the most reasonable fallback.
1120 * We'll put dummy values into the out-parameters (so
1121 * they're not just uninitialized garbage), and the
1122 * caller can take our return value as a hint that
1123 * we did not find any such reflog.
1125 set_read_ref_cutoffs(&cb
, 0, 0, "empty reflog");
1128 if (flags
& GET_OID_QUIETLY
)
1131 die(_("log for %s is empty"), refname
);
1136 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1141 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1144 struct ref_transaction
*tr
;
1147 CALLOC_ARRAY(tr
, 1);
1148 tr
->ref_store
= refs
;
1152 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1154 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1157 void ref_transaction_free(struct ref_transaction
*transaction
)
1164 switch (transaction
->state
) {
1165 case REF_TRANSACTION_OPEN
:
1166 case REF_TRANSACTION_CLOSED
:
1169 case REF_TRANSACTION_PREPARED
:
1170 BUG("free called on a prepared reference transaction");
1173 BUG("unexpected reference transaction state");
1177 for (i
= 0; i
< transaction
->nr
; i
++) {
1178 free(transaction
->updates
[i
]->msg
);
1179 free(transaction
->updates
[i
]);
1181 free(transaction
->updates
);
1185 struct ref_update
*ref_transaction_add_update(
1186 struct ref_transaction
*transaction
,
1187 const char *refname
, unsigned int flags
,
1188 const struct object_id
*new_oid
,
1189 const struct object_id
*old_oid
,
1192 struct ref_update
*update
;
1194 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1195 BUG("update called for transaction that is not open");
1197 FLEX_ALLOC_STR(update
, refname
, refname
);
1198 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1199 transaction
->updates
[transaction
->nr
++] = update
;
1201 update
->flags
= flags
;
1203 if (flags
& REF_HAVE_NEW
)
1204 oidcpy(&update
->new_oid
, new_oid
);
1205 if (flags
& REF_HAVE_OLD
)
1206 oidcpy(&update
->old_oid
, old_oid
);
1207 update
->msg
= normalize_reflog_message(msg
);
1211 int ref_transaction_update(struct ref_transaction
*transaction
,
1212 const char *refname
,
1213 const struct object_id
*new_oid
,
1214 const struct object_id
*old_oid
,
1215 unsigned int flags
, const char *msg
,
1220 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1221 ((new_oid
&& !is_null_oid(new_oid
)) ?
1222 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1223 !refname_is_safe(refname
))) {
1224 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1229 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1230 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1233 * Clear flags outside the allowed set; this should be a noop because
1234 * of the BUG() check above, but it works around a -Wnonnull warning
1235 * with some versions of "gcc -O3".
1237 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1239 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1241 ref_transaction_add_update(transaction
, refname
, flags
,
1242 new_oid
, old_oid
, msg
);
1246 int ref_transaction_create(struct ref_transaction
*transaction
,
1247 const char *refname
,
1248 const struct object_id
*new_oid
,
1249 unsigned int flags
, const char *msg
,
1252 if (!new_oid
|| is_null_oid(new_oid
)) {
1253 strbuf_addf(err
, "'%s' has a null OID", refname
);
1256 return ref_transaction_update(transaction
, refname
, new_oid
,
1257 null_oid(), flags
, msg
, err
);
1260 int ref_transaction_delete(struct ref_transaction
*transaction
,
1261 const char *refname
,
1262 const struct object_id
*old_oid
,
1263 unsigned int flags
, const char *msg
,
1266 if (old_oid
&& is_null_oid(old_oid
))
1267 BUG("delete called with old_oid set to zeros");
1268 return ref_transaction_update(transaction
, refname
,
1269 null_oid(), old_oid
,
1273 int ref_transaction_verify(struct ref_transaction
*transaction
,
1274 const char *refname
,
1275 const struct object_id
*old_oid
,
1280 BUG("verify called with old_oid set to NULL");
1281 return ref_transaction_update(transaction
, refname
,
1286 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1287 const char *refname
, const struct object_id
*new_oid
,
1288 const struct object_id
*old_oid
, unsigned int flags
,
1289 enum action_on_err onerr
)
1291 struct ref_transaction
*t
= NULL
;
1292 struct strbuf err
= STRBUF_INIT
;
1295 t
= ref_store_transaction_begin(refs
, &err
);
1297 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1299 ref_transaction_commit(t
, &err
)) {
1301 ref_transaction_free(t
);
1304 const char *str
= _("update_ref failed for ref '%s': %s");
1307 case UPDATE_REFS_MSG_ON_ERR
:
1308 error(str
, refname
, err
.buf
);
1310 case UPDATE_REFS_DIE_ON_ERR
:
1311 die(str
, refname
, err
.buf
);
1313 case UPDATE_REFS_QUIET_ON_ERR
:
1316 strbuf_release(&err
);
1319 strbuf_release(&err
);
1321 ref_transaction_free(t
);
1325 int update_ref(const char *msg
, const char *refname
,
1326 const struct object_id
*new_oid
,
1327 const struct object_id
*old_oid
,
1328 unsigned int flags
, enum action_on_err onerr
)
1330 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1331 old_oid
, flags
, onerr
);
1335 * Check that the string refname matches a rule of the form
1336 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1337 * "foo/%.*s/baz", and return the string "bar".
1339 static const char *match_parse_rule(const char *refname
, const char *rule
,
1343 * Check that rule matches refname up to the first percent in the rule.
1344 * We can bail immediately if not, but otherwise we leave "rule" at the
1345 * %-placeholder, and "refname" at the start of the potential matched
1348 while (*rule
!= '%') {
1350 BUG("rev-parse rule did not have percent");
1351 if (*refname
++ != *rule
++)
1356 * Check that our "%" is the expected placeholder. This assumes there
1357 * are no other percents (placeholder or quoted) in the string, but
1358 * that is sufficient for our rev-parse rules.
1360 if (!skip_prefix(rule
, "%.*s", &rule
))
1364 * And now check that our suffix (if any) matches.
1366 if (!strip_suffix(refname
, rule
, len
))
1369 return refname
; /* len set by strip_suffix() */
1372 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1373 const char *refname
, int strict
)
1376 struct strbuf resolved_buf
= STRBUF_INIT
;
1378 /* skip first rule, it will always match */
1379 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1381 int rules_to_fail
= i
;
1382 const char *short_name
;
1383 size_t short_name_len
;
1385 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1391 * in strict mode, all (except the matched one) rules
1392 * must fail to resolve to a valid non-ambiguous ref
1395 rules_to_fail
= NUM_REV_PARSE_RULES
;
1398 * check if the short name resolves to a valid ref,
1399 * but use only rules prior to the matched one
1401 for (j
= 0; j
< rules_to_fail
; j
++) {
1402 const char *rule
= ref_rev_parse_rules
[j
];
1404 /* skip matched rule */
1409 * the short name is ambiguous, if it resolves
1410 * (with this previous rule) to a valid ref
1411 * read_ref() returns 0 on success
1413 strbuf_reset(&resolved_buf
);
1414 strbuf_addf(&resolved_buf
, rule
,
1415 cast_size_t_to_int(short_name_len
),
1417 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1422 * short name is non-ambiguous if all previous rules
1423 * haven't resolved to a valid ref
1425 if (j
== rules_to_fail
) {
1426 strbuf_release(&resolved_buf
);
1427 return xmemdupz(short_name
, short_name_len
);
1431 strbuf_release(&resolved_buf
);
1432 return xstrdup(refname
);
1435 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1437 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1441 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1442 struct strvec
*hide_refs
)
1445 if (!strcmp("transfer.hiderefs", var
) ||
1446 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1447 !strcmp(key
, "hiderefs"))) {
1452 return config_error_nonbool(var
);
1454 /* drop const to remove trailing '/' characters */
1455 ref
= (char *)strvec_push(hide_refs
, value
);
1457 while (len
&& ref
[len
- 1] == '/')
1463 int ref_is_hidden(const char *refname
, const char *refname_full
,
1464 const struct strvec
*hide_refs
)
1468 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1469 const char *match
= hide_refs
->v
[i
];
1470 const char *subject
;
1474 if (*match
== '!') {
1479 if (*match
== '^') {
1480 subject
= refname_full
;
1486 /* refname can be NULL when namespaces are used. */
1488 skip_prefix(subject
, match
, &p
) &&
1495 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1497 const char **pattern
;
1498 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1500 * We can't feed any excludes from hidden refs config
1501 * sections, since later rules may override previous
1502 * ones. For example, with rules "refs/foo" and
1503 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1504 * everything underneath it), but the earlier exclusion
1505 * would cause us to skip all of "refs/foo". We
1506 * likewise don't implement the namespace stripping
1507 * required for '^' rules.
1509 * Both are possible to do, but complicated, so avoid
1510 * populating the jump list at all if we see either of
1513 if (**pattern
== '!' || **pattern
== '^')
1516 return hide_refs
->v
;
1519 const char *find_descendant_ref(const char *dirname
,
1520 const struct string_list
*extras
,
1521 const struct string_list
*skip
)
1529 * Look at the place where dirname would be inserted into
1530 * extras. If there is an entry at that position that starts
1531 * with dirname (remember, dirname includes the trailing
1532 * slash) and is not in skip, then we have a conflict.
1534 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1535 pos
< extras
->nr
; pos
++) {
1536 const char *extra_refname
= extras
->items
[pos
].string
;
1538 if (!starts_with(extra_refname
, dirname
))
1541 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1542 return extra_refname
;
1547 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1549 struct object_id oid
;
1552 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1554 return fn("HEAD", &oid
, flag
, cb_data
);
1559 int head_ref(each_ref_fn fn
, void *cb_data
)
1561 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1564 struct ref_iterator
*refs_ref_iterator_begin(
1565 struct ref_store
*refs
,
1567 const char **exclude_patterns
,
1569 enum do_for_each_ref_flags flags
)
1571 struct ref_iterator
*iter
;
1573 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1574 static int ref_paranoia
= -1;
1576 if (ref_paranoia
< 0)
1577 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1579 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1580 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1584 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1586 * `iterator_begin()` already takes care of prefix, but we
1587 * might need to do some trimming:
1590 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1596 * Call fn for each reference in the specified submodule for which the
1597 * refname begins with prefix. If trim is non-zero, then trim that
1598 * many characters off the beginning of each refname before passing
1599 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1600 * include broken references in the iteration. If fn ever returns a
1601 * non-zero value, stop the iteration and return that value;
1602 * otherwise, return 0.
1604 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1605 each_repo_ref_fn fn
, int trim
, int flags
,
1608 struct ref_iterator
*iter
;
1609 struct ref_store
*refs
= get_main_ref_store(r
);
1614 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1616 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1619 struct do_for_each_ref_help
{
1624 static int do_for_each_ref_helper(struct repository
*r UNUSED
,
1625 const char *refname
,
1626 const struct object_id
*oid
,
1630 struct do_for_each_ref_help
*hp
= cb_data
;
1632 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1635 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1636 const char **exclude_patterns
,
1637 each_ref_fn fn
, int trim
,
1638 enum do_for_each_ref_flags flags
, void *cb_data
)
1640 struct ref_iterator
*iter
;
1641 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1646 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1649 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1650 do_for_each_ref_helper
, &hp
);
1653 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1655 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1658 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1660 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1663 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1664 each_ref_fn fn
, void *cb_data
)
1666 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1669 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1671 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1674 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1676 return do_for_each_ref(get_main_ref_store(the_repository
),
1677 prefix
, NULL
, fn
, 0, 0, cb_data
);
1680 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1681 const char **exclude_patterns
,
1682 each_ref_fn fn
, void *cb_data
)
1684 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1687 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1689 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1690 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1691 strlen(git_replace_ref_base
),
1692 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1695 int for_each_namespaced_ref(const char **exclude_patterns
,
1696 each_ref_fn fn
, void *cb_data
)
1698 struct strbuf buf
= STRBUF_INIT
;
1700 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1701 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1702 buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1703 strbuf_release(&buf
);
1707 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1709 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1710 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1713 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1715 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1718 static int qsort_strcmp(const void *va
, const void *vb
)
1720 const char *a
= *(const char **)va
;
1721 const char *b
= *(const char **)vb
;
1723 return strcmp(a
, b
);
1726 static void find_longest_prefixes_1(struct string_list
*out
,
1727 struct strbuf
*prefix
,
1728 const char **patterns
, size_t nr
)
1732 for (i
= 0; i
< nr
; i
++) {
1733 char c
= patterns
[i
][prefix
->len
];
1734 if (!c
|| is_glob_special(c
)) {
1735 string_list_append(out
, prefix
->buf
);
1745 * Set "end" to the index of the element _after_ the last one
1748 for (end
= i
+ 1; end
< nr
; end
++) {
1749 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1753 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1754 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1755 strbuf_setlen(prefix
, prefix
->len
- 1);
1761 static void find_longest_prefixes(struct string_list
*out
,
1762 const char **patterns
)
1764 struct strvec sorted
= STRVEC_INIT
;
1765 struct strbuf prefix
= STRBUF_INIT
;
1767 strvec_pushv(&sorted
, patterns
);
1768 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1770 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1772 strvec_clear(&sorted
);
1773 strbuf_release(&prefix
);
1776 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1777 const char *namespace,
1778 const char **patterns
,
1779 const char **exclude_patterns
,
1780 each_ref_fn fn
, void *cb_data
)
1782 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1783 struct string_list_item
*prefix
;
1784 struct strbuf buf
= STRBUF_INIT
;
1785 int ret
= 0, namespace_len
;
1787 find_longest_prefixes(&prefixes
, patterns
);
1790 strbuf_addstr(&buf
, namespace);
1791 namespace_len
= buf
.len
;
1793 for_each_string_list_item(prefix
, &prefixes
) {
1794 strbuf_addstr(&buf
, prefix
->string
);
1795 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1796 exclude_patterns
, fn
, cb_data
);
1799 strbuf_setlen(&buf
, namespace_len
);
1802 string_list_clear(&prefixes
, 0);
1803 strbuf_release(&buf
);
1807 static int refs_read_special_head(struct ref_store
*ref_store
,
1808 const char *refname
, struct object_id
*oid
,
1809 struct strbuf
*referent
, unsigned int *type
,
1812 struct strbuf full_path
= STRBUF_INIT
;
1813 struct strbuf content
= STRBUF_INIT
;
1815 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1817 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1818 *failure_errno
= errno
;
1822 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1826 strbuf_release(&full_path
);
1827 strbuf_release(&content
);
1831 static int is_special_ref(const char *refname
)
1834 * Special references are refs that have different semantics compared
1835 * to "normal" refs. These refs can thus not be stored in the ref
1836 * backend, but must always be accessed via the filesystem. The
1837 * following refs are special:
1839 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1840 * carries additional metadata like where it came from.
1842 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1845 * Reading, writing or deleting references must consistently go either
1846 * through the filesystem (special refs) or through the reference
1847 * backend (normal ones).
1849 static const char * const special_refs
[] = {
1855 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1856 if (!strcmp(refname
, special_refs
[i
]))
1862 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1863 struct object_id
*oid
, struct strbuf
*referent
,
1864 unsigned int *type
, int *failure_errno
)
1866 assert(failure_errno
);
1867 if (is_special_ref(refname
))
1868 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1869 type
, failure_errno
);
1871 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1872 type
, failure_errno
);
1875 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1876 struct strbuf
*referent
)
1878 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1881 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1882 const char *refname
,
1884 struct object_id
*oid
,
1887 static struct strbuf sb_refname
= STRBUF_INIT
;
1888 struct object_id unused_oid
;
1895 flags
= &unused_flags
;
1899 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1900 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1901 !refname_is_safe(refname
))
1905 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1906 * missing refs and refs that were present but invalid,
1907 * to complain about the latter to stderr.
1909 * We don't know whether the ref exists, so don't set
1912 *flags
|= REF_BAD_NAME
;
1915 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1916 unsigned int read_flags
= 0;
1919 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1920 &read_flags
, &failure_errno
)) {
1921 *flags
|= read_flags
;
1923 /* In reading mode, refs must eventually resolve */
1924 if (resolve_flags
& RESOLVE_REF_READING
)
1928 * Otherwise a missing ref is OK. But the files backend
1929 * may show errors besides ENOENT if there are
1930 * similarly-named refs.
1932 if (failure_errno
!= ENOENT
&&
1933 failure_errno
!= EISDIR
&&
1934 failure_errno
!= ENOTDIR
)
1938 if (*flags
& REF_BAD_NAME
)
1939 *flags
|= REF_ISBROKEN
;
1943 *flags
|= read_flags
;
1945 if (!(read_flags
& REF_ISSYMREF
)) {
1946 if (*flags
& REF_BAD_NAME
) {
1948 *flags
|= REF_ISBROKEN
;
1953 refname
= sb_refname
.buf
;
1954 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1958 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1959 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1960 !refname_is_safe(refname
))
1963 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1970 /* backend functions */
1971 int refs_init_db(struct ref_store
*refs
, int flags
, struct strbuf
*err
)
1973 return refs
->be
->init_db(refs
, flags
, err
);
1976 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1977 struct object_id
*oid
, int *flags
)
1979 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1980 resolve_flags
, oid
, flags
);
1983 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1984 struct object_id
*oid
)
1986 struct ref_store
*refs
;
1989 refs
= get_submodule_ref_store(submodule
);
1994 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
2000 struct ref_store_hash_entry
2002 struct hashmap_entry ent
;
2004 struct ref_store
*refs
;
2006 /* NUL-terminated identifier of the ref store: */
2007 char name
[FLEX_ARRAY
];
2010 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
2011 const struct hashmap_entry
*eptr
,
2012 const struct hashmap_entry
*entry_or_key
,
2013 const void *keydata
)
2015 const struct ref_store_hash_entry
*e1
, *e2
;
2018 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2019 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2020 name
= keydata
? keydata
: e2
->name
;
2022 return strcmp(e1
->name
, name
);
2025 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2026 const char *name
, struct ref_store
*refs
)
2028 struct ref_store_hash_entry
*entry
;
2030 FLEX_ALLOC_STR(entry
, name
, name
);
2031 hashmap_entry_init(&entry
->ent
, strhash(name
));
2036 /* A hashmap of ref_stores, stored by submodule name: */
2037 static struct hashmap submodule_ref_stores
;
2039 /* A hashmap of ref_stores, stored by worktree id: */
2040 static struct hashmap worktree_ref_stores
;
2043 * Look up a ref store by name. If that ref_store hasn't been
2044 * registered yet, return NULL.
2046 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2049 struct ref_store_hash_entry
*entry
;
2052 if (!map
->tablesize
)
2053 /* It's initialized on demand in register_ref_store(). */
2056 hash
= strhash(name
);
2057 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2058 struct ref_store_hash_entry
, ent
);
2059 return entry
? entry
->refs
: NULL
;
2063 * Create, record, and return a ref_store instance for the specified
2066 static struct ref_store
*ref_store_init(struct repository
*repo
,
2070 const struct ref_storage_be
*be
;
2071 struct ref_store
*refs
;
2073 be
= find_ref_storage_backend(repo
->ref_storage_format
);
2075 BUG("reference backend is unknown");
2077 refs
= be
->init(repo
, gitdir
, flags
);
2081 struct ref_store
*get_main_ref_store(struct repository
*r
)
2083 if (r
->refs_private
)
2084 return r
->refs_private
;
2087 BUG("attempting to get main_ref_store outside of repository");
2089 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2090 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2091 return r
->refs_private
;
2095 * Associate a ref store with a name. It is a fatal error to call this
2096 * function twice for the same name.
2098 static void register_ref_store_map(struct hashmap
*map
,
2100 struct ref_store
*refs
,
2103 struct ref_store_hash_entry
*entry
;
2105 if (!map
->tablesize
)
2106 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2108 entry
= alloc_ref_store_hash_entry(name
, refs
);
2109 if (hashmap_put(map
, &entry
->ent
))
2110 BUG("%s ref_store '%s' initialized twice", type
, name
);
2113 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2115 struct strbuf submodule_sb
= STRBUF_INIT
;
2116 struct ref_store
*refs
;
2117 char *to_free
= NULL
;
2119 struct repository
*subrepo
;
2124 len
= strlen(submodule
);
2125 while (len
&& is_dir_sep(submodule
[len
- 1]))
2131 /* We need to strip off one or more trailing slashes */
2132 submodule
= to_free
= xmemdupz(submodule
, len
);
2134 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2138 strbuf_addstr(&submodule_sb
, submodule
);
2139 if (!is_nonbare_repository_dir(&submodule_sb
))
2142 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2145 subrepo
= xmalloc(sizeof(*subrepo
));
2147 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2148 * superprojects other than the_repository. This probably should be
2149 * done by making it take a struct repository * parameter instead of a
2152 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2157 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2158 REF_STORE_READ
| REF_STORE_ODB
);
2159 register_ref_store_map(&submodule_ref_stores
, "submodule",
2163 strbuf_release(&submodule_sb
);
2169 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2171 struct ref_store
*refs
;
2175 return get_main_ref_store(the_repository
);
2177 id
= wt
->id
? wt
->id
: "/";
2178 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2183 refs
= ref_store_init(the_repository
,
2184 git_common_path("worktrees/%s", wt
->id
),
2185 REF_STORE_ALL_CAPS
);
2187 refs
= ref_store_init(the_repository
,
2188 get_git_common_dir(),
2189 REF_STORE_ALL_CAPS
);
2192 register_ref_store_map(&worktree_ref_stores
, "worktree",
2197 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2198 const char *path
, const struct ref_storage_be
*be
)
2202 refs
->gitdir
= xstrdup(path
);
2205 /* backend functions */
2206 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2208 return refs
->be
->pack_refs(refs
, opts
);
2211 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2213 if (current_ref_iter
&&
2214 (current_ref_iter
->oid
== base
||
2215 oideq(current_ref_iter
->oid
, base
)))
2216 return ref_iterator_peel(current_ref_iter
, peeled
);
2218 return peel_object(base
, peeled
) ? -1 : 0;
2221 int refs_create_symref(struct ref_store
*refs
,
2222 const char *ref_target
,
2223 const char *refs_heads_master
,
2229 msg
= normalize_reflog_message(logmsg
);
2230 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2236 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2239 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2240 refs_heads_master
, logmsg
);
2243 int ref_update_reject_duplicates(struct string_list
*refnames
,
2246 size_t i
, n
= refnames
->nr
;
2250 for (i
= 1; i
< n
; i
++) {
2251 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2252 refnames
->items
[i
].string
);
2256 _("multiple updates for ref '%s' not allowed"),
2257 refnames
->items
[i
].string
);
2259 } else if (cmp
> 0) {
2260 BUG("ref_update_reject_duplicates() received unsorted list");
2266 static int run_transaction_hook(struct ref_transaction
*transaction
,
2269 struct child_process proc
= CHILD_PROCESS_INIT
;
2270 struct strbuf buf
= STRBUF_INIT
;
2274 hook
= find_hook("reference-transaction");
2278 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2280 proc
.stdout_to_stderr
= 1;
2281 proc
.trace2_hook_name
= "reference-transaction";
2283 ret
= start_command(&proc
);
2287 sigchain_push(SIGPIPE
, SIG_IGN
);
2289 for (i
= 0; i
< transaction
->nr
; i
++) {
2290 struct ref_update
*update
= transaction
->updates
[i
];
2293 strbuf_addf(&buf
, "%s %s %s\n",
2294 oid_to_hex(&update
->old_oid
),
2295 oid_to_hex(&update
->new_oid
),
2298 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2299 if (errno
!= EPIPE
) {
2300 /* Don't leak errno outside this API */
2309 sigchain_pop(SIGPIPE
);
2310 strbuf_release(&buf
);
2312 ret
|= finish_command(&proc
);
2316 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2319 struct ref_store
*refs
= transaction
->ref_store
;
2322 switch (transaction
->state
) {
2323 case REF_TRANSACTION_OPEN
:
2326 case REF_TRANSACTION_PREPARED
:
2327 BUG("prepare called twice on reference transaction");
2329 case REF_TRANSACTION_CLOSED
:
2330 BUG("prepare called on a closed reference transaction");
2333 BUG("unexpected reference transaction state");
2337 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2339 _("ref updates forbidden inside quarantine environment"));
2343 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2347 ret
= run_transaction_hook(transaction
, "prepared");
2349 ref_transaction_abort(transaction
, err
);
2350 die(_("ref updates aborted by hook"));
2356 int ref_transaction_abort(struct ref_transaction
*transaction
,
2359 struct ref_store
*refs
= transaction
->ref_store
;
2362 switch (transaction
->state
) {
2363 case REF_TRANSACTION_OPEN
:
2364 /* No need to abort explicitly. */
2366 case REF_TRANSACTION_PREPARED
:
2367 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2369 case REF_TRANSACTION_CLOSED
:
2370 BUG("abort called on a closed reference transaction");
2373 BUG("unexpected reference transaction state");
2377 run_transaction_hook(transaction
, "aborted");
2379 ref_transaction_free(transaction
);
2383 int ref_transaction_commit(struct ref_transaction
*transaction
,
2386 struct ref_store
*refs
= transaction
->ref_store
;
2389 switch (transaction
->state
) {
2390 case REF_TRANSACTION_OPEN
:
2391 /* Need to prepare first. */
2392 ret
= ref_transaction_prepare(transaction
, err
);
2396 case REF_TRANSACTION_PREPARED
:
2397 /* Fall through to finish. */
2399 case REF_TRANSACTION_CLOSED
:
2400 BUG("commit called on a closed reference transaction");
2403 BUG("unexpected reference transaction state");
2407 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2409 run_transaction_hook(transaction
, "committed");
2413 int refs_verify_refname_available(struct ref_store
*refs
,
2414 const char *refname
,
2415 const struct string_list
*extras
,
2416 const struct string_list
*skip
,
2420 const char *extra_refname
;
2421 struct strbuf dirname
= STRBUF_INIT
;
2422 struct strbuf referent
= STRBUF_INIT
;
2423 struct object_id oid
;
2425 struct ref_iterator
*iter
;
2430 * For the sake of comments in this function, suppose that
2431 * refname is "refs/foo/bar".
2436 strbuf_grow(&dirname
, strlen(refname
) + 1);
2437 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2439 * Just saying "Is a directory" when we e.g. can't
2440 * lock some multi-level ref isn't very informative,
2441 * the user won't be told *what* is a directory, so
2442 * let's not use strerror() below.
2445 /* Expand dirname to the new prefix, not including the trailing slash: */
2446 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2449 * We are still at a leading dir of the refname (e.g.,
2450 * "refs/foo"; if there is a reference with that name,
2451 * it is a conflict, *unless* it is in skip.
2453 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2456 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2457 &type
, &ignore_errno
)) {
2458 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2459 dirname
.buf
, refname
);
2463 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2464 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2465 refname
, dirname
.buf
);
2471 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2472 * There is no point in searching for a reference with that
2473 * name, because a refname isn't considered to conflict with
2474 * itself. But we still need to check for references whose
2475 * names are in the "refs/foo/bar/" namespace, because they
2478 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2479 strbuf_addch(&dirname
, '/');
2481 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2482 DO_FOR_EACH_INCLUDE_BROKEN
);
2483 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2485 string_list_has_string(skip
, iter
->refname
))
2488 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2489 iter
->refname
, refname
);
2490 ref_iterator_abort(iter
);
2494 if (ok
!= ITER_DONE
)
2495 BUG("error while iterating over references");
2497 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2499 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2500 refname
, extra_refname
);
2505 strbuf_release(&referent
);
2506 strbuf_release(&dirname
);
2510 struct do_for_each_reflog_help
{
2515 static int do_for_each_reflog_helper(struct repository
*r UNUSED
,
2516 const char *refname
,
2517 const struct object_id
*oid UNUSED
,
2521 struct do_for_each_reflog_help
*hp
= cb_data
;
2522 return hp
->fn(refname
, hp
->cb_data
);
2525 int refs_for_each_reflog(struct ref_store
*refs
, each_reflog_fn fn
, void *cb_data
)
2527 struct ref_iterator
*iter
;
2528 struct do_for_each_reflog_help hp
= { fn
, cb_data
};
2530 iter
= refs
->be
->reflog_iterator_begin(refs
);
2532 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2533 do_for_each_reflog_helper
, &hp
);
2536 int for_each_reflog(each_reflog_fn fn
, void *cb_data
)
2538 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2541 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2542 const char *refname
,
2543 each_reflog_ent_fn fn
,
2546 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2550 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2553 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2554 refname
, fn
, cb_data
);
2557 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2558 each_reflog_ent_fn fn
, void *cb_data
)
2560 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2563 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2566 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2570 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2572 return refs
->be
->reflog_exists(refs
, refname
);
2575 int reflog_exists(const char *refname
)
2577 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2580 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2583 return refs
->be
->create_reflog(refs
, refname
, err
);
2586 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2588 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2592 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2594 return refs
->be
->delete_reflog(refs
, refname
);
2597 int delete_reflog(const char *refname
)
2599 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2602 int refs_reflog_expire(struct ref_store
*refs
,
2603 const char *refname
,
2605 reflog_expiry_prepare_fn prepare_fn
,
2606 reflog_expiry_should_prune_fn should_prune_fn
,
2607 reflog_expiry_cleanup_fn cleanup_fn
,
2608 void *policy_cb_data
)
2610 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2611 prepare_fn
, should_prune_fn
,
2612 cleanup_fn
, policy_cb_data
);
2615 int reflog_expire(const char *refname
,
2617 reflog_expiry_prepare_fn prepare_fn
,
2618 reflog_expiry_should_prune_fn should_prune_fn
,
2619 reflog_expiry_cleanup_fn cleanup_fn
,
2620 void *policy_cb_data
)
2622 return refs_reflog_expire(get_main_ref_store(the_repository
),
2624 prepare_fn
, should_prune_fn
,
2625 cleanup_fn
, policy_cb_data
);
2628 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2631 struct ref_store
*refs
= transaction
->ref_store
;
2633 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2636 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2637 ref_transaction_for_each_queued_update_fn cb
,
2642 for (i
= 0; i
< transaction
->nr
; i
++) {
2643 struct ref_update
*update
= transaction
->updates
[i
];
2646 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2647 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2652 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2653 struct string_list
*refnames
, unsigned int flags
)
2655 struct ref_transaction
*transaction
;
2656 struct strbuf err
= STRBUF_INIT
;
2657 struct string_list_item
*item
;
2658 int ret
= 0, failures
= 0;
2664 msg
= normalize_reflog_message(logmsg
);
2667 * Since we don't check the references' old_oids, the
2668 * individual updates can't fail, so we can pack all of the
2669 * updates into a single transaction.
2671 transaction
= ref_store_transaction_begin(refs
, &err
);
2673 ret
= error("%s", err
.buf
);
2677 for_each_string_list_item(item
, refnames
) {
2678 ret
= ref_transaction_delete(transaction
, item
->string
,
2679 NULL
, flags
, msg
, &err
);
2681 warning(_("could not delete reference %s: %s"),
2682 item
->string
, err
.buf
);
2688 ret
= ref_transaction_commit(transaction
, &err
);
2690 if (refnames
->nr
== 1)
2691 error(_("could not delete reference %s: %s"),
2692 refnames
->items
[0].string
, err
.buf
);
2694 error(_("could not delete references: %s"), err
.buf
);
2698 if (!ret
&& failures
)
2700 ref_transaction_free(transaction
);
2701 strbuf_release(&err
);
2706 int delete_refs(const char *msg
, struct string_list
*refnames
,
2709 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2712 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2713 const char *newref
, const char *logmsg
)
2718 msg
= normalize_reflog_message(logmsg
);
2719 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2724 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2726 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2729 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2730 const char *newref
, const char *logmsg
)
2735 msg
= normalize_reflog_message(logmsg
);
2736 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2741 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2743 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);