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
;
1043 cb
->date
= timestamp
;
1045 if (timestamp
<= cb
->at_time
|| cb
->cnt
== 0) {
1046 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1048 * we have not yet updated cb->[n|o]oid so they still
1049 * hold the values for the previous record.
1051 if (!is_null_oid(&cb
->ooid
)) {
1052 oidcpy(cb
->oid
, noid
);
1053 if (!oideq(&cb
->ooid
, noid
))
1054 warning(_("log for ref %s has gap after %s"),
1055 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1057 else if (cb
->date
== cb
->at_time
)
1058 oidcpy(cb
->oid
, noid
);
1059 else if (!oideq(noid
, cb
->oid
))
1060 warning(_("log for ref %s unexpectedly ended on %s"),
1061 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1062 DATE_MODE(RFC2822
)));
1064 oidcpy(&cb
->ooid
, ooid
);
1065 oidcpy(&cb
->noid
, noid
);
1070 oidcpy(&cb
->ooid
, ooid
);
1071 oidcpy(&cb
->noid
, noid
);
1077 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1078 const char *email UNUSED
,
1079 timestamp_t timestamp
, int tz
,
1080 const char *message
, void *cb_data
)
1082 struct read_ref_at_cb
*cb
= cb_data
;
1084 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1085 oidcpy(cb
->oid
, ooid
);
1086 if (cb
->at_time
&& is_null_oid(cb
->oid
))
1087 oidcpy(cb
->oid
, noid
);
1088 /* We just want the first entry */
1092 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1093 unsigned int flags
, timestamp_t at_time
, int cnt
,
1094 struct object_id
*oid
, char **msg
,
1095 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1097 struct read_ref_at_cb cb
;
1099 memset(&cb
, 0, sizeof(cb
));
1100 cb
.refname
= refname
;
1101 cb
.at_time
= at_time
;
1104 cb
.cutoff_time
= cutoff_time
;
1105 cb
.cutoff_tz
= cutoff_tz
;
1106 cb
.cutoff_cnt
= cutoff_cnt
;
1109 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1112 if (flags
& GET_OID_QUIETLY
)
1115 die(_("log for %s is empty"), refname
);
1120 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1125 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1128 struct ref_transaction
*tr
;
1131 CALLOC_ARRAY(tr
, 1);
1132 tr
->ref_store
= refs
;
1136 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1138 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1141 void ref_transaction_free(struct ref_transaction
*transaction
)
1148 switch (transaction
->state
) {
1149 case REF_TRANSACTION_OPEN
:
1150 case REF_TRANSACTION_CLOSED
:
1153 case REF_TRANSACTION_PREPARED
:
1154 BUG("free called on a prepared reference transaction");
1157 BUG("unexpected reference transaction state");
1161 for (i
= 0; i
< transaction
->nr
; i
++) {
1162 free(transaction
->updates
[i
]->msg
);
1163 free(transaction
->updates
[i
]);
1165 free(transaction
->updates
);
1169 struct ref_update
*ref_transaction_add_update(
1170 struct ref_transaction
*transaction
,
1171 const char *refname
, unsigned int flags
,
1172 const struct object_id
*new_oid
,
1173 const struct object_id
*old_oid
,
1176 struct ref_update
*update
;
1178 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1179 BUG("update called for transaction that is not open");
1181 FLEX_ALLOC_STR(update
, refname
, refname
);
1182 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1183 transaction
->updates
[transaction
->nr
++] = update
;
1185 update
->flags
= flags
;
1187 if (flags
& REF_HAVE_NEW
)
1188 oidcpy(&update
->new_oid
, new_oid
);
1189 if (flags
& REF_HAVE_OLD
)
1190 oidcpy(&update
->old_oid
, old_oid
);
1191 update
->msg
= normalize_reflog_message(msg
);
1195 int ref_transaction_update(struct ref_transaction
*transaction
,
1196 const char *refname
,
1197 const struct object_id
*new_oid
,
1198 const struct object_id
*old_oid
,
1199 unsigned int flags
, const char *msg
,
1204 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1205 ((new_oid
&& !is_null_oid(new_oid
)) ?
1206 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1207 !refname_is_safe(refname
))) {
1208 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1213 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1214 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1217 * Clear flags outside the allowed set; this should be a noop because
1218 * of the BUG() check above, but it works around a -Wnonnull warning
1219 * with some versions of "gcc -O3".
1221 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1223 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1225 ref_transaction_add_update(transaction
, refname
, flags
,
1226 new_oid
, old_oid
, msg
);
1230 int ref_transaction_create(struct ref_transaction
*transaction
,
1231 const char *refname
,
1232 const struct object_id
*new_oid
,
1233 unsigned int flags
, const char *msg
,
1236 if (!new_oid
|| is_null_oid(new_oid
)) {
1237 strbuf_addf(err
, "'%s' has a null OID", refname
);
1240 return ref_transaction_update(transaction
, refname
, new_oid
,
1241 null_oid(), flags
, msg
, err
);
1244 int ref_transaction_delete(struct ref_transaction
*transaction
,
1245 const char *refname
,
1246 const struct object_id
*old_oid
,
1247 unsigned int flags
, const char *msg
,
1250 if (old_oid
&& is_null_oid(old_oid
))
1251 BUG("delete called with old_oid set to zeros");
1252 return ref_transaction_update(transaction
, refname
,
1253 null_oid(), old_oid
,
1257 int ref_transaction_verify(struct ref_transaction
*transaction
,
1258 const char *refname
,
1259 const struct object_id
*old_oid
,
1264 BUG("verify called with old_oid set to NULL");
1265 return ref_transaction_update(transaction
, refname
,
1270 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1271 const char *refname
, const struct object_id
*new_oid
,
1272 const struct object_id
*old_oid
, unsigned int flags
,
1273 enum action_on_err onerr
)
1275 struct ref_transaction
*t
= NULL
;
1276 struct strbuf err
= STRBUF_INIT
;
1279 t
= ref_store_transaction_begin(refs
, &err
);
1281 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1283 ref_transaction_commit(t
, &err
)) {
1285 ref_transaction_free(t
);
1288 const char *str
= _("update_ref failed for ref '%s': %s");
1291 case UPDATE_REFS_MSG_ON_ERR
:
1292 error(str
, refname
, err
.buf
);
1294 case UPDATE_REFS_DIE_ON_ERR
:
1295 die(str
, refname
, err
.buf
);
1297 case UPDATE_REFS_QUIET_ON_ERR
:
1300 strbuf_release(&err
);
1303 strbuf_release(&err
);
1305 ref_transaction_free(t
);
1309 int update_ref(const char *msg
, const char *refname
,
1310 const struct object_id
*new_oid
,
1311 const struct object_id
*old_oid
,
1312 unsigned int flags
, enum action_on_err onerr
)
1314 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1315 old_oid
, flags
, onerr
);
1319 * Check that the string refname matches a rule of the form
1320 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1321 * "foo/%.*s/baz", and return the string "bar".
1323 static const char *match_parse_rule(const char *refname
, const char *rule
,
1327 * Check that rule matches refname up to the first percent in the rule.
1328 * We can bail immediately if not, but otherwise we leave "rule" at the
1329 * %-placeholder, and "refname" at the start of the potential matched
1332 while (*rule
!= '%') {
1334 BUG("rev-parse rule did not have percent");
1335 if (*refname
++ != *rule
++)
1340 * Check that our "%" is the expected placeholder. This assumes there
1341 * are no other percents (placeholder or quoted) in the string, but
1342 * that is sufficient for our rev-parse rules.
1344 if (!skip_prefix(rule
, "%.*s", &rule
))
1348 * And now check that our suffix (if any) matches.
1350 if (!strip_suffix(refname
, rule
, len
))
1353 return refname
; /* len set by strip_suffix() */
1356 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1357 const char *refname
, int strict
)
1360 struct strbuf resolved_buf
= STRBUF_INIT
;
1362 /* skip first rule, it will always match */
1363 for (i
= NUM_REV_PARSE_RULES
- 1; i
> 0 ; --i
) {
1365 int rules_to_fail
= i
;
1366 const char *short_name
;
1367 size_t short_name_len
;
1369 short_name
= match_parse_rule(refname
, ref_rev_parse_rules
[i
],
1375 * in strict mode, all (except the matched one) rules
1376 * must fail to resolve to a valid non-ambiguous ref
1379 rules_to_fail
= NUM_REV_PARSE_RULES
;
1382 * check if the short name resolves to a valid ref,
1383 * but use only rules prior to the matched one
1385 for (j
= 0; j
< rules_to_fail
; j
++) {
1386 const char *rule
= ref_rev_parse_rules
[j
];
1388 /* skip matched rule */
1393 * the short name is ambiguous, if it resolves
1394 * (with this previous rule) to a valid ref
1395 * read_ref() returns 0 on success
1397 strbuf_reset(&resolved_buf
);
1398 strbuf_addf(&resolved_buf
, rule
,
1399 cast_size_t_to_int(short_name_len
),
1401 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1406 * short name is non-ambiguous if all previous rules
1407 * haven't resolved to a valid ref
1409 if (j
== rules_to_fail
) {
1410 strbuf_release(&resolved_buf
);
1411 return xmemdupz(short_name
, short_name_len
);
1415 strbuf_release(&resolved_buf
);
1416 return xstrdup(refname
);
1419 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1421 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1425 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
,
1426 struct strvec
*hide_refs
)
1429 if (!strcmp("transfer.hiderefs", var
) ||
1430 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1431 !strcmp(key
, "hiderefs"))) {
1436 return config_error_nonbool(var
);
1438 /* drop const to remove trailing '/' characters */
1439 ref
= (char *)strvec_push(hide_refs
, value
);
1441 while (len
&& ref
[len
- 1] == '/')
1447 int ref_is_hidden(const char *refname
, const char *refname_full
,
1448 const struct strvec
*hide_refs
)
1452 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1453 const char *match
= hide_refs
->v
[i
];
1454 const char *subject
;
1458 if (*match
== '!') {
1463 if (*match
== '^') {
1464 subject
= refname_full
;
1470 /* refname can be NULL when namespaces are used. */
1472 skip_prefix(subject
, match
, &p
) &&
1479 const char **hidden_refs_to_excludes(const struct strvec
*hide_refs
)
1481 const char **pattern
;
1482 for (pattern
= hide_refs
->v
; *pattern
; pattern
++) {
1484 * We can't feed any excludes from hidden refs config
1485 * sections, since later rules may override previous
1486 * ones. For example, with rules "refs/foo" and
1487 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1488 * everything underneath it), but the earlier exclusion
1489 * would cause us to skip all of "refs/foo". We
1490 * likewise don't implement the namespace stripping
1491 * required for '^' rules.
1493 * Both are possible to do, but complicated, so avoid
1494 * populating the jump list at all if we see either of
1497 if (**pattern
== '!' || **pattern
== '^')
1500 return hide_refs
->v
;
1503 const char *find_descendant_ref(const char *dirname
,
1504 const struct string_list
*extras
,
1505 const struct string_list
*skip
)
1513 * Look at the place where dirname would be inserted into
1514 * extras. If there is an entry at that position that starts
1515 * with dirname (remember, dirname includes the trailing
1516 * slash) and is not in skip, then we have a conflict.
1518 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1519 pos
< extras
->nr
; pos
++) {
1520 const char *extra_refname
= extras
->items
[pos
].string
;
1522 if (!starts_with(extra_refname
, dirname
))
1525 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1526 return extra_refname
;
1531 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1533 struct object_id oid
;
1536 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1538 return fn("HEAD", &oid
, flag
, cb_data
);
1543 int head_ref(each_ref_fn fn
, void *cb_data
)
1545 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1548 struct ref_iterator
*refs_ref_iterator_begin(
1549 struct ref_store
*refs
,
1551 const char **exclude_patterns
,
1553 enum do_for_each_ref_flags flags
)
1555 struct ref_iterator
*iter
;
1557 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1558 static int ref_paranoia
= -1;
1560 if (ref_paranoia
< 0)
1561 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1563 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1564 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1568 iter
= refs
->be
->iterator_begin(refs
, prefix
, exclude_patterns
, flags
);
1570 * `iterator_begin()` already takes care of prefix, but we
1571 * might need to do some trimming:
1574 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1576 /* Sanity check for subclasses: */
1578 BUG("reference iterator is not ordered");
1584 * Call fn for each reference in the specified submodule for which the
1585 * refname begins with prefix. If trim is non-zero, then trim that
1586 * many characters off the beginning of each refname before passing
1587 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1588 * include broken references in the iteration. If fn ever returns a
1589 * non-zero value, stop the iteration and return that value;
1590 * otherwise, return 0.
1592 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1593 each_repo_ref_fn fn
, int trim
, int flags
,
1596 struct ref_iterator
*iter
;
1597 struct ref_store
*refs
= get_main_ref_store(r
);
1602 iter
= refs_ref_iterator_begin(refs
, prefix
, NULL
, trim
, flags
);
1604 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1607 struct do_for_each_ref_help
{
1612 static int do_for_each_ref_helper(struct repository
*r UNUSED
,
1613 const char *refname
,
1614 const struct object_id
*oid
,
1618 struct do_for_each_ref_help
*hp
= cb_data
;
1620 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1623 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1624 const char **exclude_patterns
,
1625 each_ref_fn fn
, int trim
,
1626 enum do_for_each_ref_flags flags
, void *cb_data
)
1628 struct ref_iterator
*iter
;
1629 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1634 iter
= refs_ref_iterator_begin(refs
, prefix
, exclude_patterns
, trim
,
1637 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1638 do_for_each_ref_helper
, &hp
);
1641 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1643 return do_for_each_ref(refs
, "", NULL
, fn
, 0, 0, cb_data
);
1646 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1648 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1651 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1652 each_ref_fn fn
, void *cb_data
)
1654 return do_for_each_ref(refs
, prefix
, NULL
, fn
, strlen(prefix
), 0, cb_data
);
1657 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1659 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1662 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1664 return do_for_each_ref(get_main_ref_store(the_repository
),
1665 prefix
, NULL
, fn
, 0, 0, cb_data
);
1668 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1669 const char **exclude_patterns
,
1670 each_ref_fn fn
, void *cb_data
)
1672 return do_for_each_ref(refs
, prefix
, exclude_patterns
, fn
, 0, 0, cb_data
);
1675 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1677 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1678 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1679 strlen(git_replace_ref_base
),
1680 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1683 int for_each_namespaced_ref(const char **exclude_patterns
,
1684 each_ref_fn fn
, void *cb_data
)
1686 struct strbuf buf
= STRBUF_INIT
;
1688 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1689 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1690 buf
.buf
, exclude_patterns
, fn
, 0, 0, cb_data
);
1691 strbuf_release(&buf
);
1695 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1697 return do_for_each_ref(refs
, "", NULL
, fn
, 0,
1698 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1701 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1703 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1706 static int qsort_strcmp(const void *va
, const void *vb
)
1708 const char *a
= *(const char **)va
;
1709 const char *b
= *(const char **)vb
;
1711 return strcmp(a
, b
);
1714 static void find_longest_prefixes_1(struct string_list
*out
,
1715 struct strbuf
*prefix
,
1716 const char **patterns
, size_t nr
)
1720 for (i
= 0; i
< nr
; i
++) {
1721 char c
= patterns
[i
][prefix
->len
];
1722 if (!c
|| is_glob_special(c
)) {
1723 string_list_append(out
, prefix
->buf
);
1733 * Set "end" to the index of the element _after_ the last one
1736 for (end
= i
+ 1; end
< nr
; end
++) {
1737 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1741 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1742 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1743 strbuf_setlen(prefix
, prefix
->len
- 1);
1749 static void find_longest_prefixes(struct string_list
*out
,
1750 const char **patterns
)
1752 struct strvec sorted
= STRVEC_INIT
;
1753 struct strbuf prefix
= STRBUF_INIT
;
1755 strvec_pushv(&sorted
, patterns
);
1756 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1758 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1760 strvec_clear(&sorted
);
1761 strbuf_release(&prefix
);
1764 int refs_for_each_fullref_in_prefixes(struct ref_store
*ref_store
,
1765 const char *namespace,
1766 const char **patterns
,
1767 const char **exclude_patterns
,
1768 each_ref_fn fn
, void *cb_data
)
1770 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1771 struct string_list_item
*prefix
;
1772 struct strbuf buf
= STRBUF_INIT
;
1773 int ret
= 0, namespace_len
;
1775 find_longest_prefixes(&prefixes
, patterns
);
1778 strbuf_addstr(&buf
, namespace);
1779 namespace_len
= buf
.len
;
1781 for_each_string_list_item(prefix
, &prefixes
) {
1782 strbuf_addstr(&buf
, prefix
->string
);
1783 ret
= refs_for_each_fullref_in(ref_store
, buf
.buf
,
1784 exclude_patterns
, fn
, cb_data
);
1787 strbuf_setlen(&buf
, namespace_len
);
1790 string_list_clear(&prefixes
, 0);
1791 strbuf_release(&buf
);
1795 static int refs_read_special_head(struct ref_store
*ref_store
,
1796 const char *refname
, struct object_id
*oid
,
1797 struct strbuf
*referent
, unsigned int *type
,
1800 struct strbuf full_path
= STRBUF_INIT
;
1801 struct strbuf content
= STRBUF_INIT
;
1803 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1805 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0) {
1806 *failure_errno
= errno
;
1810 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1814 strbuf_release(&full_path
);
1815 strbuf_release(&content
);
1819 static int is_special_ref(const char *refname
)
1822 * Special references are refs that have different semantics compared
1823 * to "normal" refs. These refs can thus not be stored in the ref
1824 * backend, but must always be accessed via the filesystem. The
1825 * following refs are special:
1827 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1828 * carries additional metadata like where it came from.
1830 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1833 * Reading, writing or deleting references must consistently go either
1834 * through the filesystem (special refs) or through the reference
1835 * backend (normal ones).
1837 static const char * const special_refs
[] = {
1843 for (i
= 0; i
< ARRAY_SIZE(special_refs
); i
++)
1844 if (!strcmp(refname
, special_refs
[i
]))
1850 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1851 struct object_id
*oid
, struct strbuf
*referent
,
1852 unsigned int *type
, int *failure_errno
)
1854 assert(failure_errno
);
1855 if (is_special_ref(refname
))
1856 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1857 type
, failure_errno
);
1859 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1860 type
, failure_errno
);
1863 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1864 struct strbuf
*referent
)
1866 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1869 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1870 const char *refname
,
1872 struct object_id
*oid
,
1875 static struct strbuf sb_refname
= STRBUF_INIT
;
1876 struct object_id unused_oid
;
1883 flags
= &unused_flags
;
1887 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1888 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1889 !refname_is_safe(refname
))
1893 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1894 * missing refs and refs that were present but invalid,
1895 * to complain about the latter to stderr.
1897 * We don't know whether the ref exists, so don't set
1900 *flags
|= REF_BAD_NAME
;
1903 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1904 unsigned int read_flags
= 0;
1907 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1908 &read_flags
, &failure_errno
)) {
1909 *flags
|= read_flags
;
1911 /* In reading mode, refs must eventually resolve */
1912 if (resolve_flags
& RESOLVE_REF_READING
)
1916 * Otherwise a missing ref is OK. But the files backend
1917 * may show errors besides ENOENT if there are
1918 * similarly-named refs.
1920 if (failure_errno
!= ENOENT
&&
1921 failure_errno
!= EISDIR
&&
1922 failure_errno
!= ENOTDIR
)
1926 if (*flags
& REF_BAD_NAME
)
1927 *flags
|= REF_ISBROKEN
;
1931 *flags
|= read_flags
;
1933 if (!(read_flags
& REF_ISSYMREF
)) {
1934 if (*flags
& REF_BAD_NAME
) {
1936 *flags
|= REF_ISBROKEN
;
1941 refname
= sb_refname
.buf
;
1942 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1946 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1947 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1948 !refname_is_safe(refname
))
1951 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1958 /* backend functions */
1959 int refs_init_db(struct ref_store
*refs
, int flags
, struct strbuf
*err
)
1961 return refs
->be
->init_db(refs
, flags
, err
);
1964 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1965 struct object_id
*oid
, int *flags
)
1967 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1968 resolve_flags
, oid
, flags
);
1971 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1972 struct object_id
*oid
)
1974 struct ref_store
*refs
;
1977 refs
= get_submodule_ref_store(submodule
);
1982 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1988 struct ref_store_hash_entry
1990 struct hashmap_entry ent
;
1992 struct ref_store
*refs
;
1994 /* NUL-terminated identifier of the ref store: */
1995 char name
[FLEX_ARRAY
];
1998 static int ref_store_hash_cmp(const void *cmp_data UNUSED
,
1999 const struct hashmap_entry
*eptr
,
2000 const struct hashmap_entry
*entry_or_key
,
2001 const void *keydata
)
2003 const struct ref_store_hash_entry
*e1
, *e2
;
2006 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
2007 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
2008 name
= keydata
? keydata
: e2
->name
;
2010 return strcmp(e1
->name
, name
);
2013 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
2014 const char *name
, struct ref_store
*refs
)
2016 struct ref_store_hash_entry
*entry
;
2018 FLEX_ALLOC_STR(entry
, name
, name
);
2019 hashmap_entry_init(&entry
->ent
, strhash(name
));
2024 /* A hashmap of ref_stores, stored by submodule name: */
2025 static struct hashmap submodule_ref_stores
;
2027 /* A hashmap of ref_stores, stored by worktree id: */
2028 static struct hashmap worktree_ref_stores
;
2031 * Look up a ref store by name. If that ref_store hasn't been
2032 * registered yet, return NULL.
2034 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
2037 struct ref_store_hash_entry
*entry
;
2040 if (!map
->tablesize
)
2041 /* It's initialized on demand in register_ref_store(). */
2044 hash
= strhash(name
);
2045 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
2046 struct ref_store_hash_entry
, ent
);
2047 return entry
? entry
->refs
: NULL
;
2051 * Create, record, and return a ref_store instance for the specified
2054 static struct ref_store
*ref_store_init(struct repository
*repo
,
2058 const struct ref_storage_be
*be
;
2059 struct ref_store
*refs
;
2061 be
= find_ref_storage_backend(repo
->ref_storage_format
);
2063 BUG("reference backend is unknown");
2065 refs
= be
->init(repo
, gitdir
, flags
);
2069 struct ref_store
*get_main_ref_store(struct repository
*r
)
2071 if (r
->refs_private
)
2072 return r
->refs_private
;
2075 BUG("attempting to get main_ref_store outside of repository");
2077 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
2078 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
2079 return r
->refs_private
;
2083 * Associate a ref store with a name. It is a fatal error to call this
2084 * function twice for the same name.
2086 static void register_ref_store_map(struct hashmap
*map
,
2088 struct ref_store
*refs
,
2091 struct ref_store_hash_entry
*entry
;
2093 if (!map
->tablesize
)
2094 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2096 entry
= alloc_ref_store_hash_entry(name
, refs
);
2097 if (hashmap_put(map
, &entry
->ent
))
2098 BUG("%s ref_store '%s' initialized twice", type
, name
);
2101 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2103 struct strbuf submodule_sb
= STRBUF_INIT
;
2104 struct ref_store
*refs
;
2105 char *to_free
= NULL
;
2107 struct repository
*subrepo
;
2112 len
= strlen(submodule
);
2113 while (len
&& is_dir_sep(submodule
[len
- 1]))
2119 /* We need to strip off one or more trailing slashes */
2120 submodule
= to_free
= xmemdupz(submodule
, len
);
2122 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2126 strbuf_addstr(&submodule_sb
, submodule
);
2127 if (!is_nonbare_repository_dir(&submodule_sb
))
2130 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2133 subrepo
= xmalloc(sizeof(*subrepo
));
2135 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2136 * superprojects other than the_repository. This probably should be
2137 * done by making it take a struct repository * parameter instead of a
2140 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2145 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2146 REF_STORE_READ
| REF_STORE_ODB
);
2147 register_ref_store_map(&submodule_ref_stores
, "submodule",
2151 strbuf_release(&submodule_sb
);
2157 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2159 struct ref_store
*refs
;
2163 return get_main_ref_store(the_repository
);
2165 id
= wt
->id
? wt
->id
: "/";
2166 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2171 refs
= ref_store_init(the_repository
,
2172 git_common_path("worktrees/%s", wt
->id
),
2173 REF_STORE_ALL_CAPS
);
2175 refs
= ref_store_init(the_repository
,
2176 get_git_common_dir(),
2177 REF_STORE_ALL_CAPS
);
2180 register_ref_store_map(&worktree_ref_stores
, "worktree",
2185 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2186 const char *path
, const struct ref_storage_be
*be
)
2190 refs
->gitdir
= xstrdup(path
);
2193 /* backend functions */
2194 int refs_pack_refs(struct ref_store
*refs
, struct pack_refs_opts
*opts
)
2196 return refs
->be
->pack_refs(refs
, opts
);
2199 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2201 if (current_ref_iter
&&
2202 (current_ref_iter
->oid
== base
||
2203 oideq(current_ref_iter
->oid
, base
)))
2204 return ref_iterator_peel(current_ref_iter
, peeled
);
2206 return peel_object(base
, peeled
) ? -1 : 0;
2209 int refs_create_symref(struct ref_store
*refs
,
2210 const char *ref_target
,
2211 const char *refs_heads_master
,
2217 msg
= normalize_reflog_message(logmsg
);
2218 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2224 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2227 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2228 refs_heads_master
, logmsg
);
2231 int ref_update_reject_duplicates(struct string_list
*refnames
,
2234 size_t i
, n
= refnames
->nr
;
2238 for (i
= 1; i
< n
; i
++) {
2239 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2240 refnames
->items
[i
].string
);
2244 _("multiple updates for ref '%s' not allowed"),
2245 refnames
->items
[i
].string
);
2247 } else if (cmp
> 0) {
2248 BUG("ref_update_reject_duplicates() received unsorted list");
2254 static int run_transaction_hook(struct ref_transaction
*transaction
,
2257 struct child_process proc
= CHILD_PROCESS_INIT
;
2258 struct strbuf buf
= STRBUF_INIT
;
2262 hook
= find_hook("reference-transaction");
2266 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2268 proc
.stdout_to_stderr
= 1;
2269 proc
.trace2_hook_name
= "reference-transaction";
2271 ret
= start_command(&proc
);
2275 sigchain_push(SIGPIPE
, SIG_IGN
);
2277 for (i
= 0; i
< transaction
->nr
; i
++) {
2278 struct ref_update
*update
= transaction
->updates
[i
];
2281 strbuf_addf(&buf
, "%s %s %s\n",
2282 oid_to_hex(&update
->old_oid
),
2283 oid_to_hex(&update
->new_oid
),
2286 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2287 if (errno
!= EPIPE
) {
2288 /* Don't leak errno outside this API */
2297 sigchain_pop(SIGPIPE
);
2298 strbuf_release(&buf
);
2300 ret
|= finish_command(&proc
);
2304 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2307 struct ref_store
*refs
= transaction
->ref_store
;
2310 switch (transaction
->state
) {
2311 case REF_TRANSACTION_OPEN
:
2314 case REF_TRANSACTION_PREPARED
:
2315 BUG("prepare called twice on reference transaction");
2317 case REF_TRANSACTION_CLOSED
:
2318 BUG("prepare called on a closed reference transaction");
2321 BUG("unexpected reference transaction state");
2325 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2327 _("ref updates forbidden inside quarantine environment"));
2331 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2335 ret
= run_transaction_hook(transaction
, "prepared");
2337 ref_transaction_abort(transaction
, err
);
2338 die(_("ref updates aborted by hook"));
2344 int ref_transaction_abort(struct ref_transaction
*transaction
,
2347 struct ref_store
*refs
= transaction
->ref_store
;
2350 switch (transaction
->state
) {
2351 case REF_TRANSACTION_OPEN
:
2352 /* No need to abort explicitly. */
2354 case REF_TRANSACTION_PREPARED
:
2355 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2357 case REF_TRANSACTION_CLOSED
:
2358 BUG("abort called on a closed reference transaction");
2361 BUG("unexpected reference transaction state");
2365 run_transaction_hook(transaction
, "aborted");
2367 ref_transaction_free(transaction
);
2371 int ref_transaction_commit(struct ref_transaction
*transaction
,
2374 struct ref_store
*refs
= transaction
->ref_store
;
2377 switch (transaction
->state
) {
2378 case REF_TRANSACTION_OPEN
:
2379 /* Need to prepare first. */
2380 ret
= ref_transaction_prepare(transaction
, err
);
2384 case REF_TRANSACTION_PREPARED
:
2385 /* Fall through to finish. */
2387 case REF_TRANSACTION_CLOSED
:
2388 BUG("commit called on a closed reference transaction");
2391 BUG("unexpected reference transaction state");
2395 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2397 run_transaction_hook(transaction
, "committed");
2401 int refs_verify_refname_available(struct ref_store
*refs
,
2402 const char *refname
,
2403 const struct string_list
*extras
,
2404 const struct string_list
*skip
,
2408 const char *extra_refname
;
2409 struct strbuf dirname
= STRBUF_INIT
;
2410 struct strbuf referent
= STRBUF_INIT
;
2411 struct object_id oid
;
2413 struct ref_iterator
*iter
;
2418 * For the sake of comments in this function, suppose that
2419 * refname is "refs/foo/bar".
2424 strbuf_grow(&dirname
, strlen(refname
) + 1);
2425 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2427 * Just saying "Is a directory" when we e.g. can't
2428 * lock some multi-level ref isn't very informative,
2429 * the user won't be told *what* is a directory, so
2430 * let's not use strerror() below.
2433 /* Expand dirname to the new prefix, not including the trailing slash: */
2434 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2437 * We are still at a leading dir of the refname (e.g.,
2438 * "refs/foo"; if there is a reference with that name,
2439 * it is a conflict, *unless* it is in skip.
2441 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2444 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2445 &type
, &ignore_errno
)) {
2446 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2447 dirname
.buf
, refname
);
2451 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2452 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2453 refname
, dirname
.buf
);
2459 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2460 * There is no point in searching for a reference with that
2461 * name, because a refname isn't considered to conflict with
2462 * itself. But we still need to check for references whose
2463 * names are in the "refs/foo/bar/" namespace, because they
2466 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2467 strbuf_addch(&dirname
, '/');
2469 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, NULL
, 0,
2470 DO_FOR_EACH_INCLUDE_BROKEN
);
2471 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2473 string_list_has_string(skip
, iter
->refname
))
2476 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2477 iter
->refname
, refname
);
2478 ref_iterator_abort(iter
);
2482 if (ok
!= ITER_DONE
)
2483 BUG("error while iterating over references");
2485 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2487 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2488 refname
, extra_refname
);
2493 strbuf_release(&referent
);
2494 strbuf_release(&dirname
);
2498 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2500 struct ref_iterator
*iter
;
2501 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2503 iter
= refs
->be
->reflog_iterator_begin(refs
);
2505 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2506 do_for_each_ref_helper
, &hp
);
2509 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2511 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2514 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2515 const char *refname
,
2516 each_reflog_ent_fn fn
,
2519 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2523 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2526 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2527 refname
, fn
, cb_data
);
2530 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2531 each_reflog_ent_fn fn
, void *cb_data
)
2533 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2536 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2539 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2543 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2545 return refs
->be
->reflog_exists(refs
, refname
);
2548 int reflog_exists(const char *refname
)
2550 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2553 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2556 return refs
->be
->create_reflog(refs
, refname
, err
);
2559 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2561 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2565 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2567 return refs
->be
->delete_reflog(refs
, refname
);
2570 int delete_reflog(const char *refname
)
2572 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2575 int refs_reflog_expire(struct ref_store
*refs
,
2576 const char *refname
,
2578 reflog_expiry_prepare_fn prepare_fn
,
2579 reflog_expiry_should_prune_fn should_prune_fn
,
2580 reflog_expiry_cleanup_fn cleanup_fn
,
2581 void *policy_cb_data
)
2583 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2584 prepare_fn
, should_prune_fn
,
2585 cleanup_fn
, policy_cb_data
);
2588 int reflog_expire(const char *refname
,
2590 reflog_expiry_prepare_fn prepare_fn
,
2591 reflog_expiry_should_prune_fn should_prune_fn
,
2592 reflog_expiry_cleanup_fn cleanup_fn
,
2593 void *policy_cb_data
)
2595 return refs_reflog_expire(get_main_ref_store(the_repository
),
2597 prepare_fn
, should_prune_fn
,
2598 cleanup_fn
, policy_cb_data
);
2601 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2604 struct ref_store
*refs
= transaction
->ref_store
;
2606 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2609 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2610 ref_transaction_for_each_queued_update_fn cb
,
2615 for (i
= 0; i
< transaction
->nr
; i
++) {
2616 struct ref_update
*update
= transaction
->updates
[i
];
2619 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2620 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2625 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2626 struct string_list
*refnames
, unsigned int flags
)
2628 struct ref_transaction
*transaction
;
2629 struct strbuf err
= STRBUF_INIT
;
2630 struct string_list_item
*item
;
2631 int ret
= 0, failures
= 0;
2637 msg
= normalize_reflog_message(logmsg
);
2640 * Since we don't check the references' old_oids, the
2641 * individual updates can't fail, so we can pack all of the
2642 * updates into a single transaction.
2644 transaction
= ref_store_transaction_begin(refs
, &err
);
2646 ret
= error("%s", err
.buf
);
2650 for_each_string_list_item(item
, refnames
) {
2651 ret
= ref_transaction_delete(transaction
, item
->string
,
2652 NULL
, flags
, msg
, &err
);
2654 warning(_("could not delete reference %s: %s"),
2655 item
->string
, err
.buf
);
2661 ret
= ref_transaction_commit(transaction
, &err
);
2663 if (refnames
->nr
== 1)
2664 error(_("could not delete reference %s: %s"),
2665 refnames
->items
[0].string
, err
.buf
);
2667 error(_("could not delete references: %s"), err
.buf
);
2671 if (!ret
&& failures
)
2673 ref_transaction_free(transaction
);
2674 strbuf_release(&err
);
2679 int delete_refs(const char *msg
, struct string_list
*refnames
,
2682 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2685 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2686 const char *newref
, const char *logmsg
)
2691 msg
= normalize_reflog_message(logmsg
);
2692 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2697 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2699 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2702 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2703 const char *newref
, const char *logmsg
)
2708 msg
= normalize_reflog_message(logmsg
);
2709 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2714 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2716 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);