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
[] = {
1884 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1885 if (!strcmp(refname
, special_refs
[i
]))
1891 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1892 struct object_id
*oid
, struct strbuf
*referent
,
1893 unsigned int *type
, int *failure_errno
)
1895 assert(failure_errno
);
1896 if (is_special_ref(refname
))
1897 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1898 type
, failure_errno
);
1900 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1901 type
, failure_errno
);
1904 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1905 struct strbuf
*referent
)
1907 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1910 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1911 const char *refname
,
1913 struct object_id
*oid
,
1916 static struct strbuf sb_refname
= STRBUF_INIT
;
1917 struct object_id unused_oid
;
1924 flags
= &unused_flags
;
1928 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1929 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1930 !refname_is_safe(refname
))
1934 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1935 * missing refs and refs that were present but invalid,
1936 * to complain about the latter to stderr.
1938 * We don't know whether the ref exists, so don't set
1941 *flags
|= REF_BAD_NAME
;
1944 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1945 unsigned int read_flags
= 0;
1948 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1949 &read_flags
, &failure_errno
)) {
1950 *flags
|= read_flags
;
1952 /* In reading mode, refs must eventually resolve */
1953 if (resolve_flags
& RESOLVE_REF_READING
)
1957 * Otherwise a missing ref is OK. But the files backend
1958 * may show errors besides ENOENT if there are
1959 * similarly-named refs.
1961 if (failure_errno
!= ENOENT
&&
1962 failure_errno
!= EISDIR
&&
1963 failure_errno
!= ENOTDIR
)
1967 if (*flags
& REF_BAD_NAME
)
1968 *flags
|= REF_ISBROKEN
;
1972 *flags
|= read_flags
;
1974 if (!(read_flags
& REF_ISSYMREF
)) {
1975 if (*flags
& REF_BAD_NAME
) {
1977 *flags
|= REF_ISBROKEN
;
1982 refname
= sb_refname
.buf
;
1983 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1987 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1988 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1989 !refname_is_safe(refname
))
1992 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1999 /* backend functions */
2000 int refs_init_db(struct strbuf
*err
)
2002 struct ref_store
*refs
= get_main_ref_store(the_repository
);
2004 return refs
->be
->init_db(refs
, err
);
2007 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
2008 struct object_id
*oid
, int *flags
)
2010 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
2011 resolve_flags
, oid
, flags
);
2014 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
2015 struct object_id
*oid
)
2017 struct ref_store
*refs
;
2020 refs
= get_submodule_ref_store(submodule
);
2025 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
2031 struct ref_store_hash_entry
2033 struct hashmap_entry ent
;
2035 struct ref_store
*refs
;
2037 /* NUL-terminated identifier of the ref store: */
2038 char name
[FLEX_ARRAY
];
2041 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
2042 const struct hashmap_entry
*eptr
,
2043 const struct hashmap_entry
*entry_or_key
,
2044 const void *keydata
)
2046 const struct ref_store_hash_entry
*e1
, *e2
;
2049 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2050 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2051 name
= keydata
? keydata
: e2
->name
;
2053 return strcmp(e1
->name
, name
);
2056 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2057 const char *name
, struct ref_store
*refs
)
2059 struct ref_store_hash_entry
*entry
;
2061 FLEX_ALLOC_STR(entry
, name
, name
);
2062 hashmap_entry_init(&entry
->ent
, strhash(name
));
2067 /* A hashmap of ref_stores, stored by submodule name: */
2068 static struct hashmap submodule_ref_stores
;
2070 /* A hashmap of ref_stores, stored by worktree id: */
2071 static struct hashmap worktree_ref_stores
;
2074 * Look up a ref store by name. If that ref_store hasn't been
2075 * registered yet, return NULL.
2077 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2080 struct ref_store_hash_entry
*entry
;
2083 if (!map
->tablesize
)
2084 /* It's initialized on demand in register_ref_store(). */
2087 hash
= strhash(name
);
2088 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2089 struct ref_store_hash_entry
, ent
);
2090 return entry
? entry
->refs
: NULL
;
2094 * Create, record, and return a ref_store instance for the specified
2097 static struct ref_store
*ref_store_init(struct repository
*repo
,
2101 const struct ref_storage_be
*be
;
2102 struct ref_store
*refs
;
2104 be
= find_ref_storage_backend(repo
->ref_storage_format
);
2106 BUG("reference backend is unknown");
2108 refs
= be
->init(repo
, gitdir
, flags
);
2112 struct ref_store
*get_main_ref_store(struct repository
*r
)
2114 if (r
->refs_private
)
2115 return r
->refs_private
;
2118 BUG("attempting to get main_ref_store outside of repository");
2120 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2121 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2122 return r
->refs_private
;
2126 * Associate a ref store with a name. It is a fatal error to call this
2127 * function twice for the same name.
2129 static void register_ref_store_map(struct hashmap
*map
,
2131 struct ref_store
*refs
,
2134 struct ref_store_hash_entry
*entry
;
2136 if (!map
->tablesize
)
2137 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2139 entry
= alloc_ref_store_hash_entry(name
, refs
);
2140 if (hashmap_put(map
, &entry
->ent
))
2141 BUG("%s ref_store '%s' initialized twice", type
, name
);
2144 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2146 struct strbuf submodule_sb
= STRBUF_INIT
;
2147 struct ref_store
*refs
;
2148 char *to_free
= NULL
;
2150 struct repository
*subrepo
;
2155 len
= strlen(submodule
);
2156 while (len
&& is_dir_sep(submodule
[len
- 1]))
2162 /* We need to strip off one or more trailing slashes */
2163 submodule
= to_free
= xmemdupz(submodule
, len
);
2165 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2169 strbuf_addstr(&submodule_sb
, submodule
);
2170 if (!is_nonbare_repository_dir(&submodule_sb
))
2173 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2176 subrepo
= xmalloc(sizeof(*subrepo
));
2178 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2179 * superprojects other than the_repository. This probably should be
2180 * done by making it take a struct repository * parameter instead of a
2183 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2188 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2189 REF_STORE_READ
| REF_STORE_ODB
);
2190 register_ref_store_map(&submodule_ref_stores
, "submodule",
2194 strbuf_release(&submodule_sb
);
2200 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2202 struct ref_store
*refs
;
2206 return get_main_ref_store(the_repository
);
2208 id
= wt
->id
? wt
->id
: "/";
2209 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2214 refs
= ref_store_init(the_repository
,
2215 git_common_path("worktrees/%s", wt
->id
),
2216 REF_STORE_ALL_CAPS
);
2218 refs
= ref_store_init(the_repository
,
2219 get_git_common_dir(),
2220 REF_STORE_ALL_CAPS
);
2223 register_ref_store_map(&worktree_ref_stores
, "worktree",
2228 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2229 const char *path
, const struct ref_storage_be
*be
)
2233 refs
->gitdir
= xstrdup(path
);
2236 /* backend functions */
2237 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2239 return refs
->be
->pack_refs(refs
, opts
);
2242 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2244 if (current_ref_iter
&&
2245 (current_ref_iter
->oid
== base
||
2246 oideq(current_ref_iter
->oid
, base
)))
2247 return ref_iterator_peel(current_ref_iter
, peeled
);
2249 return peel_object(base
, peeled
) ? -1 : 0;
2252 int refs_create_symref(struct ref_store
*refs
,
2253 const char *ref_target
,
2254 const char *refs_heads_master
,
2260 msg
= normalize_reflog_message(logmsg
);
2261 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2267 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2270 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2271 refs_heads_master
, logmsg
);
2274 int ref_update_reject_duplicates(struct string_list
*refnames
,
2277 size_t i
, n
= refnames
->nr
;
2281 for (i
= 1; i
< n
; i
++) {
2282 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2283 refnames
->items
[i
].string
);
2287 _("multiple updates for ref '%s' not allowed"),
2288 refnames
->items
[i
].string
);
2290 } else if (cmp
> 0) {
2291 BUG("ref_update_reject_duplicates() received unsorted list");
2297 static int run_transaction_hook(struct ref_transaction
*transaction
,
2300 struct child_process proc
= CHILD_PROCESS_INIT
;
2301 struct strbuf buf
= STRBUF_INIT
;
2305 hook
= find_hook("reference-transaction");
2309 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2311 proc
.stdout_to_stderr
= 1;
2312 proc
.trace2_hook_name
= "reference-transaction";
2314 ret
= start_command(&proc
);
2318 sigchain_push(SIGPIPE
, SIG_IGN
);
2320 for (i
= 0; i
< transaction
->nr
; i
++) {
2321 struct ref_update
*update
= transaction
->updates
[i
];
2324 strbuf_addf(&buf
, "%s %s %s\n",
2325 oid_to_hex(&update
->old_oid
),
2326 oid_to_hex(&update
->new_oid
),
2329 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2330 if (errno
!= EPIPE
) {
2331 /* Don't leak errno outside this API */
2340 sigchain_pop(SIGPIPE
);
2341 strbuf_release(&buf
);
2343 ret
|= finish_command(&proc
);
2347 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2350 struct ref_store
*refs
= transaction
->ref_store
;
2353 switch (transaction
->state
) {
2354 case REF_TRANSACTION_OPEN
:
2357 case REF_TRANSACTION_PREPARED
:
2358 BUG("prepare called twice on reference transaction");
2360 case REF_TRANSACTION_CLOSED
:
2361 BUG("prepare called on a closed reference transaction");
2364 BUG("unexpected reference transaction state");
2368 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2370 _("ref updates forbidden inside quarantine environment"));
2374 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2378 ret
= run_transaction_hook(transaction
, "prepared");
2380 ref_transaction_abort(transaction
, err
);
2381 die(_("ref updates aborted by hook"));
2387 int ref_transaction_abort(struct ref_transaction
*transaction
,
2390 struct ref_store
*refs
= transaction
->ref_store
;
2393 switch (transaction
->state
) {
2394 case REF_TRANSACTION_OPEN
:
2395 /* No need to abort explicitly. */
2397 case REF_TRANSACTION_PREPARED
:
2398 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2400 case REF_TRANSACTION_CLOSED
:
2401 BUG("abort called on a closed reference transaction");
2404 BUG("unexpected reference transaction state");
2408 run_transaction_hook(transaction
, "aborted");
2410 ref_transaction_free(transaction
);
2414 int ref_transaction_commit(struct ref_transaction
*transaction
,
2417 struct ref_store
*refs
= transaction
->ref_store
;
2420 switch (transaction
->state
) {
2421 case REF_TRANSACTION_OPEN
:
2422 /* Need to prepare first. */
2423 ret
= ref_transaction_prepare(transaction
, err
);
2427 case REF_TRANSACTION_PREPARED
:
2428 /* Fall through to finish. */
2430 case REF_TRANSACTION_CLOSED
:
2431 BUG("commit called on a closed reference transaction");
2434 BUG("unexpected reference transaction state");
2438 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2440 run_transaction_hook(transaction
, "committed");
2444 int refs_verify_refname_available(struct ref_store
*refs
,
2445 const char *refname
,
2446 const struct string_list
*extras
,
2447 const struct string_list
*skip
,
2451 const char *extra_refname
;
2452 struct strbuf dirname
= STRBUF_INIT
;
2453 struct strbuf referent
= STRBUF_INIT
;
2454 struct object_id oid
;
2456 struct ref_iterator
*iter
;
2461 * For the sake of comments in this function, suppose that
2462 * refname is "refs/foo/bar".
2467 strbuf_grow(&dirname
, strlen(refname
) + 1);
2468 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2470 * Just saying "Is a directory" when we e.g. can't
2471 * lock some multi-level ref isn't very informative,
2472 * the user won't be told *what* is a directory, so
2473 * let's not use strerror() below.
2476 /* Expand dirname to the new prefix, not including the trailing slash: */
2477 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2480 * We are still at a leading dir of the refname (e.g.,
2481 * "refs/foo"; if there is a reference with that name,
2482 * it is a conflict, *unless* it is in skip.
2484 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2487 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2488 &type
, &ignore_errno
)) {
2489 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2490 dirname
.buf
, refname
);
2494 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2495 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2496 refname
, dirname
.buf
);
2502 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2503 * There is no point in searching for a reference with that
2504 * name, because a refname isn't considered to conflict with
2505 * itself. But we still need to check for references whose
2506 * names are in the "refs/foo/bar/" namespace, because they
2509 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2510 strbuf_addch(&dirname
, '/');
2512 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2513 DO_FOR_EACH_INCLUDE_BROKEN
);
2514 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2516 string_list_has_string(skip
, iter
->refname
))
2519 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2520 iter
->refname
, refname
);
2521 ref_iterator_abort(iter
);
2525 if (ok
!= ITER_DONE
)
2526 BUG("error while iterating over references");
2528 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2530 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2531 refname
, extra_refname
);
2536 strbuf_release(&referent
);
2537 strbuf_release(&dirname
);
2541 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2543 struct ref_iterator
*iter
;
2544 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2546 iter
= refs
->be
->reflog_iterator_begin(refs
);
2548 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2549 do_for_each_ref_helper
, &hp
);
2552 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2554 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2557 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2558 const char *refname
,
2559 each_reflog_ent_fn fn
,
2562 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2566 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2569 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2570 refname
, fn
, cb_data
);
2573 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2574 each_reflog_ent_fn fn
, void *cb_data
)
2576 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2579 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2582 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2586 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2588 return refs
->be
->reflog_exists(refs
, refname
);
2591 int reflog_exists(const char *refname
)
2593 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2596 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2599 return refs
->be
->create_reflog(refs
, refname
, err
);
2602 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2604 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2608 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2610 return refs
->be
->delete_reflog(refs
, refname
);
2613 int delete_reflog(const char *refname
)
2615 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2618 int refs_reflog_expire(struct ref_store
*refs
,
2619 const char *refname
,
2621 reflog_expiry_prepare_fn prepare_fn
,
2622 reflog_expiry_should_prune_fn should_prune_fn
,
2623 reflog_expiry_cleanup_fn cleanup_fn
,
2624 void *policy_cb_data
)
2626 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2627 prepare_fn
, should_prune_fn
,
2628 cleanup_fn
, policy_cb_data
);
2631 int reflog_expire(const char *refname
,
2633 reflog_expiry_prepare_fn prepare_fn
,
2634 reflog_expiry_should_prune_fn should_prune_fn
,
2635 reflog_expiry_cleanup_fn cleanup_fn
,
2636 void *policy_cb_data
)
2638 return refs_reflog_expire(get_main_ref_store(the_repository
),
2640 prepare_fn
, should_prune_fn
,
2641 cleanup_fn
, policy_cb_data
);
2644 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2647 struct ref_store
*refs
= transaction
->ref_store
;
2649 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2652 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2653 ref_transaction_for_each_queued_update_fn cb
,
2658 for (i
= 0; i
< transaction
->nr
; i
++) {
2659 struct ref_update
*update
= transaction
->updates
[i
];
2662 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2663 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2668 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2669 struct string_list
*refnames
, unsigned int flags
)
2671 struct ref_transaction
*transaction
;
2672 struct strbuf err
= STRBUF_INIT
;
2673 struct string_list_item
*item
;
2674 int ret
= 0, failures
= 0;
2680 msg
= normalize_reflog_message(logmsg
);
2683 * Since we don't check the references' old_oids, the
2684 * individual updates can't fail, so we can pack all of the
2685 * updates into a single transaction.
2687 transaction
= ref_store_transaction_begin(refs
, &err
);
2689 ret
= error("%s", err
.buf
);
2693 for_each_string_list_item(item
, refnames
) {
2694 ret
= ref_transaction_delete(transaction
, item
->string
,
2695 NULL
, flags
, msg
, &err
);
2697 warning(_("could not delete reference %s: %s"),
2698 item
->string
, err
.buf
);
2704 ret
= ref_transaction_commit(transaction
, &err
);
2706 if (refnames
->nr
== 1)
2707 error(_("could not delete reference %s: %s"),
2708 refnames
->items
[0].string
, err
.buf
);
2710 error(_("could not delete references: %s"), err
.buf
);
2714 if (!ret
&& failures
)
2716 ref_transaction_free(transaction
);
2717 strbuf_release(&err
);
2722 int delete_refs(const char *msg
, struct string_list
*refnames
,
2725 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2728 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2729 const char *newref
, const char *logmsg
)
2734 msg
= normalize_reflog_message(logmsg
);
2735 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2740 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2742 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2745 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2746 const char *newref
, const char *logmsg
)
2751 msg
= normalize_reflog_message(logmsg
);
2752 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2757 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2759 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);