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
,
40 static const struct ref_storage_be
*find_ref_storage_backend(unsigned int ref_storage_format
)
42 if (ref_storage_format
< ARRAY_SIZE(refs_backends
))
43 return refs_backends
[ref_storage_format
];
47 unsigned int ref_storage_format_by_name(const char *name
)
49 for (unsigned int i
= 0; i
< ARRAY_SIZE(refs_backends
); i
++)
50 if (refs_backends
[i
] && !strcmp(refs_backends
[i
]->name
, name
))
52 return REF_STORAGE_FORMAT_UNKNOWN
;
55 const char *ref_storage_format_to_name(unsigned int ref_storage_format
)
57 const struct ref_storage_be
*be
= find_ref_storage_backend(ref_storage_format
);
64 * How to handle various characters in refnames:
65 * 0: An acceptable character for refs
67 * 2: ., look for a preceding . to reject .. in refs
68 * 3: {, look for a preceding @ to reject @{ in refs
69 * 4: A bad character: ASCII control characters, and
70 * ":", "?", "[", "\", "^", "~", SP, or TAB
71 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
73 static unsigned char refname_disposition
[256] = {
74 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
75 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
77 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
84 struct ref_namespace_info ref_namespace
[] = {
87 .decoration
= DECORATION_REF_HEAD
,
90 [NAMESPACE_BRANCHES
] = {
92 .decoration
= DECORATION_REF_LOCAL
,
96 .decoration
= DECORATION_REF_TAG
,
98 [NAMESPACE_REMOTE_REFS
] = {
100 * The default refspec for new remotes copies refs from
101 * refs/heads/ on the remote into refs/remotes/<remote>/.
102 * As such, "refs/remotes/" has special handling.
104 .ref
= "refs/remotes/",
105 .decoration
= DECORATION_REF_REMOTE
,
107 [NAMESPACE_STASH
] = {
109 * The single ref "refs/stash" stores the latest stash.
110 * Older stashes can be found in the reflog.
114 .decoration
= DECORATION_REF_STASH
,
116 [NAMESPACE_REPLACE
] = {
118 * This namespace allows Git to act as if one object ID
119 * points to the content of another. Unlike the other
120 * ref namespaces, this one can be changed by the
121 * GIT_REPLACE_REF_BASE environment variable. This
122 * .namespace value will be overwritten in setup_git_env().
124 .ref
= "refs/replace/",
125 .decoration
= DECORATION_GRAFTED
,
127 [NAMESPACE_NOTES
] = {
129 * The refs/notes/commit ref points to the tip of a
130 * parallel commit history that adds metadata to commits
131 * in the normal history. This ref can be overwritten
132 * by the core.notesRef config variable or the
133 * GIT_NOTES_REFS environment variable.
135 .ref
= "refs/notes/commit",
138 [NAMESPACE_PREFETCH
] = {
140 * Prefetch refs are written by the background 'fetch'
141 * maintenance task. It allows faster foreground fetches
142 * by advertising these previously-downloaded tips without
143 * updating refs/remotes/ without user intervention.
145 .ref
= "refs/prefetch/",
147 [NAMESPACE_REWRITTEN
] = {
149 * Rewritten refs are used by the 'label' command in the
150 * sequencer. These are particularly useful during an
151 * interactive rebase that uses the 'merge' command.
153 .ref
= "refs/rewritten/",
157 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
159 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
160 if (info
->ref_updated
)
163 info
->ref_updated
= 1;
167 * Try to read one refname component from the front of refname.
168 * Return the length of the component found, or -1 if the component is
169 * not legal. It is legal if it is something reasonable to have under
170 * ".git/refs/"; We do not like it if:
172 * - it begins with ".", or
173 * - it has double dots "..", or
174 * - it has ASCII control characters, or
175 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
176 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
177 * - it ends with a "/", or
178 * - it ends with ".lock", or
179 * - it contains a "@{" portion
181 * When sanitized is not NULL, instead of rejecting the input refname
182 * as an error, try to come up with a usable replacement for the input
185 static int check_refname_component(const char *refname
, int *flags
,
186 struct strbuf
*sanitized
)
190 size_t component_start
= 0; /* garbage - not a reasonable initial value */
193 component_start
= sanitized
->len
;
195 for (cp
= refname
; ; cp
++) {
197 unsigned char disp
= refname_disposition
[ch
];
199 if (sanitized
&& disp
!= 1)
200 strbuf_addch(sanitized
, ch
);
206 if (last
== '.') { /* Refname contains "..". */
208 /* collapse ".." to single "." */
209 strbuf_setlen(sanitized
, sanitized
->len
- 1);
215 if (last
== '@') { /* Refname contains "@{". */
217 sanitized
->buf
[sanitized
->len
-1] = '-';
225 sanitized
->buf
[sanitized
->len
-1] = '-';
230 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
231 /* refspec can't be a pattern */
233 sanitized
->buf
[sanitized
->len
-1] = '-';
239 * Unset the pattern flag so that we only accept
240 * a single asterisk for one side of refspec.
242 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
249 return 0; /* Component has zero length. */
251 if (refname
[0] == '.') { /* Component starts with '.'. */
253 sanitized
->buf
[component_start
] = '-';
257 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
258 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
261 /* Refname ends with ".lock". */
262 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
263 /* try again in case we have .lock.lock */
269 static int check_or_sanitize_refname(const char *refname
, int flags
,
270 struct strbuf
*sanitized
)
272 int component_len
, component_count
= 0;
274 if (!strcmp(refname
, "@")) {
275 /* Refname is a single character '@'. */
277 strbuf_addch(sanitized
, '-');
283 if (sanitized
&& sanitized
->len
)
284 strbuf_complete(sanitized
, '/');
286 /* We are at the start of a path component. */
287 component_len
= check_refname_component(refname
, &flags
,
289 if (sanitized
&& component_len
== 0)
290 ; /* OK, omit empty component */
291 else if (component_len
<= 0)
295 if (refname
[component_len
] == '\0')
297 /* Skip to next component. */
298 refname
+= component_len
+ 1;
301 if (refname
[component_len
- 1] == '.') {
302 /* Refname ends with '.'. */
304 ; /* omit ending dot */
308 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
309 return -1; /* Refname has only one component. */
313 int check_refname_format(const char *refname
, int flags
)
315 return check_or_sanitize_refname(refname
, flags
, NULL
);
318 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
320 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
321 BUG("sanitizing refname '%s' check returned error", refname
);
324 int refname_is_safe(const char *refname
)
328 if (skip_prefix(refname
, "refs/", &rest
)) {
331 size_t restlen
= strlen(rest
);
333 /* rest must not be empty, or start or end with "/" */
334 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
338 * Does the refname try to escape refs/?
339 * For example: refs/foo/../bar is safe but refs/foo/../../bar
342 buf
= xmallocz(restlen
);
343 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
349 if (!isupper(*refname
) && *refname
!= '_')
357 * Return true if refname, which has the specified oid and flags, can
358 * be resolved to an object in the database. If the referred-to object
359 * does not exist, emit a warning and return false.
361 int ref_resolves_to_object(const char *refname
,
362 struct repository
*repo
,
363 const struct object_id
*oid
,
366 if (flags
& REF_ISBROKEN
)
368 if (!repo_has_object_file(repo
, oid
)) {
369 error(_("%s does not point to a valid object!"), refname
);
375 char *refs_resolve_refdup(struct ref_store
*refs
,
376 const char *refname
, int resolve_flags
,
377 struct object_id
*oid
, int *flags
)
381 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
383 return xstrdup_or_null(result
);
386 char *resolve_refdup(const char *refname
, int resolve_flags
,
387 struct object_id
*oid
, int *flags
)
389 return refs_resolve_refdup(get_main_ref_store(the_repository
),
390 refname
, resolve_flags
,
394 /* The argument to for_each_filter_refs */
395 struct for_each_ref_filter
{
402 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
404 struct ref_store
*refs
= get_main_ref_store(the_repository
);
406 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
412 int read_ref(const char *refname
, struct object_id
*oid
)
414 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
417 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
419 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
423 int ref_exists(const char *refname
)
425 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
428 static int for_each_filter_refs(const char *refname
,
429 const struct object_id
*oid
,
430 int flags
, void *data
)
432 struct for_each_ref_filter
*filter
= data
;
434 if (wildmatch(filter
->pattern
, refname
, 0))
437 skip_prefix(refname
, filter
->prefix
, &refname
);
438 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
441 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
443 struct object
*o
= lookup_unknown_object(the_repository
, name
);
445 if (o
->type
== OBJ_NONE
) {
446 int type
= oid_object_info(the_repository
, name
, NULL
);
447 if (type
< 0 || !object_as_type(o
, type
, 0))
451 if (o
->type
!= OBJ_TAG
)
454 o
= deref_tag_noverify(o
);
458 oidcpy(oid
, &o
->oid
);
462 struct warn_if_dangling_data
{
465 const struct string_list
*refnames
;
469 static int warn_if_dangling_symref(const char *refname
,
470 const struct object_id
*oid UNUSED
,
471 int flags
, void *cb_data
)
473 struct warn_if_dangling_data
*d
= cb_data
;
474 const char *resolves_to
;
476 if (!(flags
& REF_ISSYMREF
))
479 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
482 ? strcmp(resolves_to
, d
->refname
)
483 : !string_list_has_string(d
->refnames
, resolves_to
))) {
487 fprintf(d
->fp
, d
->msg_fmt
, refname
);
492 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
494 struct warn_if_dangling_data data
;
497 data
.refname
= refname
;
498 data
.refnames
= NULL
;
499 data
.msg_fmt
= msg_fmt
;
500 for_each_rawref(warn_if_dangling_symref
, &data
);
503 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
505 struct warn_if_dangling_data data
;
509 data
.refnames
= refnames
;
510 data
.msg_fmt
= msg_fmt
;
511 for_each_rawref(warn_if_dangling_symref
, &data
);
514 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
516 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
519 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
521 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
524 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
526 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
529 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
531 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
534 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
536 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
539 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
541 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
544 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
546 struct strbuf buf
= STRBUF_INIT
;
548 struct object_id oid
;
551 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
552 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
553 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
554 strbuf_release(&buf
);
559 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
562 struct strbuf normalized_pattern
= STRBUF_INIT
;
565 BUG("pattern must not start with '/'");
568 strbuf_addstr(&normalized_pattern
, prefix
);
569 else if (!starts_with(pattern
, "refs/") &&
570 strcmp(pattern
, "HEAD"))
571 strbuf_addstr(&normalized_pattern
, "refs/");
573 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
577 strbuf_addstr(&normalized_pattern
, pattern
);
578 strbuf_strip_suffix(&normalized_pattern
, "/");
580 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
581 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
582 strbuf_release(&normalized_pattern
);
585 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
586 const char *prefix
, void *cb_data
)
588 struct strbuf real_pattern
= STRBUF_INIT
;
589 struct for_each_ref_filter filter
;
592 if (!prefix
&& !starts_with(pattern
, "refs/"))
593 strbuf_addstr(&real_pattern
, "refs/");
595 strbuf_addstr(&real_pattern
, prefix
);
596 strbuf_addstr(&real_pattern
, pattern
);
598 if (!has_glob_specials(pattern
)) {
599 /* Append implied '/' '*' if not present. */
600 strbuf_complete(&real_pattern
, '/');
601 /* No need to check for '*', there is none. */
602 strbuf_addch(&real_pattern
, '*');
605 filter
.pattern
= real_pattern
.buf
;
606 filter
.prefix
= prefix
;
608 filter
.cb_data
= cb_data
;
609 ret
= for_each_ref(for_each_filter_refs
, &filter
);
611 strbuf_release(&real_pattern
);
615 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
617 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
620 const char *prettify_refname(const char *name
)
622 if (skip_prefix(name
, "refs/heads/", &name
) ||
623 skip_prefix(name
, "refs/tags/", &name
) ||
624 skip_prefix(name
, "refs/remotes/", &name
))
629 static const char *ref_rev_parse_rules
[] = {
635 "refs/remotes/%.*s/HEAD",
639 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
642 * Is it possible that the caller meant full_name with abbrev_name?
643 * If so return a non-zero value to signal "yes"; the magnitude of
644 * the returned value gives the precedence used for disambiguation.
646 * If abbrev_name cannot mean full_name, return 0.
648 int refname_match(const char *abbrev_name
, const char *full_name
)
651 const int abbrev_name_len
= strlen(abbrev_name
);
652 const int num_rules
= NUM_REV_PARSE_RULES
;
654 for (p
= ref_rev_parse_rules
; *p
; p
++)
655 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
656 return &ref_rev_parse_rules
[num_rules
] - p
;
662 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
663 * the results to 'prefixes'
665 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
668 int len
= strlen(prefix
);
670 for (p
= ref_rev_parse_rules
; *p
; p
++)
671 strvec_pushf(prefixes
, *p
, len
, prefix
);
674 static const char default_branch_name_advice
[] = N_(
675 "Using '%s' as the name for the initial branch. This default branch name\n"
676 "is subject to change. To configure the initial branch name to use in all\n"
677 "of your new repositories, which will suppress this warning, call:\n"
679 "\tgit config --global init.defaultBranch <name>\n"
681 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
682 "'development'. The just-created branch can be renamed via this command:\n"
684 "\tgit branch -m <name>\n"
687 char *repo_default_branch_name(struct repository
*r
, int quiet
)
689 const char *config_key
= "init.defaultbranch";
690 const char *config_display_key
= "init.defaultBranch";
691 char *ret
= NULL
, *full_ref
;
692 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
696 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
697 die(_("could not retrieve `%s`"), config_display_key
);
700 ret
= xstrdup("master");
702 advise(_(default_branch_name_advice
), ret
);
705 full_ref
= xstrfmt("refs/heads/%s", ret
);
706 if (check_refname_format(full_ref
, 0))
707 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
713 const char *git_default_branch_name(int quiet
)
718 ret
= repo_default_branch_name(the_repository
, quiet
);
724 * *string and *len will only be substituted, and *string returned (for
725 * later free()ing) if the string passed in is a magic short-hand form
728 static char *substitute_branch_name(struct repository
*r
,
729 const char **string
, int *len
,
730 int nonfatal_dangling_mark
)
732 struct strbuf buf
= STRBUF_INIT
;
733 struct interpret_branch_name_options options
= {
734 .nonfatal_dangling_mark
= nonfatal_dangling_mark
736 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
740 *string
= strbuf_detach(&buf
, &size
);
742 return (char *)*string
;
748 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
749 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
751 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
752 nonfatal_dangling_mark
);
753 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
758 int expand_ref(struct repository
*repo
, const char *str
, int len
,
759 struct object_id
*oid
, char **ref
)
763 struct strbuf fullref
= STRBUF_INIT
;
766 for (p
= ref_rev_parse_rules
; *p
; p
++) {
767 struct object_id oid_from_ref
;
768 struct object_id
*this_result
;
770 struct ref_store
*refs
= get_main_ref_store(repo
);
772 this_result
= refs_found
? &oid_from_ref
: oid
;
773 strbuf_reset(&fullref
);
774 strbuf_addf(&fullref
, *p
, len
, str
);
775 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
781 if (!warn_ambiguous_refs
)
783 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
784 warning(_("ignoring dangling symref %s"), fullref
.buf
);
785 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
786 warning(_("ignoring broken ref %s"), fullref
.buf
);
789 strbuf_release(&fullref
);
793 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
794 struct object_id
*oid
, char **log
)
796 struct ref_store
*refs
= get_main_ref_store(r
);
797 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
800 struct strbuf path
= STRBUF_INIT
;
803 for (p
= ref_rev_parse_rules
; *p
; p
++) {
804 struct object_id hash
;
805 const char *ref
, *it
;
808 strbuf_addf(&path
, *p
, len
, str
);
809 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
811 oid
? &hash
: NULL
, NULL
);
814 if (refs_reflog_exists(refs
, path
.buf
))
816 else if (strcmp(ref
, path
.buf
) &&
817 refs_reflog_exists(refs
, ref
))
826 if (!warn_ambiguous_refs
)
829 strbuf_release(&path
);
834 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
836 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
839 int is_per_worktree_ref(const char *refname
)
841 return starts_with(refname
, "refs/worktree/") ||
842 starts_with(refname
, "refs/bisect/") ||
843 starts_with(refname
, "refs/rewritten/");
846 static int is_pseudoref_syntax(const char *refname
)
850 for (c
= refname
; *c
; c
++) {
851 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
856 * HEAD is not a pseudoref, but it certainly uses the
862 static int is_current_worktree_ref(const char *ref
) {
863 return is_pseudoref_syntax(ref
) || is_per_worktree_ref(ref
);
866 enum ref_worktree_type
parse_worktree_ref(const char *maybe_worktree_ref
,
867 const char **worktree_name
, int *worktree_name_length
,
868 const char **bare_refname
)
870 const char *name_dummy
;
871 int name_length_dummy
;
872 const char *ref_dummy
;
875 worktree_name
= &name_dummy
;
876 if (!worktree_name_length
)
877 worktree_name_length
= &name_length_dummy
;
879 bare_refname
= &ref_dummy
;
881 if (skip_prefix(maybe_worktree_ref
, "worktrees/", bare_refname
)) {
882 const char *slash
= strchr(*bare_refname
, '/');
884 *worktree_name
= *bare_refname
;
886 *worktree_name_length
= strlen(*worktree_name
);
888 /* This is an error condition, and the caller tell because the bare_refname is "" */
889 *bare_refname
= *worktree_name
+ *worktree_name_length
;
890 return REF_WORKTREE_OTHER
;
893 *worktree_name_length
= slash
- *bare_refname
;
894 *bare_refname
= slash
+ 1;
896 if (is_current_worktree_ref(*bare_refname
))
897 return REF_WORKTREE_OTHER
;
900 *worktree_name
= NULL
;
901 *worktree_name_length
= 0;
903 if (skip_prefix(maybe_worktree_ref
, "main-worktree/", bare_refname
)
904 && is_current_worktree_ref(*bare_refname
))
905 return REF_WORKTREE_MAIN
;
907 *bare_refname
= maybe_worktree_ref
;
908 if (is_current_worktree_ref(maybe_worktree_ref
))
909 return REF_WORKTREE_CURRENT
;
911 return REF_WORKTREE_SHARED
;
914 long get_files_ref_lock_timeout_ms(void)
916 static int configured
= 0;
918 /* The default timeout is 100 ms: */
919 static int timeout_ms
= 100;
922 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
929 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
931 const struct object_id
*old_oid
,
934 struct ref_transaction
*transaction
;
935 struct strbuf err
= STRBUF_INIT
;
937 transaction
= ref_store_transaction_begin(refs
, &err
);
939 ref_transaction_delete(transaction
, refname
, old_oid
,
941 ref_transaction_commit(transaction
, &err
)) {
942 error("%s", err
.buf
);
943 ref_transaction_free(transaction
);
944 strbuf_release(&err
);
947 ref_transaction_free(transaction
);
948 strbuf_release(&err
);
952 int delete_ref(const char *msg
, const char *refname
,
953 const struct object_id
*old_oid
, unsigned int flags
)
955 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
959 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
964 while ((c
= *msg
++)) {
965 if (wasspace
&& isspace(c
))
967 wasspace
= isspace(c
);
975 static char *normalize_reflog_message(const char *msg
)
977 struct strbuf sb
= STRBUF_INIT
;
980 copy_reflog_msg(&sb
, msg
);
981 return strbuf_detach(&sb
, NULL
);
984 int should_autocreate_reflog(const char *refname
)
986 switch (log_all_ref_updates
) {
987 case LOG_REFS_ALWAYS
:
989 case LOG_REFS_NORMAL
:
990 return starts_with(refname
, "refs/heads/") ||
991 starts_with(refname
, "refs/remotes/") ||
992 starts_with(refname
, "refs/notes/") ||
993 !strcmp(refname
, "HEAD");
999 int is_branch(const char *refname
)
1001 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
1004 struct read_ref_at_cb
{
1005 const char *refname
;
1006 timestamp_t at_time
;
1009 struct object_id
*oid
;
1012 struct object_id ooid
;
1013 struct object_id noid
;
1017 timestamp_t
*cutoff_time
;
1022 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
1023 timestamp_t timestamp
, int tz
, const char *message
)
1026 *cb
->msg
= xstrdup(message
);
1027 if (cb
->cutoff_time
)
1028 *cb
->cutoff_time
= timestamp
;
1030 *cb
->cutoff_tz
= tz
;
1032 *cb
->cutoff_cnt
= cb
->reccnt
;
1035 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
1036 const char *email UNUSED
,
1037 timestamp_t timestamp
, int tz
,
1038 const char *message
, void *cb_data
)
1040 struct read_ref_at_cb
*cb
= cb_data
;
1044 cb
->date
= timestamp
;
1047 * It is not possible for cb->cnt == 0 on the first iteration because
1048 * that special case is handled in read_ref_at().
1052 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
1053 if (timestamp
<= cb
->at_time
|| reached_count
) {
1054 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1056 * we have not yet updated cb->[n|o]oid so they still
1057 * hold the values for the previous record.
1059 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
1060 warning(_("log for ref %s has gap after %s"),
1061 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1063 oidcpy(cb
->oid
, ooid
);
1064 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
1065 oidcpy(cb
->oid
, noid
);
1066 else if (!oideq(noid
, cb
->oid
))
1067 warning(_("log for ref %s unexpectedly ended on %s"),
1068 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1069 DATE_MODE(RFC2822
)));
1073 oidcpy(&cb
->ooid
, ooid
);
1074 oidcpy(&cb
->noid
, noid
);
1075 return cb
->found_it
;
1078 static int read_ref_at_ent_newest(struct object_id
*ooid UNUSED
,
1079 struct object_id
*noid
,
1080 const char *email UNUSED
,
1081 timestamp_t timestamp
, int tz
,
1082 const char *message
, void *cb_data
)
1084 struct read_ref_at_cb
*cb
= cb_data
;
1086 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1087 oidcpy(cb
->oid
, noid
);
1088 /* We just want the first entry */
1092 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1093 const char *email UNUSED
,
1094 timestamp_t timestamp
, int tz
,
1095 const char *message
, void *cb_data
)
1097 struct read_ref_at_cb
*cb
= cb_data
;
1099 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1100 oidcpy(cb
->oid
, ooid
);
1101 if (is_null_oid(cb
->oid
))
1102 oidcpy(cb
->oid
, noid
);
1103 /* We just want the first entry */
1107 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1108 unsigned int flags
, timestamp_t at_time
, int cnt
,
1109 struct object_id
*oid
, char **msg
,
1110 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1112 struct read_ref_at_cb cb
;
1114 memset(&cb
, 0, sizeof(cb
));
1115 cb
.refname
= refname
;
1116 cb
.at_time
= at_time
;
1119 cb
.cutoff_time
= cutoff_time
;
1120 cb
.cutoff_tz
= cutoff_tz
;
1121 cb
.cutoff_cnt
= cutoff_cnt
;
1125 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
1129 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1132 if (flags
& GET_OID_QUIETLY
)
1135 die(_("log for %s is empty"), refname
);
1140 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1145 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1148 struct ref_transaction
*tr
;
1151 CALLOC_ARRAY(tr
, 1);
1152 tr
->ref_store
= refs
;
1156 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1158 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
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(transaction
->updates
[i
]);
1185 free(transaction
->updates
);
1189 struct ref_update
*ref_transaction_add_update(
1190 struct ref_transaction
*transaction
,
1191 const char *refname
, unsigned int flags
,
1192 const struct object_id
*new_oid
,
1193 const struct object_id
*old_oid
,
1196 struct ref_update
*update
;
1198 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1199 BUG("update called for transaction that is not open");
1201 FLEX_ALLOC_STR(update
, refname
, refname
);
1202 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1203 transaction
->updates
[transaction
->nr
++] = update
;
1205 update
->flags
= flags
;
1207 if (flags
& REF_HAVE_NEW
)
1208 oidcpy(&update
->new_oid
, new_oid
);
1209 if (flags
& REF_HAVE_OLD
)
1210 oidcpy(&update
->old_oid
, old_oid
);
1211 update
->msg
= normalize_reflog_message(msg
);
1215 int ref_transaction_update(struct ref_transaction
*transaction
,
1216 const char *refname
,
1217 const struct object_id
*new_oid
,
1218 const struct object_id
*old_oid
,
1219 unsigned int flags
, const char *msg
,
1224 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1225 ((new_oid
&& !is_null_oid(new_oid
)) ?
1226 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1227 !refname_is_safe(refname
))) {
1228 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1233 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1234 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1237 * Clear flags outside the allowed set; this should be a noop because
1238 * of the BUG() check above, but it works around a -Wnonnull warning
1239 * with some versions of "gcc -O3".
1241 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1243 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1245 ref_transaction_add_update(transaction
, refname
, flags
,
1246 new_oid
, old_oid
, msg
);
1250 int ref_transaction_create(struct ref_transaction
*transaction
,
1251 const char *refname
,
1252 const struct object_id
*new_oid
,
1253 unsigned int flags
, const char *msg
,
1256 if (!new_oid
|| is_null_oid(new_oid
)) {
1257 strbuf_addf(err
, "'%s' has a null OID", refname
);
1260 return ref_transaction_update(transaction
, refname
, new_oid
,
1261 null_oid(), flags
, msg
, err
);
1264 int ref_transaction_delete(struct ref_transaction
*transaction
,
1265 const char *refname
,
1266 const struct object_id
*old_oid
,
1267 unsigned int flags
, const char *msg
,
1270 if (old_oid
&& is_null_oid(old_oid
))
1271 BUG("delete called with old_oid set to zeros");
1272 return ref_transaction_update(transaction
, refname
,
1273 null_oid(), old_oid
,
1277 int ref_transaction_verify(struct ref_transaction
*transaction
,
1278 const char *refname
,
1279 const struct object_id
*old_oid
,
1284 BUG("verify called with old_oid set to NULL");
1285 return ref_transaction_update(transaction
, refname
,
1290 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1291 const char *refname
, const struct object_id
*new_oid
,
1292 const struct object_id
*old_oid
, unsigned int flags
,
1293 enum action_on_err onerr
)
1295 struct ref_transaction
*t
= NULL
;
1296 struct strbuf err
= STRBUF_INIT
;
1299 t
= ref_store_transaction_begin(refs
, &err
);
1301 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1303 ref_transaction_commit(t
, &err
)) {
1305 ref_transaction_free(t
);
1308 const char *str
= _("update_ref failed for ref '%s': %s");
1311 case UPDATE_REFS_MSG_ON_ERR
:
1312 error(str
, refname
, err
.buf
);
1314 case UPDATE_REFS_DIE_ON_ERR
:
1315 die(str
, refname
, err
.buf
);
1317 case UPDATE_REFS_QUIET_ON_ERR
:
1320 strbuf_release(&err
);
1323 strbuf_release(&err
);
1325 ref_transaction_free(t
);
1329 int update_ref(const char *msg
, const char *refname
,
1330 const struct object_id
*new_oid
,
1331 const struct object_id
*old_oid
,
1332 unsigned int flags
, enum action_on_err onerr
)
1334 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1335 old_oid
, flags
, onerr
);
1339 * Check that the string refname matches a rule of the form
1340 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1341 * "foo/%.*s/baz", and return the string "bar".
1343 static const char *match_parse_rule(const char *refname
, const char *rule
,
1347 * Check that rule matches refname up to the first percent in the rule.
1348 * We can bail immediately if not, but otherwise we leave "rule" at the
1349 * %-placeholder, and "refname" at the start of the potential matched
1352 while (*rule
!= '%') {
1354 BUG("rev-parse rule did not have percent");
1355 if (*refname
++ != *rule
++)
1360 * Check that our "%" is the expected placeholder. This assumes there
1361 * are no other percents (placeholder or quoted) in the string, but
1362 * that is sufficient for our rev-parse rules.
1364 if (!skip_prefix(rule
, "%.*s", &rule
))
1368 * And now check that our suffix (if any) matches.
1370 if (!strip_suffix(refname
, rule
, len
))
1373 return refname
; /* len set by strip_suffix() */
1376 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1377 const char *refname
, int strict
)
1380 struct strbuf resolved_buf
= STRBUF_INIT
;
1382 /* skip first rule, it will always match */
1383 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1385 int rules_to_fail
= i
;
1386 const char *short_name
;
1387 size_t short_name_len
;
1389 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1395 * in strict mode, all (except the matched one) rules
1396 * must fail to resolve to a valid non-ambiguous ref
1399 rules_to_fail
= NUM_REV_PARSE_RULES
;
1402 * check if the short name resolves to a valid ref,
1403 * but use only rules prior to the matched one
1405 for (j
= 0; j
< rules_to_fail
; j
++) {
1406 const char *rule
= ref_rev_parse_rules
[j
];
1408 /* skip matched rule */
1413 * the short name is ambiguous, if it resolves
1414 * (with this previous rule) to a valid ref
1415 * read_ref() returns 0 on success
1417 strbuf_reset(&resolved_buf
);
1418 strbuf_addf(&resolved_buf
, rule
,
1419 cast_size_t_to_int(short_name_len
),
1421 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1426 * short name is non-ambiguous if all previous rules
1427 * haven't resolved to a valid ref
1429 if (j
== rules_to_fail
) {
1430 strbuf_release(&resolved_buf
);
1431 return xmemdupz(short_name
, short_name_len
);
1435 strbuf_release(&resolved_buf
);
1436 return xstrdup(refname
);
1439 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1441 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1445 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1446 struct strvec
*hide_refs
)
1449 if (!strcmp("transfer.hiderefs", var
) ||
1450 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1451 !strcmp(key
, "hiderefs"))) {
1456 return config_error_nonbool(var
);
1458 /* drop const to remove trailing '/' characters */
1459 ref
= (char *)strvec_push(hide_refs
, value
);
1461 while (len
&& ref
[len
- 1] == '/')
1467 int ref_is_hidden(const char *refname
, const char *refname_full
,
1468 const struct strvec
*hide_refs
)
1472 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1473 const char *match
= hide_refs
->v
[i
];
1474 const char *subject
;
1478 if (*match
== '!') {
1483 if (*match
== '^') {
1484 subject
= refname_full
;
1490 /* refname can be NULL when namespaces are used. */
1492 skip_prefix(subject
, match
, &p
) &&
1499 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1501 const char **pattern
;
1502 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1504 * We can't feed any excludes from hidden refs config
1505 * sections, since later rules may override previous
1506 * ones. For example, with rules "refs/foo" and
1507 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1508 * everything underneath it), but the earlier exclusion
1509 * would cause us to skip all of "refs/foo". We
1510 * likewise don't implement the namespace stripping
1511 * required for '^' rules.
1513 * Both are possible to do, but complicated, so avoid
1514 * populating the jump list at all if we see either of
1517 if (**pattern
== '!' || **pattern
== '^')
1520 return hide_refs
->v
;
1523 const char *find_descendant_ref(const char *dirname
,
1524 const struct string_list
*extras
,
1525 const struct string_list
*skip
)
1533 * Look at the place where dirname would be inserted into
1534 * extras. If there is an entry at that position that starts
1535 * with dirname (remember, dirname includes the trailing
1536 * slash) and is not in skip, then we have a conflict.
1538 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1539 pos
< extras
->nr
; pos
++) {
1540 const char *extra_refname
= extras
->items
[pos
].string
;
1542 if (!starts_with(extra_refname
, dirname
))
1545 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1546 return extra_refname
;
1551 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1553 struct object_id oid
;
1556 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1558 return fn("HEAD", &oid
, flag
, cb_data
);
1563 int head_ref(each_ref_fn fn
, void *cb_data
)
1565 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1568 struct ref_iterator
*refs_ref_iterator_begin(
1569 struct ref_store
*refs
,
1571 const char **exclude_patterns
,
1573 enum do_for_each_ref_flags flags
)
1575 struct ref_iterator
*iter
;
1577 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1578 static int ref_paranoia
= -1;
1580 if (ref_paranoia
< 0)
1581 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1583 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1584 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1588 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1590 * `iterator_begin()` already takes care of prefix, but we
1591 * might need to do some trimming:
1594 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1596 /* Sanity check for subclasses: */
1598 BUG("reference iterator is not ordered");
1604 * Call fn for each reference in the specified submodule for which the
1605 * refname begins with prefix. If trim is non-zero, then trim that
1606 * many characters off the beginning of each refname before passing
1607 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1608 * include broken references in the iteration. If fn ever returns a
1609 * non-zero value, stop the iteration and return that value;
1610 * otherwise, return 0.
1612 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1613 each_repo_ref_fn fn
, int trim
, int flags
,
1616 struct ref_iterator
*iter
;
1617 struct ref_store
*refs
= get_main_ref_store(r
);
1622 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1624 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1627 struct do_for_each_ref_help
{
1632 static int do_for_each_ref_helper(struct repository
*r UNUSED
,
1633 const char *refname
,
1634 const struct object_id
*oid
,
1638 struct do_for_each_ref_help
*hp
= cb_data
;
1640 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1643 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1644 const char **exclude_patterns
,
1645 each_ref_fn fn
, int trim
,
1646 enum do_for_each_ref_flags flags
, void *cb_data
)
1648 struct ref_iterator
*iter
;
1649 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1654 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1657 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1658 do_for_each_ref_helper
, &hp
);
1661 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1663 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1666 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1668 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1671 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1672 each_ref_fn fn
, void *cb_data
)
1674 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1677 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1679 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1682 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1684 return do_for_each_ref(get_main_ref_store(the_repository
),
1685 prefix
, NULL
, fn
, 0, 0, cb_data
);
1688 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1689 const char **exclude_patterns
,
1690 each_ref_fn fn
, void *cb_data
)
1692 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1695 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1697 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1698 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1699 strlen(git_replace_ref_base
),
1700 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1703 int for_each_namespaced_ref(const char **exclude_patterns
,
1704 each_ref_fn fn
, void *cb_data
)
1706 struct strbuf buf
= STRBUF_INIT
;
1708 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1709 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1710 buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1711 strbuf_release(&buf
);
1715 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1717 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1718 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1721 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1723 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1726 static int qsort_strcmp(const void *va
, const void *vb
)
1728 const char *a
= *(const char **)va
;
1729 const char *b
= *(const char **)vb
;
1731 return strcmp(a
, b
);
1734 static void find_longest_prefixes_1(struct string_list
*out
,
1735 struct strbuf
*prefix
,
1736 const char **patterns
, size_t nr
)
1740 for (i
= 0; i
< nr
; i
++) {
1741 char c
= patterns
[i
][prefix
->len
];
1742 if (!c
|| is_glob_special(c
)) {
1743 string_list_append(out
, prefix
->buf
);
1753 * Set "end" to the index of the element _after_ the last one
1756 for (end
= i
+ 1; end
< nr
; end
++) {
1757 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1761 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1762 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1763 strbuf_setlen(prefix
, prefix
->len
- 1);
1769 static void find_longest_prefixes(struct string_list
*out
,
1770 const char **patterns
)
1772 struct strvec sorted
= STRVEC_INIT
;
1773 struct strbuf prefix
= STRBUF_INIT
;
1775 strvec_pushv(&sorted
, patterns
);
1776 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1778 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1780 strvec_clear(&sorted
);
1781 strbuf_release(&prefix
);
1784 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1785 const char *namespace,
1786 const char **patterns
,
1787 const char **exclude_patterns
,
1788 each_ref_fn fn
, void *cb_data
)
1790 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1791 struct string_list_item
*prefix
;
1792 struct strbuf buf
= STRBUF_INIT
;
1793 int ret
= 0, namespace_len
;
1795 find_longest_prefixes(&prefixes
, patterns
);
1798 strbuf_addstr(&buf
, namespace);
1799 namespace_len
= buf
.len
;
1801 for_each_string_list_item(prefix
, &prefixes
) {
1802 strbuf_addstr(&buf
, prefix
->string
);
1803 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1804 exclude_patterns
, fn
, cb_data
);
1807 strbuf_setlen(&buf
, namespace_len
);
1810 string_list_clear(&prefixes
, 0);
1811 strbuf_release(&buf
);
1815 static int refs_read_special_head(struct ref_store
*ref_store
,
1816 const char *refname
, struct object_id
*oid
,
1817 struct strbuf
*referent
, unsigned int *type
,
1820 struct strbuf full_path
= STRBUF_INIT
;
1821 struct strbuf content
= STRBUF_INIT
;
1823 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1825 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1826 *failure_errno
= errno
;
1830 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1834 strbuf_release(&full_path
);
1835 strbuf_release(&content
);
1839 static int is_special_ref(const char *refname
)
1842 * Special references get written and read directly via the filesystem
1843 * by the subsystems that create them. Thus, they must not go through
1844 * the reference backend but must instead be read directly. It is
1845 * arguable whether this behaviour is sensible, or whether it's simply
1846 * a leaky abstraction enabled by us only having a single reference
1847 * backend implementation. But at least for a subset of references it
1848 * indeed does make sense to treat them specially:
1850 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1851 * carries additional metadata like where it came from.
1853 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1856 * There are some exceptions that you might expect to see on this list
1857 * but which are handled exclusively via the reference backend:
1859 * - BISECT_EXPECTED_REV
1861 * - CHERRY_PICK_HEAD
1867 * - "rebase-apply/" and "rebase-merge/" contain all of the state for
1868 * rebases, including some reference-like files. These are
1869 * exclusively read and written via the filesystem and never go
1870 * through the refdb.
1872 * Writing or deleting references must consistently go either through
1873 * the filesystem (special refs) or through the reference backend
1876 static const char * const special_refs
[] = {
1883 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1884 if (!strcmp(refname
, special_refs
[i
]))
1890 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1891 struct object_id
*oid
, struct strbuf
*referent
,
1892 unsigned int *type
, int *failure_errno
)
1894 assert(failure_errno
);
1895 if (is_special_ref(refname
))
1896 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1897 type
, failure_errno
);
1899 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1900 type
, failure_errno
);
1903 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1904 struct strbuf
*referent
)
1906 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1909 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1910 const char *refname
,
1912 struct object_id
*oid
,
1915 static struct strbuf sb_refname
= STRBUF_INIT
;
1916 struct object_id unused_oid
;
1923 flags
= &unused_flags
;
1927 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1928 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1929 !refname_is_safe(refname
))
1933 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1934 * missing refs and refs that were present but invalid,
1935 * to complain about the latter to stderr.
1937 * We don't know whether the ref exists, so don't set
1940 *flags
|= REF_BAD_NAME
;
1943 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1944 unsigned int read_flags
= 0;
1947 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1948 &read_flags
, &failure_errno
)) {
1949 *flags
|= read_flags
;
1951 /* In reading mode, refs must eventually resolve */
1952 if (resolve_flags
& RESOLVE_REF_READING
)
1956 * Otherwise a missing ref is OK. But the files backend
1957 * may show errors besides ENOENT if there are
1958 * similarly-named refs.
1960 if (failure_errno
!= ENOENT
&&
1961 failure_errno
!= EISDIR
&&
1962 failure_errno
!= ENOTDIR
)
1966 if (*flags
& REF_BAD_NAME
)
1967 *flags
|= REF_ISBROKEN
;
1971 *flags
|= read_flags
;
1973 if (!(read_flags
& REF_ISSYMREF
)) {
1974 if (*flags
& REF_BAD_NAME
) {
1976 *flags
|= REF_ISBROKEN
;
1981 refname
= sb_refname
.buf
;
1982 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1986 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1987 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1988 !refname_is_safe(refname
))
1991 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1998 /* backend functions */
1999 int refs_init_db(struct strbuf
*err
)
2001 struct ref_store
*refs
= get_main_ref_store(the_repository
);
2003 return refs
->be
->init_db(refs
, err
);
2006 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
2007 struct object_id
*oid
, int *flags
)
2009 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
2010 resolve_flags
, oid
, flags
);
2013 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
2014 struct object_id
*oid
)
2016 struct ref_store
*refs
;
2019 refs
= get_submodule_ref_store(submodule
);
2024 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
2030 struct ref_store_hash_entry
2032 struct hashmap_entry ent
;
2034 struct ref_store
*refs
;
2036 /* NUL-terminated identifier of the ref store: */
2037 char name
[FLEX_ARRAY
];
2040 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
2041 const struct hashmap_entry
*eptr
,
2042 const struct hashmap_entry
*entry_or_key
,
2043 const void *keydata
)
2045 const struct ref_store_hash_entry
*e1
, *e2
;
2048 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2049 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2050 name
= keydata
? keydata
: e2
->name
;
2052 return strcmp(e1
->name
, name
);
2055 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2056 const char *name
, struct ref_store
*refs
)
2058 struct ref_store_hash_entry
*entry
;
2060 FLEX_ALLOC_STR(entry
, name
, name
);
2061 hashmap_entry_init(&entry
->ent
, strhash(name
));
2066 /* A hashmap of ref_stores, stored by submodule name: */
2067 static struct hashmap submodule_ref_stores
;
2069 /* A hashmap of ref_stores, stored by worktree id: */
2070 static struct hashmap worktree_ref_stores
;
2073 * Look up a ref store by name. If that ref_store hasn't been
2074 * registered yet, return NULL.
2076 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2079 struct ref_store_hash_entry
*entry
;
2082 if (!map
->tablesize
)
2083 /* It's initialized on demand in register_ref_store(). */
2086 hash
= strhash(name
);
2087 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2088 struct ref_store_hash_entry
, ent
);
2089 return entry
? entry
->refs
: NULL
;
2093 * Create, record, and return a ref_store instance for the specified
2096 static struct ref_store
*ref_store_init(struct repository
*repo
,
2100 const struct ref_storage_be
*be
;
2101 struct ref_store
*refs
;
2103 be
= find_ref_storage_backend(repo
->ref_storage_format
);
2105 BUG("reference backend is unknown");
2107 refs
= be
->init(repo
, gitdir
, flags
);
2111 struct ref_store
*get_main_ref_store(struct repository
*r
)
2113 if (r
->refs_private
)
2114 return r
->refs_private
;
2117 BUG("attempting to get main_ref_store outside of repository");
2119 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2120 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2121 return r
->refs_private
;
2125 * Associate a ref store with a name. It is a fatal error to call this
2126 * function twice for the same name.
2128 static void register_ref_store_map(struct hashmap
*map
,
2130 struct ref_store
*refs
,
2133 struct ref_store_hash_entry
*entry
;
2135 if (!map
->tablesize
)
2136 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2138 entry
= alloc_ref_store_hash_entry(name
, refs
);
2139 if (hashmap_put(map
, &entry
->ent
))
2140 BUG("%s ref_store '%s' initialized twice", type
, name
);
2143 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2145 struct strbuf submodule_sb
= STRBUF_INIT
;
2146 struct ref_store
*refs
;
2147 char *to_free
= NULL
;
2149 struct repository
*subrepo
;
2154 len
= strlen(submodule
);
2155 while (len
&& is_dir_sep(submodule
[len
- 1]))
2161 /* We need to strip off one or more trailing slashes */
2162 submodule
= to_free
= xmemdupz(submodule
, len
);
2164 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2168 strbuf_addstr(&submodule_sb
, submodule
);
2169 if (!is_nonbare_repository_dir(&submodule_sb
))
2172 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2175 subrepo
= xmalloc(sizeof(*subrepo
));
2177 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2178 * superprojects other than the_repository. This probably should be
2179 * done by making it take a struct repository * parameter instead of a
2182 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2187 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2188 REF_STORE_READ
| REF_STORE_ODB
);
2189 register_ref_store_map(&submodule_ref_stores
, "submodule",
2193 strbuf_release(&submodule_sb
);
2199 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2201 struct ref_store
*refs
;
2205 return get_main_ref_store(the_repository
);
2207 id
= wt
->id
? wt
->id
: "/";
2208 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2213 refs
= ref_store_init(the_repository
,
2214 git_common_path("worktrees/%s", wt
->id
),
2215 REF_STORE_ALL_CAPS
);
2217 refs
= ref_store_init(the_repository
,
2218 get_git_common_dir(),
2219 REF_STORE_ALL_CAPS
);
2222 register_ref_store_map(&worktree_ref_stores
, "worktree",
2227 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2228 const char *path
, const struct ref_storage_be
*be
)
2232 refs
->gitdir
= xstrdup(path
);
2235 /* backend functions */
2236 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2238 return refs
->be
->pack_refs(refs
, opts
);
2241 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2243 if (current_ref_iter
&&
2244 (current_ref_iter
->oid
== base
||
2245 oideq(current_ref_iter
->oid
, base
)))
2246 return ref_iterator_peel(current_ref_iter
, peeled
);
2248 return peel_object(base
, peeled
) ? -1 : 0;
2251 int refs_create_symref(struct ref_store
*refs
,
2252 const char *ref_target
,
2253 const char *refs_heads_master
,
2259 msg
= normalize_reflog_message(logmsg
);
2260 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2266 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2269 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2270 refs_heads_master
, logmsg
);
2273 int ref_update_reject_duplicates(struct string_list
*refnames
,
2276 size_t i
, n
= refnames
->nr
;
2280 for (i
= 1; i
< n
; i
++) {
2281 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2282 refnames
->items
[i
].string
);
2286 _("multiple updates for ref '%s' not allowed"),
2287 refnames
->items
[i
].string
);
2289 } else if (cmp
> 0) {
2290 BUG("ref_update_reject_duplicates() received unsorted list");
2296 static int run_transaction_hook(struct ref_transaction
*transaction
,
2299 struct child_process proc
= CHILD_PROCESS_INIT
;
2300 struct strbuf buf
= STRBUF_INIT
;
2304 hook
= find_hook("reference-transaction");
2308 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2310 proc
.stdout_to_stderr
= 1;
2311 proc
.trace2_hook_name
= "reference-transaction";
2313 ret
= start_command(&proc
);
2317 sigchain_push(SIGPIPE
, SIG_IGN
);
2319 for (i
= 0; i
< transaction
->nr
; i
++) {
2320 struct ref_update
*update
= transaction
->updates
[i
];
2323 strbuf_addf(&buf
, "%s %s %s\n",
2324 oid_to_hex(&update
->old_oid
),
2325 oid_to_hex(&update
->new_oid
),
2328 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2329 if (errno
!= EPIPE
) {
2330 /* Don't leak errno outside this API */
2339 sigchain_pop(SIGPIPE
);
2340 strbuf_release(&buf
);
2342 ret
|= finish_command(&proc
);
2346 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2349 struct ref_store
*refs
= transaction
->ref_store
;
2352 switch (transaction
->state
) {
2353 case REF_TRANSACTION_OPEN
:
2356 case REF_TRANSACTION_PREPARED
:
2357 BUG("prepare called twice on reference transaction");
2359 case REF_TRANSACTION_CLOSED
:
2360 BUG("prepare called on a closed reference transaction");
2363 BUG("unexpected reference transaction state");
2367 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2369 _("ref updates forbidden inside quarantine environment"));
2373 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2377 ret
= run_transaction_hook(transaction
, "prepared");
2379 ref_transaction_abort(transaction
, err
);
2380 die(_("ref updates aborted by hook"));
2386 int ref_transaction_abort(struct ref_transaction
*transaction
,
2389 struct ref_store
*refs
= transaction
->ref_store
;
2392 switch (transaction
->state
) {
2393 case REF_TRANSACTION_OPEN
:
2394 /* No need to abort explicitly. */
2396 case REF_TRANSACTION_PREPARED
:
2397 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2399 case REF_TRANSACTION_CLOSED
:
2400 BUG("abort called on a closed reference transaction");
2403 BUG("unexpected reference transaction state");
2407 run_transaction_hook(transaction
, "aborted");
2409 ref_transaction_free(transaction
);
2413 int ref_transaction_commit(struct ref_transaction
*transaction
,
2416 struct ref_store
*refs
= transaction
->ref_store
;
2419 switch (transaction
->state
) {
2420 case REF_TRANSACTION_OPEN
:
2421 /* Need to prepare first. */
2422 ret
= ref_transaction_prepare(transaction
, err
);
2426 case REF_TRANSACTION_PREPARED
:
2427 /* Fall through to finish. */
2429 case REF_TRANSACTION_CLOSED
:
2430 BUG("commit called on a closed reference transaction");
2433 BUG("unexpected reference transaction state");
2437 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2439 run_transaction_hook(transaction
, "committed");
2443 int refs_verify_refname_available(struct ref_store
*refs
,
2444 const char *refname
,
2445 const struct string_list
*extras
,
2446 const struct string_list
*skip
,
2450 const char *extra_refname
;
2451 struct strbuf dirname
= STRBUF_INIT
;
2452 struct strbuf referent
= STRBUF_INIT
;
2453 struct object_id oid
;
2455 struct ref_iterator
*iter
;
2460 * For the sake of comments in this function, suppose that
2461 * refname is "refs/foo/bar".
2466 strbuf_grow(&dirname
, strlen(refname
) + 1);
2467 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2469 * Just saying "Is a directory" when we e.g. can't
2470 * lock some multi-level ref isn't very informative,
2471 * the user won't be told *what* is a directory, so
2472 * let's not use strerror() below.
2475 /* Expand dirname to the new prefix, not including the trailing slash: */
2476 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2479 * We are still at a leading dir of the refname (e.g.,
2480 * "refs/foo"; if there is a reference with that name,
2481 * it is a conflict, *unless* it is in skip.
2483 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2486 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2487 &type
, &ignore_errno
)) {
2488 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2489 dirname
.buf
, refname
);
2493 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2494 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2495 refname
, dirname
.buf
);
2501 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2502 * There is no point in searching for a reference with that
2503 * name, because a refname isn't considered to conflict with
2504 * itself. But we still need to check for references whose
2505 * names are in the "refs/foo/bar/" namespace, because they
2508 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2509 strbuf_addch(&dirname
, '/');
2511 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2512 DO_FOR_EACH_INCLUDE_BROKEN
);
2513 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2515 string_list_has_string(skip
, iter
->refname
))
2518 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2519 iter
->refname
, refname
);
2520 ref_iterator_abort(iter
);
2524 if (ok
!= ITER_DONE
)
2525 BUG("error while iterating over references");
2527 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2529 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2530 refname
, extra_refname
);
2535 strbuf_release(&referent
);
2536 strbuf_release(&dirname
);
2540 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2542 struct ref_iterator
*iter
;
2543 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2545 iter
= refs
->be
->reflog_iterator_begin(refs
);
2547 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2548 do_for_each_ref_helper
, &hp
);
2551 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2553 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2556 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2557 const char *refname
,
2558 each_reflog_ent_fn fn
,
2561 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2565 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2568 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2569 refname
, fn
, cb_data
);
2572 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2573 each_reflog_ent_fn fn
, void *cb_data
)
2575 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2578 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2581 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2585 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2587 return refs
->be
->reflog_exists(refs
, refname
);
2590 int reflog_exists(const char *refname
)
2592 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2595 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2598 return refs
->be
->create_reflog(refs
, refname
, err
);
2601 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2603 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2607 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2609 return refs
->be
->delete_reflog(refs
, refname
);
2612 int delete_reflog(const char *refname
)
2614 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2617 int refs_reflog_expire(struct ref_store
*refs
,
2618 const char *refname
,
2620 reflog_expiry_prepare_fn prepare_fn
,
2621 reflog_expiry_should_prune_fn should_prune_fn
,
2622 reflog_expiry_cleanup_fn cleanup_fn
,
2623 void *policy_cb_data
)
2625 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2626 prepare_fn
, should_prune_fn
,
2627 cleanup_fn
, policy_cb_data
);
2630 int reflog_expire(const char *refname
,
2632 reflog_expiry_prepare_fn prepare_fn
,
2633 reflog_expiry_should_prune_fn should_prune_fn
,
2634 reflog_expiry_cleanup_fn cleanup_fn
,
2635 void *policy_cb_data
)
2637 return refs_reflog_expire(get_main_ref_store(the_repository
),
2639 prepare_fn
, should_prune_fn
,
2640 cleanup_fn
, policy_cb_data
);
2643 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2646 struct ref_store
*refs
= transaction
->ref_store
;
2648 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2651 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2652 ref_transaction_for_each_queued_update_fn cb
,
2657 for (i
= 0; i
< transaction
->nr
; i
++) {
2658 struct ref_update
*update
= transaction
->updates
[i
];
2661 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2662 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2667 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2668 struct string_list
*refnames
, unsigned int flags
)
2670 struct ref_transaction
*transaction
;
2671 struct strbuf err
= STRBUF_INIT
;
2672 struct string_list_item
*item
;
2673 int ret
= 0, failures
= 0;
2679 msg
= normalize_reflog_message(logmsg
);
2682 * Since we don't check the references' old_oids, the
2683 * individual updates can't fail, so we can pack all of the
2684 * updates into a single transaction.
2686 transaction
= ref_store_transaction_begin(refs
, &err
);
2688 ret
= error("%s", err
.buf
);
2692 for_each_string_list_item(item
, refnames
) {
2693 ret
= ref_transaction_delete(transaction
, item
->string
,
2694 NULL
, flags
, msg
, &err
);
2696 warning(_("could not delete reference %s: %s"),
2697 item
->string
, err
.buf
);
2703 ret
= ref_transaction_commit(transaction
, &err
);
2705 if (refnames
->nr
== 1)
2706 error(_("could not delete reference %s: %s"),
2707 refnames
->items
[0].string
, err
.buf
);
2709 error(_("could not delete references: %s"), err
.buf
);
2713 if (!ret
&& failures
)
2715 ref_transaction_free(transaction
);
2716 strbuf_release(&err
);
2721 int delete_refs(const char *msg
, struct string_list
*refnames
,
2724 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2727 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2728 const char *newref
, const char *logmsg
)
2733 msg
= normalize_reflog_message(logmsg
);
2734 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2739 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2741 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2744 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2745 const char *newref
, const char *logmsg
)
2750 msg
= normalize_reflog_message(logmsg
);
2751 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2756 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2758 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);