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)
1828 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1832 strbuf_release(&full_path
);
1833 strbuf_release(&content
);
1837 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1838 struct object_id
*oid
, struct strbuf
*referent
,
1839 unsigned int *type
, int *failure_errno
)
1841 assert(failure_errno
);
1842 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1843 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1844 type
, failure_errno
);
1847 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1848 type
, failure_errno
);
1851 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1852 struct strbuf
*referent
)
1854 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1857 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1858 const char *refname
,
1860 struct object_id
*oid
,
1863 static struct strbuf sb_refname
= STRBUF_INIT
;
1864 struct object_id unused_oid
;
1871 flags
= &unused_flags
;
1875 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1876 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1877 !refname_is_safe(refname
))
1881 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1882 * missing refs and refs that were present but invalid,
1883 * to complain about the latter to stderr.
1885 * We don't know whether the ref exists, so don't set
1888 *flags
|= REF_BAD_NAME
;
1891 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1892 unsigned int read_flags
= 0;
1895 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1896 &read_flags
, &failure_errno
)) {
1897 *flags
|= read_flags
;
1899 /* In reading mode, refs must eventually resolve */
1900 if (resolve_flags
& RESOLVE_REF_READING
)
1904 * Otherwise a missing ref is OK. But the files backend
1905 * may show errors besides ENOENT if there are
1906 * similarly-named refs.
1908 if (failure_errno
!= ENOENT
&&
1909 failure_errno
!= EISDIR
&&
1910 failure_errno
!= ENOTDIR
)
1914 if (*flags
& REF_BAD_NAME
)
1915 *flags
|= REF_ISBROKEN
;
1919 *flags
|= read_flags
;
1921 if (!(read_flags
& REF_ISSYMREF
)) {
1922 if (*flags
& REF_BAD_NAME
) {
1924 *flags
|= REF_ISBROKEN
;
1929 refname
= sb_refname
.buf
;
1930 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1934 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1935 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1936 !refname_is_safe(refname
))
1939 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1946 /* backend functions */
1947 int refs_init_db(struct strbuf
*err
)
1949 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1951 return refs
->be
->init_db(refs
, err
);
1954 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1955 struct object_id
*oid
, int *flags
)
1957 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1958 resolve_flags
, oid
, flags
);
1961 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1962 struct object_id
*oid
)
1964 struct ref_store
*refs
;
1967 refs
= get_submodule_ref_store(submodule
);
1972 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1978 struct ref_store_hash_entry
1980 struct hashmap_entry ent
;
1982 struct ref_store
*refs
;
1984 /* NUL-terminated identifier of the ref store: */
1985 char name
[FLEX_ARRAY
];
1988 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
1989 const struct hashmap_entry
*eptr
,
1990 const struct hashmap_entry
*entry_or_key
,
1991 const void *keydata
)
1993 const struct ref_store_hash_entry
*e1
, *e2
;
1996 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1997 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1998 name
= keydata
? keydata
: e2
->name
;
2000 return strcmp(e1
->name
, name
);
2003 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2004 const char *name
, struct ref_store
*refs
)
2006 struct ref_store_hash_entry
*entry
;
2008 FLEX_ALLOC_STR(entry
, name
, name
);
2009 hashmap_entry_init(&entry
->ent
, strhash(name
));
2014 /* A hashmap of ref_stores, stored by submodule name: */
2015 static struct hashmap submodule_ref_stores
;
2017 /* A hashmap of ref_stores, stored by worktree id: */
2018 static struct hashmap worktree_ref_stores
;
2021 * Look up a ref store by name. If that ref_store hasn't been
2022 * registered yet, return NULL.
2024 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2027 struct ref_store_hash_entry
*entry
;
2030 if (!map
->tablesize
)
2031 /* It's initialized on demand in register_ref_store(). */
2034 hash
= strhash(name
);
2035 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2036 struct ref_store_hash_entry
, ent
);
2037 return entry
? entry
->refs
: NULL
;
2041 * Create, record, and return a ref_store instance for the specified
2044 static struct ref_store
*ref_store_init(struct repository
*repo
,
2048 unsigned int format
= REF_STORAGE_FORMAT_FILES
;
2049 const struct ref_storage_be
*be
= find_ref_storage_backend(format
);
2050 struct ref_store
*refs
;
2053 BUG("reference backend is unknown");
2055 refs
= be
->init(repo
, gitdir
, flags
);
2059 struct ref_store
*get_main_ref_store(struct repository
*r
)
2061 if (r
->refs_private
)
2062 return r
->refs_private
;
2065 BUG("attempting to get main_ref_store outside of repository");
2067 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2068 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2069 return r
->refs_private
;
2073 * Associate a ref store with a name. It is a fatal error to call this
2074 * function twice for the same name.
2076 static void register_ref_store_map(struct hashmap
*map
,
2078 struct ref_store
*refs
,
2081 struct ref_store_hash_entry
*entry
;
2083 if (!map
->tablesize
)
2084 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2086 entry
= alloc_ref_store_hash_entry(name
, refs
);
2087 if (hashmap_put(map
, &entry
->ent
))
2088 BUG("%s ref_store '%s' initialized twice", type
, name
);
2091 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2093 struct strbuf submodule_sb
= STRBUF_INIT
;
2094 struct ref_store
*refs
;
2095 char *to_free
= NULL
;
2097 struct repository
*subrepo
;
2102 len
= strlen(submodule
);
2103 while (len
&& is_dir_sep(submodule
[len
- 1]))
2109 /* We need to strip off one or more trailing slashes */
2110 submodule
= to_free
= xmemdupz(submodule
, len
);
2112 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2116 strbuf_addstr(&submodule_sb
, submodule
);
2117 if (!is_nonbare_repository_dir(&submodule_sb
))
2120 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2123 subrepo
= xmalloc(sizeof(*subrepo
));
2125 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2126 * superprojects other than the_repository. This probably should be
2127 * done by making it take a struct repository * parameter instead of a
2130 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2135 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2136 REF_STORE_READ
| REF_STORE_ODB
);
2137 register_ref_store_map(&submodule_ref_stores
, "submodule",
2141 strbuf_release(&submodule_sb
);
2147 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2149 struct ref_store
*refs
;
2153 return get_main_ref_store(the_repository
);
2155 id
= wt
->id
? wt
->id
: "/";
2156 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2161 refs
= ref_store_init(the_repository
,
2162 git_common_path("worktrees/%s", wt
->id
),
2163 REF_STORE_ALL_CAPS
);
2165 refs
= ref_store_init(the_repository
,
2166 get_git_common_dir(),
2167 REF_STORE_ALL_CAPS
);
2170 register_ref_store_map(&worktree_ref_stores
, "worktree",
2175 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2176 const char *path
, const struct ref_storage_be
*be
)
2180 refs
->gitdir
= xstrdup(path
);
2183 /* backend functions */
2184 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2186 return refs
->be
->pack_refs(refs
, opts
);
2189 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2191 if (current_ref_iter
&&
2192 (current_ref_iter
->oid
== base
||
2193 oideq(current_ref_iter
->oid
, base
)))
2194 return ref_iterator_peel(current_ref_iter
, peeled
);
2196 return peel_object(base
, peeled
) ? -1 : 0;
2199 int refs_create_symref(struct ref_store
*refs
,
2200 const char *ref_target
,
2201 const char *refs_heads_master
,
2207 msg
= normalize_reflog_message(logmsg
);
2208 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2214 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2217 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2218 refs_heads_master
, logmsg
);
2221 int ref_update_reject_duplicates(struct string_list
*refnames
,
2224 size_t i
, n
= refnames
->nr
;
2228 for (i
= 1; i
< n
; i
++) {
2229 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2230 refnames
->items
[i
].string
);
2234 _("multiple updates for ref '%s' not allowed"),
2235 refnames
->items
[i
].string
);
2237 } else if (cmp
> 0) {
2238 BUG("ref_update_reject_duplicates() received unsorted list");
2244 static int run_transaction_hook(struct ref_transaction
*transaction
,
2247 struct child_process proc
= CHILD_PROCESS_INIT
;
2248 struct strbuf buf
= STRBUF_INIT
;
2252 hook
= find_hook("reference-transaction");
2256 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2258 proc
.stdout_to_stderr
= 1;
2259 proc
.trace2_hook_name
= "reference-transaction";
2261 ret
= start_command(&proc
);
2265 sigchain_push(SIGPIPE
, SIG_IGN
);
2267 for (i
= 0; i
< transaction
->nr
; i
++) {
2268 struct ref_update
*update
= transaction
->updates
[i
];
2271 strbuf_addf(&buf
, "%s %s %s\n",
2272 oid_to_hex(&update
->old_oid
),
2273 oid_to_hex(&update
->new_oid
),
2276 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2277 if (errno
!= EPIPE
) {
2278 /* Don't leak errno outside this API */
2287 sigchain_pop(SIGPIPE
);
2288 strbuf_release(&buf
);
2290 ret
|= finish_command(&proc
);
2294 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2297 struct ref_store
*refs
= transaction
->ref_store
;
2300 switch (transaction
->state
) {
2301 case REF_TRANSACTION_OPEN
:
2304 case REF_TRANSACTION_PREPARED
:
2305 BUG("prepare called twice on reference transaction");
2307 case REF_TRANSACTION_CLOSED
:
2308 BUG("prepare called on a closed reference transaction");
2311 BUG("unexpected reference transaction state");
2315 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2317 _("ref updates forbidden inside quarantine environment"));
2321 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2325 ret
= run_transaction_hook(transaction
, "prepared");
2327 ref_transaction_abort(transaction
, err
);
2328 die(_("ref updates aborted by hook"));
2334 int ref_transaction_abort(struct ref_transaction
*transaction
,
2337 struct ref_store
*refs
= transaction
->ref_store
;
2340 switch (transaction
->state
) {
2341 case REF_TRANSACTION_OPEN
:
2342 /* No need to abort explicitly. */
2344 case REF_TRANSACTION_PREPARED
:
2345 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2347 case REF_TRANSACTION_CLOSED
:
2348 BUG("abort called on a closed reference transaction");
2351 BUG("unexpected reference transaction state");
2355 run_transaction_hook(transaction
, "aborted");
2357 ref_transaction_free(transaction
);
2361 int ref_transaction_commit(struct ref_transaction
*transaction
,
2364 struct ref_store
*refs
= transaction
->ref_store
;
2367 switch (transaction
->state
) {
2368 case REF_TRANSACTION_OPEN
:
2369 /* Need to prepare first. */
2370 ret
= ref_transaction_prepare(transaction
, err
);
2374 case REF_TRANSACTION_PREPARED
:
2375 /* Fall through to finish. */
2377 case REF_TRANSACTION_CLOSED
:
2378 BUG("commit called on a closed reference transaction");
2381 BUG("unexpected reference transaction state");
2385 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2387 run_transaction_hook(transaction
, "committed");
2391 int refs_verify_refname_available(struct ref_store
*refs
,
2392 const char *refname
,
2393 const struct string_list
*extras
,
2394 const struct string_list
*skip
,
2398 const char *extra_refname
;
2399 struct strbuf dirname
= STRBUF_INIT
;
2400 struct strbuf referent
= STRBUF_INIT
;
2401 struct object_id oid
;
2403 struct ref_iterator
*iter
;
2408 * For the sake of comments in this function, suppose that
2409 * refname is "refs/foo/bar".
2414 strbuf_grow(&dirname
, strlen(refname
) + 1);
2415 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2417 * Just saying "Is a directory" when we e.g. can't
2418 * lock some multi-level ref isn't very informative,
2419 * the user won't be told *what* is a directory, so
2420 * let's not use strerror() below.
2423 /* Expand dirname to the new prefix, not including the trailing slash: */
2424 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2427 * We are still at a leading dir of the refname (e.g.,
2428 * "refs/foo"; if there is a reference with that name,
2429 * it is a conflict, *unless* it is in skip.
2431 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2434 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2435 &type
, &ignore_errno
)) {
2436 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2437 dirname
.buf
, refname
);
2441 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2442 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2443 refname
, dirname
.buf
);
2449 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2450 * There is no point in searching for a reference with that
2451 * name, because a refname isn't considered to conflict with
2452 * itself. But we still need to check for references whose
2453 * names are in the "refs/foo/bar/" namespace, because they
2456 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2457 strbuf_addch(&dirname
, '/');
2459 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2460 DO_FOR_EACH_INCLUDE_BROKEN
);
2461 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2463 string_list_has_string(skip
, iter
->refname
))
2466 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2467 iter
->refname
, refname
);
2468 ref_iterator_abort(iter
);
2472 if (ok
!= ITER_DONE
)
2473 BUG("error while iterating over references");
2475 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2477 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2478 refname
, extra_refname
);
2483 strbuf_release(&referent
);
2484 strbuf_release(&dirname
);
2488 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2490 struct ref_iterator
*iter
;
2491 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2493 iter
= refs
->be
->reflog_iterator_begin(refs
);
2495 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2496 do_for_each_ref_helper
, &hp
);
2499 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2501 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2504 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2505 const char *refname
,
2506 each_reflog_ent_fn fn
,
2509 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2513 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2516 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2517 refname
, fn
, cb_data
);
2520 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2521 each_reflog_ent_fn fn
, void *cb_data
)
2523 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2526 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2529 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2533 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2535 return refs
->be
->reflog_exists(refs
, refname
);
2538 int reflog_exists(const char *refname
)
2540 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2543 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2546 return refs
->be
->create_reflog(refs
, refname
, err
);
2549 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2551 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2555 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2557 return refs
->be
->delete_reflog(refs
, refname
);
2560 int delete_reflog(const char *refname
)
2562 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2565 int refs_reflog_expire(struct ref_store
*refs
,
2566 const char *refname
,
2568 reflog_expiry_prepare_fn prepare_fn
,
2569 reflog_expiry_should_prune_fn should_prune_fn
,
2570 reflog_expiry_cleanup_fn cleanup_fn
,
2571 void *policy_cb_data
)
2573 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2574 prepare_fn
, should_prune_fn
,
2575 cleanup_fn
, policy_cb_data
);
2578 int reflog_expire(const char *refname
,
2580 reflog_expiry_prepare_fn prepare_fn
,
2581 reflog_expiry_should_prune_fn should_prune_fn
,
2582 reflog_expiry_cleanup_fn cleanup_fn
,
2583 void *policy_cb_data
)
2585 return refs_reflog_expire(get_main_ref_store(the_repository
),
2587 prepare_fn
, should_prune_fn
,
2588 cleanup_fn
, policy_cb_data
);
2591 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2594 struct ref_store
*refs
= transaction
->ref_store
;
2596 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2599 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2600 ref_transaction_for_each_queued_update_fn cb
,
2605 for (i
= 0; i
< transaction
->nr
; i
++) {
2606 struct ref_update
*update
= transaction
->updates
[i
];
2609 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2610 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2615 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2616 struct string_list
*refnames
, unsigned int flags
)
2618 struct ref_transaction
*transaction
;
2619 struct strbuf err
= STRBUF_INIT
;
2620 struct string_list_item
*item
;
2621 int ret
= 0, failures
= 0;
2627 msg
= normalize_reflog_message(logmsg
);
2630 * Since we don't check the references' old_oids, the
2631 * individual updates can't fail, so we can pack all of the
2632 * updates into a single transaction.
2634 transaction
= ref_store_transaction_begin(refs
, &err
);
2636 ret
= error("%s", err
.buf
);
2640 for_each_string_list_item(item
, refnames
) {
2641 ret
= ref_transaction_delete(transaction
, item
->string
,
2642 NULL
, flags
, msg
, &err
);
2644 warning(_("could not delete reference %s: %s"),
2645 item
->string
, err
.buf
);
2651 ret
= ref_transaction_commit(transaction
, &err
);
2653 if (refnames
->nr
== 1)
2654 error(_("could not delete reference %s: %s"),
2655 refnames
->items
[0].string
, err
.buf
);
2657 error(_("could not delete references: %s"), err
.buf
);
2661 if (!ret
&& failures
)
2663 ref_transaction_free(transaction
);
2664 strbuf_release(&err
);
2669 int delete_refs(const char *msg
, struct string_list
*refnames
,
2672 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2675 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2676 const char *newref
, const char *logmsg
)
2681 msg
= normalize_reflog_message(logmsg
);
2682 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2687 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2689 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2692 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2693 const char *newref
, const char *logmsg
)
2698 msg
= normalize_reflog_message(logmsg
);
2699 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2704 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2706 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);