2 * The backend-independent part of the reference module.
11 #include "refs/refs-internal.h"
12 #include "run-command.h"
14 #include "object-store.h"
17 #include "submodule.h"
20 #include "repository.h"
26 * List of all available backends
28 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
30 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
32 struct ref_storage_be
*be
;
33 for (be
= refs_backends
; be
; be
= be
->next
)
34 if (!strcmp(be
->name
, name
))
40 * How to handle various characters in refnames:
41 * 0: An acceptable character for refs
43 * 2: ., look for a preceding . to reject .. in refs
44 * 3: {, look for a preceding @ to reject @{ in refs
45 * 4: A bad character: ASCII control characters, and
46 * ":", "?", "[", "\", "^", "~", SP, or TAB
47 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
49 static unsigned char refname_disposition
[256] = {
50 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
51 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
52 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
56 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
57 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
60 struct ref_namespace_info ref_namespace
[] = {
63 .decoration
= DECORATION_REF_HEAD
,
66 [NAMESPACE_BRANCHES
] = {
68 .decoration
= DECORATION_REF_LOCAL
,
72 .decoration
= DECORATION_REF_TAG
,
74 [NAMESPACE_REMOTE_REFS
] = {
76 * The default refspec for new remotes copies refs from
77 * refs/heads/ on the remote into refs/remotes/<remote>/.
78 * As such, "refs/remotes/" has special handling.
80 .ref
= "refs/remotes/",
81 .decoration
= DECORATION_REF_REMOTE
,
85 * The single ref "refs/stash" stores the latest stash.
86 * Older stashes can be found in the reflog.
90 .decoration
= DECORATION_REF_STASH
,
92 [NAMESPACE_REPLACE
] = {
94 * This namespace allows Git to act as if one object ID
95 * points to the content of another. Unlike the other
96 * ref namespaces, this one can be changed by the
97 * GIT_REPLACE_REF_BASE environment variable. This
98 * .namespace value will be overwritten in setup_git_env().
100 .ref
= "refs/replace/",
101 .decoration
= DECORATION_GRAFTED
,
103 [NAMESPACE_NOTES
] = {
105 * The refs/notes/commit ref points to the tip of a
106 * parallel commit history that adds metadata to commits
107 * in the normal history. This ref can be overwritten
108 * by the core.notesRef config variable or the
109 * GIT_NOTES_REFS environment variable.
111 .ref
= "refs/notes/commit",
114 [NAMESPACE_PREFETCH
] = {
116 * Prefetch refs are written by the background 'fetch'
117 * maintenance task. It allows faster foreground fetches
118 * by advertising these previously-downloaded tips without
119 * updating refs/remotes/ without user intervention.
121 .ref
= "refs/prefetch/",
123 [NAMESPACE_REWRITTEN
] = {
125 * Rewritten refs are used by the 'label' command in the
126 * sequencer. These are particularly useful during an
127 * interactive rebase that uses the 'merge' command.
129 .ref
= "refs/rewritten/",
133 void update_ref_namespace(enum ref_namespace
namespace, char *ref
)
135 struct ref_namespace_info
*info
= &ref_namespace
[namespace];
136 if (info
->ref_updated
)
139 info
->ref_updated
= 1;
143 * Try to read one refname component from the front of refname.
144 * Return the length of the component found, or -1 if the component is
145 * not legal. It is legal if it is something reasonable to have under
146 * ".git/refs/"; We do not like it if:
148 * - it begins with ".", or
149 * - it has double dots "..", or
150 * - it has ASCII control characters, or
151 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
152 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
153 * - it ends with a "/", or
154 * - it ends with ".lock", or
155 * - it contains a "@{" portion
157 * When sanitized is not NULL, instead of rejecting the input refname
158 * as an error, try to come up with a usable replacement for the input
161 static int check_refname_component(const char *refname
, int *flags
,
162 struct strbuf
*sanitized
)
166 size_t component_start
= 0; /* garbage - not a reasonable initial value */
169 component_start
= sanitized
->len
;
171 for (cp
= refname
; ; cp
++) {
173 unsigned char disp
= refname_disposition
[ch
];
175 if (sanitized
&& disp
!= 1)
176 strbuf_addch(sanitized
, ch
);
182 if (last
== '.') { /* Refname contains "..". */
184 /* collapse ".." to single "." */
185 strbuf_setlen(sanitized
, sanitized
->len
- 1);
191 if (last
== '@') { /* Refname contains "@{". */
193 sanitized
->buf
[sanitized
->len
-1] = '-';
201 sanitized
->buf
[sanitized
->len
-1] = '-';
206 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
207 /* refspec can't be a pattern */
209 sanitized
->buf
[sanitized
->len
-1] = '-';
215 * Unset the pattern flag so that we only accept
216 * a single asterisk for one side of refspec.
218 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
225 return 0; /* Component has zero length. */
227 if (refname
[0] == '.') { /* Component starts with '.'. */
229 sanitized
->buf
[component_start
] = '-';
233 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
234 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
237 /* Refname ends with ".lock". */
238 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
239 /* try again in case we have .lock.lock */
245 static int check_or_sanitize_refname(const char *refname
, int flags
,
246 struct strbuf
*sanitized
)
248 int component_len
, component_count
= 0;
250 if (!strcmp(refname
, "@")) {
251 /* Refname is a single character '@'. */
253 strbuf_addch(sanitized
, '-');
259 if (sanitized
&& sanitized
->len
)
260 strbuf_complete(sanitized
, '/');
262 /* We are at the start of a path component. */
263 component_len
= check_refname_component(refname
, &flags
,
265 if (sanitized
&& component_len
== 0)
266 ; /* OK, omit empty component */
267 else if (component_len
<= 0)
271 if (refname
[component_len
] == '\0')
273 /* Skip to next component. */
274 refname
+= component_len
+ 1;
277 if (refname
[component_len
- 1] == '.') {
278 /* Refname ends with '.'. */
280 ; /* omit ending dot */
284 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
285 return -1; /* Refname has only one component. */
289 int check_refname_format(const char *refname
, int flags
)
291 return check_or_sanitize_refname(refname
, flags
, NULL
);
294 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
296 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
297 BUG("sanitizing refname '%s' check returned error", refname
);
300 int refname_is_safe(const char *refname
)
304 if (skip_prefix(refname
, "refs/", &rest
)) {
307 size_t restlen
= strlen(rest
);
309 /* rest must not be empty, or start or end with "/" */
310 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
314 * Does the refname try to escape refs/?
315 * For example: refs/foo/../bar is safe but refs/foo/../../bar
318 buf
= xmallocz(restlen
);
319 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
325 if (!isupper(*refname
) && *refname
!= '_')
333 * Return true if refname, which has the specified oid and flags, can
334 * be resolved to an object in the database. If the referred-to object
335 * does not exist, emit a warning and return false.
337 int ref_resolves_to_object(const char *refname
,
338 struct repository
*repo
,
339 const struct object_id
*oid
,
342 if (flags
& REF_ISBROKEN
)
344 if (!repo_has_object_file(repo
, oid
)) {
345 error(_("%s does not point to a valid object!"), refname
);
351 char *refs_resolve_refdup(struct ref_store
*refs
,
352 const char *refname
, int resolve_flags
,
353 struct object_id
*oid
, int *flags
)
357 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
359 return xstrdup_or_null(result
);
362 char *resolve_refdup(const char *refname
, int resolve_flags
,
363 struct object_id
*oid
, int *flags
)
365 return refs_resolve_refdup(get_main_ref_store(the_repository
),
366 refname
, resolve_flags
,
370 /* The argument to filter_refs */
378 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
380 struct ref_store
*refs
= get_main_ref_store(the_repository
);
382 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
388 int read_ref(const char *refname
, struct object_id
*oid
)
390 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
393 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
395 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
399 int ref_exists(const char *refname
)
401 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
404 static int filter_refs(const char *refname
, const struct object_id
*oid
,
405 int flags
, void *data
)
407 struct ref_filter
*filter
= (struct ref_filter
*)data
;
409 if (wildmatch(filter
->pattern
, refname
, 0))
412 skip_prefix(refname
, filter
->prefix
, &refname
);
413 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
416 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
418 struct object
*o
= lookup_unknown_object(the_repository
, name
);
420 if (o
->type
== OBJ_NONE
) {
421 int type
= oid_object_info(the_repository
, name
, NULL
);
422 if (type
< 0 || !object_as_type(o
, type
, 0))
426 if (o
->type
!= OBJ_TAG
)
429 o
= deref_tag_noverify(o
);
433 oidcpy(oid
, &o
->oid
);
437 struct warn_if_dangling_data
{
440 const struct string_list
*refnames
;
444 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
445 int flags
, void *cb_data
)
447 struct warn_if_dangling_data
*d
= cb_data
;
448 const char *resolves_to
;
450 if (!(flags
& REF_ISSYMREF
))
453 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
456 ? strcmp(resolves_to
, d
->refname
)
457 : !string_list_has_string(d
->refnames
, resolves_to
))) {
461 fprintf(d
->fp
, d
->msg_fmt
, refname
);
466 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
468 struct warn_if_dangling_data data
;
471 data
.refname
= refname
;
472 data
.refnames
= NULL
;
473 data
.msg_fmt
= msg_fmt
;
474 for_each_rawref(warn_if_dangling_symref
, &data
);
477 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
479 struct warn_if_dangling_data data
;
483 data
.refnames
= refnames
;
484 data
.msg_fmt
= msg_fmt
;
485 for_each_rawref(warn_if_dangling_symref
, &data
);
488 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
490 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
493 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
495 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
498 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
500 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
503 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
505 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
508 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
510 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
513 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
515 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
518 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
520 struct strbuf buf
= STRBUF_INIT
;
522 struct object_id oid
;
525 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
526 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
527 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
528 strbuf_release(&buf
);
533 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
536 struct strbuf normalized_pattern
= STRBUF_INIT
;
539 BUG("pattern must not start with '/'");
542 strbuf_addstr(&normalized_pattern
, prefix
);
543 else if (!starts_with(pattern
, "refs/") &&
544 strcmp(pattern
, "HEAD"))
545 strbuf_addstr(&normalized_pattern
, "refs/");
547 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
551 strbuf_addstr(&normalized_pattern
, pattern
);
552 strbuf_strip_suffix(&normalized_pattern
, "/");
554 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
555 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
556 strbuf_release(&normalized_pattern
);
559 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
560 const char *prefix
, void *cb_data
)
562 struct strbuf real_pattern
= STRBUF_INIT
;
563 struct ref_filter filter
;
566 if (!prefix
&& !starts_with(pattern
, "refs/"))
567 strbuf_addstr(&real_pattern
, "refs/");
569 strbuf_addstr(&real_pattern
, prefix
);
570 strbuf_addstr(&real_pattern
, pattern
);
572 if (!has_glob_specials(pattern
)) {
573 /* Append implied '/' '*' if not present. */
574 strbuf_complete(&real_pattern
, '/');
575 /* No need to check for '*', there is none. */
576 strbuf_addch(&real_pattern
, '*');
579 filter
.pattern
= real_pattern
.buf
;
580 filter
.prefix
= prefix
;
582 filter
.cb_data
= cb_data
;
583 ret
= for_each_ref(filter_refs
, &filter
);
585 strbuf_release(&real_pattern
);
589 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
591 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
594 const char *prettify_refname(const char *name
)
596 if (skip_prefix(name
, "refs/heads/", &name
) ||
597 skip_prefix(name
, "refs/tags/", &name
) ||
598 skip_prefix(name
, "refs/remotes/", &name
))
603 static const char *ref_rev_parse_rules
[] = {
609 "refs/remotes/%.*s/HEAD",
613 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
616 * Is it possible that the caller meant full_name with abbrev_name?
617 * If so return a non-zero value to signal "yes"; the magnitude of
618 * the returned value gives the precedence used for disambiguation.
620 * If abbrev_name cannot mean full_name, return 0.
622 int refname_match(const char *abbrev_name
, const char *full_name
)
625 const int abbrev_name_len
= strlen(abbrev_name
);
626 const int num_rules
= NUM_REV_PARSE_RULES
;
628 for (p
= ref_rev_parse_rules
; *p
; p
++)
629 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
630 return &ref_rev_parse_rules
[num_rules
] - p
;
636 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
637 * the results to 'prefixes'
639 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
642 int len
= strlen(prefix
);
644 for (p
= ref_rev_parse_rules
; *p
; p
++)
645 strvec_pushf(prefixes
, *p
, len
, prefix
);
648 static const char default_branch_name_advice
[] = N_(
649 "Using '%s' as the name for the initial branch. This default branch name\n"
650 "is subject to change. To configure the initial branch name to use in all\n"
651 "of your new repositories, which will suppress this warning, call:\n"
653 "\tgit config --global init.defaultBranch <name>\n"
655 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
656 "'development'. The just-created branch can be renamed via this command:\n"
658 "\tgit branch -m <name>\n"
661 char *repo_default_branch_name(struct repository
*r
, int quiet
)
663 const char *config_key
= "init.defaultbranch";
664 const char *config_display_key
= "init.defaultBranch";
665 char *ret
= NULL
, *full_ref
;
666 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
670 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
671 die(_("could not retrieve `%s`"), config_display_key
);
674 ret
= xstrdup("master");
676 advise(_(default_branch_name_advice
), ret
);
679 full_ref
= xstrfmt("refs/heads/%s", ret
);
680 if (check_refname_format(full_ref
, 0))
681 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
687 const char *git_default_branch_name(int quiet
)
692 ret
= repo_default_branch_name(the_repository
, quiet
);
698 * *string and *len will only be substituted, and *string returned (for
699 * later free()ing) if the string passed in is a magic short-hand form
702 static char *substitute_branch_name(struct repository
*r
,
703 const char **string
, int *len
,
704 int nonfatal_dangling_mark
)
706 struct strbuf buf
= STRBUF_INIT
;
707 struct interpret_branch_name_options options
= {
708 .nonfatal_dangling_mark
= nonfatal_dangling_mark
710 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
714 *string
= strbuf_detach(&buf
, &size
);
716 return (char *)*string
;
722 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
723 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
725 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
726 nonfatal_dangling_mark
);
727 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
732 int expand_ref(struct repository
*repo
, const char *str
, int len
,
733 struct object_id
*oid
, char **ref
)
737 struct strbuf fullref
= STRBUF_INIT
;
740 for (p
= ref_rev_parse_rules
; *p
; p
++) {
741 struct object_id oid_from_ref
;
742 struct object_id
*this_result
;
744 struct ref_store
*refs
= get_main_ref_store(repo
);
746 this_result
= refs_found
? &oid_from_ref
: oid
;
747 strbuf_reset(&fullref
);
748 strbuf_addf(&fullref
, *p
, len
, str
);
749 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
755 if (!warn_ambiguous_refs
)
757 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
758 warning(_("ignoring dangling symref %s"), fullref
.buf
);
759 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
760 warning(_("ignoring broken ref %s"), fullref
.buf
);
763 strbuf_release(&fullref
);
767 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
768 struct object_id
*oid
, char **log
)
770 struct ref_store
*refs
= get_main_ref_store(r
);
771 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
774 struct strbuf path
= STRBUF_INIT
;
777 for (p
= ref_rev_parse_rules
; *p
; p
++) {
778 struct object_id hash
;
779 const char *ref
, *it
;
782 strbuf_addf(&path
, *p
, len
, str
);
783 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
785 oid
? &hash
: NULL
, NULL
);
788 if (refs_reflog_exists(refs
, path
.buf
))
790 else if (strcmp(ref
, path
.buf
) &&
791 refs_reflog_exists(refs
, ref
))
800 if (!warn_ambiguous_refs
)
803 strbuf_release(&path
);
808 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
810 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
813 static int is_per_worktree_ref(const char *refname
)
815 return starts_with(refname
, "refs/worktree/") ||
816 starts_with(refname
, "refs/bisect/") ||
817 starts_with(refname
, "refs/rewritten/");
820 static int is_pseudoref_syntax(const char *refname
)
824 for (c
= refname
; *c
; c
++) {
825 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
832 static int is_main_pseudoref_syntax(const char *refname
)
834 return skip_prefix(refname
, "main-worktree/", &refname
) &&
836 is_pseudoref_syntax(refname
);
839 static int is_other_pseudoref_syntax(const char *refname
)
841 if (!skip_prefix(refname
, "worktrees/", &refname
))
843 refname
= strchr(refname
, '/');
844 if (!refname
|| !refname
[1])
846 return is_pseudoref_syntax(refname
+ 1);
849 enum ref_type
ref_type(const char *refname
)
851 if (is_per_worktree_ref(refname
))
852 return REF_TYPE_PER_WORKTREE
;
853 if (is_pseudoref_syntax(refname
))
854 return REF_TYPE_PSEUDOREF
;
855 if (is_main_pseudoref_syntax(refname
))
856 return REF_TYPE_MAIN_PSEUDOREF
;
857 if (is_other_pseudoref_syntax(refname
))
858 return REF_TYPE_OTHER_PSEUDOREF
;
859 return REF_TYPE_NORMAL
;
862 long get_files_ref_lock_timeout_ms(void)
864 static int configured
= 0;
866 /* The default timeout is 100 ms: */
867 static int timeout_ms
= 100;
870 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
877 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
879 const struct object_id
*old_oid
,
882 struct ref_transaction
*transaction
;
883 struct strbuf err
= STRBUF_INIT
;
885 transaction
= ref_store_transaction_begin(refs
, &err
);
887 ref_transaction_delete(transaction
, refname
, old_oid
,
889 ref_transaction_commit(transaction
, &err
)) {
890 error("%s", err
.buf
);
891 ref_transaction_free(transaction
);
892 strbuf_release(&err
);
895 ref_transaction_free(transaction
);
896 strbuf_release(&err
);
900 int delete_ref(const char *msg
, const char *refname
,
901 const struct object_id
*old_oid
, unsigned int flags
)
903 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
907 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
912 while ((c
= *msg
++)) {
913 if (wasspace
&& isspace(c
))
915 wasspace
= isspace(c
);
923 static char *normalize_reflog_message(const char *msg
)
925 struct strbuf sb
= STRBUF_INIT
;
928 copy_reflog_msg(&sb
, msg
);
929 return strbuf_detach(&sb
, NULL
);
932 int should_autocreate_reflog(const char *refname
)
934 switch (log_all_ref_updates
) {
935 case LOG_REFS_ALWAYS
:
937 case LOG_REFS_NORMAL
:
938 return starts_with(refname
, "refs/heads/") ||
939 starts_with(refname
, "refs/remotes/") ||
940 starts_with(refname
, "refs/notes/") ||
941 !strcmp(refname
, "HEAD");
947 int is_branch(const char *refname
)
949 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
952 struct read_ref_at_cb
{
957 struct object_id
*oid
;
960 struct object_id ooid
;
961 struct object_id noid
;
965 timestamp_t
*cutoff_time
;
970 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
971 timestamp_t timestamp
, int tz
, const char *message
)
974 *cb
->msg
= xstrdup(message
);
976 *cb
->cutoff_time
= timestamp
;
980 *cb
->cutoff_cnt
= cb
->reccnt
;
983 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
984 const char *email
, timestamp_t timestamp
, int tz
,
985 const char *message
, void *cb_data
)
987 struct read_ref_at_cb
*cb
= cb_data
;
991 cb
->date
= timestamp
;
994 * It is not possible for cb->cnt == 0 on the first iteration because
995 * that special case is handled in read_ref_at().
999 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
1000 if (timestamp
<= cb
->at_time
|| reached_count
) {
1001 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1003 * we have not yet updated cb->[n|o]oid so they still
1004 * hold the values for the previous record.
1006 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
1007 warning(_("log for ref %s has gap after %s"),
1008 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
1010 oidcpy(cb
->oid
, ooid
);
1011 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
1012 oidcpy(cb
->oid
, noid
);
1013 else if (!oideq(noid
, cb
->oid
))
1014 warning(_("log for ref %s unexpectedly ended on %s"),
1015 cb
->refname
, show_date(cb
->date
, cb
->tz
,
1016 DATE_MODE(RFC2822
)));
1020 oidcpy(&cb
->ooid
, ooid
);
1021 oidcpy(&cb
->noid
, noid
);
1022 return cb
->found_it
;
1025 static int read_ref_at_ent_newest(struct object_id
*ooid
, struct object_id
*noid
,
1026 const char *email
, timestamp_t timestamp
,
1027 int tz
, const char *message
, void *cb_data
)
1029 struct read_ref_at_cb
*cb
= cb_data
;
1031 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1032 oidcpy(cb
->oid
, noid
);
1033 /* We just want the first entry */
1037 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
1038 const char *email
, timestamp_t timestamp
,
1039 int tz
, const char *message
, void *cb_data
)
1041 struct read_ref_at_cb
*cb
= cb_data
;
1043 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
1044 oidcpy(cb
->oid
, ooid
);
1045 if (is_null_oid(cb
->oid
))
1046 oidcpy(cb
->oid
, noid
);
1047 /* We just want the first entry */
1051 int read_ref_at(struct ref_store
*refs
, const char *refname
,
1052 unsigned int flags
, timestamp_t at_time
, int cnt
,
1053 struct object_id
*oid
, char **msg
,
1054 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
1056 struct read_ref_at_cb cb
;
1058 memset(&cb
, 0, sizeof(cb
));
1059 cb
.refname
= refname
;
1060 cb
.at_time
= at_time
;
1063 cb
.cutoff_time
= cutoff_time
;
1064 cb
.cutoff_tz
= cutoff_tz
;
1065 cb
.cutoff_cnt
= cutoff_cnt
;
1069 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
1073 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
1076 if (flags
& GET_OID_QUIETLY
)
1079 die(_("log for %s is empty"), refname
);
1084 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1089 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1092 struct ref_transaction
*tr
;
1095 CALLOC_ARRAY(tr
, 1);
1096 tr
->ref_store
= refs
;
1100 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1102 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1105 void ref_transaction_free(struct ref_transaction
*transaction
)
1112 switch (transaction
->state
) {
1113 case REF_TRANSACTION_OPEN
:
1114 case REF_TRANSACTION_CLOSED
:
1117 case REF_TRANSACTION_PREPARED
:
1118 BUG("free called on a prepared reference transaction");
1121 BUG("unexpected reference transaction state");
1125 for (i
= 0; i
< transaction
->nr
; i
++) {
1126 free(transaction
->updates
[i
]->msg
);
1127 free(transaction
->updates
[i
]);
1129 free(transaction
->updates
);
1133 struct ref_update
*ref_transaction_add_update(
1134 struct ref_transaction
*transaction
,
1135 const char *refname
, unsigned int flags
,
1136 const struct object_id
*new_oid
,
1137 const struct object_id
*old_oid
,
1140 struct ref_update
*update
;
1142 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1143 BUG("update called for transaction that is not open");
1145 FLEX_ALLOC_STR(update
, refname
, refname
);
1146 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1147 transaction
->updates
[transaction
->nr
++] = update
;
1149 update
->flags
= flags
;
1151 if (flags
& REF_HAVE_NEW
)
1152 oidcpy(&update
->new_oid
, new_oid
);
1153 if (flags
& REF_HAVE_OLD
)
1154 oidcpy(&update
->old_oid
, old_oid
);
1155 update
->msg
= normalize_reflog_message(msg
);
1159 int ref_transaction_update(struct ref_transaction
*transaction
,
1160 const char *refname
,
1161 const struct object_id
*new_oid
,
1162 const struct object_id
*old_oid
,
1163 unsigned int flags
, const char *msg
,
1168 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1169 ((new_oid
&& !is_null_oid(new_oid
)) ?
1170 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1171 !refname_is_safe(refname
))) {
1172 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1177 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1178 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1181 * Clear flags outside the allowed set; this should be a noop because
1182 * of the BUG() check above, but it works around a -Wnonnull warning
1183 * with some versions of "gcc -O3".
1185 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1187 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1189 ref_transaction_add_update(transaction
, refname
, flags
,
1190 new_oid
, old_oid
, msg
);
1194 int ref_transaction_create(struct ref_transaction
*transaction
,
1195 const char *refname
,
1196 const struct object_id
*new_oid
,
1197 unsigned int flags
, const char *msg
,
1200 if (!new_oid
|| is_null_oid(new_oid
)) {
1201 strbuf_addf(err
, "'%s' has a null OID", refname
);
1204 return ref_transaction_update(transaction
, refname
, new_oid
,
1205 null_oid(), flags
, msg
, err
);
1208 int ref_transaction_delete(struct ref_transaction
*transaction
,
1209 const char *refname
,
1210 const struct object_id
*old_oid
,
1211 unsigned int flags
, const char *msg
,
1214 if (old_oid
&& is_null_oid(old_oid
))
1215 BUG("delete called with old_oid set to zeros");
1216 return ref_transaction_update(transaction
, refname
,
1217 null_oid(), old_oid
,
1221 int ref_transaction_verify(struct ref_transaction
*transaction
,
1222 const char *refname
,
1223 const struct object_id
*old_oid
,
1228 BUG("verify called with old_oid set to NULL");
1229 return ref_transaction_update(transaction
, refname
,
1234 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1235 const char *refname
, const struct object_id
*new_oid
,
1236 const struct object_id
*old_oid
, unsigned int flags
,
1237 enum action_on_err onerr
)
1239 struct ref_transaction
*t
= NULL
;
1240 struct strbuf err
= STRBUF_INIT
;
1243 t
= ref_store_transaction_begin(refs
, &err
);
1245 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1247 ref_transaction_commit(t
, &err
)) {
1249 ref_transaction_free(t
);
1252 const char *str
= _("update_ref failed for ref '%s': %s");
1255 case UPDATE_REFS_MSG_ON_ERR
:
1256 error(str
, refname
, err
.buf
);
1258 case UPDATE_REFS_DIE_ON_ERR
:
1259 die(str
, refname
, err
.buf
);
1261 case UPDATE_REFS_QUIET_ON_ERR
:
1264 strbuf_release(&err
);
1267 strbuf_release(&err
);
1269 ref_transaction_free(t
);
1273 int update_ref(const char *msg
, const char *refname
,
1274 const struct object_id
*new_oid
,
1275 const struct object_id
*old_oid
,
1276 unsigned int flags
, enum action_on_err onerr
)
1278 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1279 old_oid
, flags
, onerr
);
1282 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1283 const char *refname
, int strict
)
1286 static char **scanf_fmts
;
1287 static int nr_rules
;
1289 struct strbuf resolved_buf
= STRBUF_INIT
;
1293 * Pre-generate scanf formats from ref_rev_parse_rules[].
1294 * Generate a format suitable for scanf from a
1295 * ref_rev_parse_rules rule by interpolating "%s" at the
1296 * location of the "%.*s".
1298 size_t total_len
= 0;
1301 /* the rule list is NULL terminated, count them first */
1302 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1303 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1304 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1306 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1309 for (i
= 0; i
< nr_rules
; i
++) {
1310 assert(offset
< total_len
);
1311 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1312 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1313 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1317 /* bail out if there are no rules */
1319 return xstrdup(refname
);
1321 /* buffer for scanf result, at most refname must fit */
1322 short_name
= xstrdup(refname
);
1324 /* skip first rule, it will always match */
1325 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1327 int rules_to_fail
= i
;
1330 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1333 short_name_len
= strlen(short_name
);
1336 * in strict mode, all (except the matched one) rules
1337 * must fail to resolve to a valid non-ambiguous ref
1340 rules_to_fail
= nr_rules
;
1343 * check if the short name resolves to a valid ref,
1344 * but use only rules prior to the matched one
1346 for (j
= 0; j
< rules_to_fail
; j
++) {
1347 const char *rule
= ref_rev_parse_rules
[j
];
1349 /* skip matched rule */
1354 * the short name is ambiguous, if it resolves
1355 * (with this previous rule) to a valid ref
1356 * read_ref() returns 0 on success
1358 strbuf_reset(&resolved_buf
);
1359 strbuf_addf(&resolved_buf
, rule
,
1360 short_name_len
, short_name
);
1361 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1366 * short name is non-ambiguous if all previous rules
1367 * haven't resolved to a valid ref
1369 if (j
== rules_to_fail
) {
1370 strbuf_release(&resolved_buf
);
1375 strbuf_release(&resolved_buf
);
1377 return xstrdup(refname
);
1380 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1382 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1386 static struct string_list
*hide_refs
;
1388 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1391 if (!strcmp("transfer.hiderefs", var
) ||
1392 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1393 !strcmp(key
, "hiderefs"))) {
1398 return config_error_nonbool(var
);
1399 ref
= xstrdup(value
);
1401 while (len
&& ref
[len
- 1] == '/')
1404 CALLOC_ARRAY(hide_refs
, 1);
1405 hide_refs
->strdup_strings
= 1;
1407 string_list_append(hide_refs
, ref
);
1412 int ref_is_hidden(const char *refname
, const char *refname_full
)
1418 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1419 const char *match
= hide_refs
->items
[i
].string
;
1420 const char *subject
;
1424 if (*match
== '!') {
1429 if (*match
== '^') {
1430 subject
= refname_full
;
1436 /* refname can be NULL when namespaces are used. */
1438 skip_prefix(subject
, match
, &p
) &&
1445 const char *find_descendant_ref(const char *dirname
,
1446 const struct string_list
*extras
,
1447 const struct string_list
*skip
)
1455 * Look at the place where dirname would be inserted into
1456 * extras. If there is an entry at that position that starts
1457 * with dirname (remember, dirname includes the trailing
1458 * slash) and is not in skip, then we have a conflict.
1460 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1461 pos
< extras
->nr
; pos
++) {
1462 const char *extra_refname
= extras
->items
[pos
].string
;
1464 if (!starts_with(extra_refname
, dirname
))
1467 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1468 return extra_refname
;
1473 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1475 struct object_id oid
;
1478 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1480 return fn("HEAD", &oid
, flag
, cb_data
);
1485 int head_ref(each_ref_fn fn
, void *cb_data
)
1487 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1490 struct ref_iterator
*refs_ref_iterator_begin(
1491 struct ref_store
*refs
,
1492 const char *prefix
, int trim
,
1493 enum do_for_each_ref_flags flags
)
1495 struct ref_iterator
*iter
;
1497 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1498 static int ref_paranoia
= -1;
1500 if (ref_paranoia
< 0)
1501 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1503 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1504 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1508 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1511 * `iterator_begin()` already takes care of prefix, but we
1512 * might need to do some trimming:
1515 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1517 /* Sanity check for subclasses: */
1519 BUG("reference iterator is not ordered");
1525 * Call fn for each reference in the specified submodule for which the
1526 * refname begins with prefix. If trim is non-zero, then trim that
1527 * many characters off the beginning of each refname before passing
1528 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1529 * include broken references in the iteration. If fn ever returns a
1530 * non-zero value, stop the iteration and return that value;
1531 * otherwise, return 0.
1533 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1534 each_repo_ref_fn fn
, int trim
, int flags
,
1537 struct ref_iterator
*iter
;
1538 struct ref_store
*refs
= get_main_ref_store(r
);
1543 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1545 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1548 struct do_for_each_ref_help
{
1553 static int do_for_each_ref_helper(struct repository
*r
,
1554 const char *refname
,
1555 const struct object_id
*oid
,
1559 struct do_for_each_ref_help
*hp
= cb_data
;
1561 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1564 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1565 each_ref_fn fn
, int trim
,
1566 enum do_for_each_ref_flags flags
, void *cb_data
)
1568 struct ref_iterator
*iter
;
1569 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1574 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1576 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1577 do_for_each_ref_helper
, &hp
);
1580 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1582 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1585 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1587 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1590 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1591 each_ref_fn fn
, void *cb_data
)
1593 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1596 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1598 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1601 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1603 return do_for_each_ref(get_main_ref_store(the_repository
),
1604 prefix
, fn
, 0, 0, cb_data
);
1607 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1608 each_ref_fn fn
, void *cb_data
)
1610 return do_for_each_ref(refs
, prefix
, fn
, 0, 0, cb_data
);
1613 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1615 const char *git_replace_ref_base
= ref_namespace
[NAMESPACE_REPLACE
].ref
;
1616 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1617 strlen(git_replace_ref_base
),
1618 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1621 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1623 struct strbuf buf
= STRBUF_INIT
;
1625 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1626 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1627 buf
.buf
, fn
, 0, 0, cb_data
);
1628 strbuf_release(&buf
);
1632 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1634 return do_for_each_ref(refs
, "", fn
, 0,
1635 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1638 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1640 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1643 static int qsort_strcmp(const void *va
, const void *vb
)
1645 const char *a
= *(const char **)va
;
1646 const char *b
= *(const char **)vb
;
1648 return strcmp(a
, b
);
1651 static void find_longest_prefixes_1(struct string_list
*out
,
1652 struct strbuf
*prefix
,
1653 const char **patterns
, size_t nr
)
1657 for (i
= 0; i
< nr
; i
++) {
1658 char c
= patterns
[i
][prefix
->len
];
1659 if (!c
|| is_glob_special(c
)) {
1660 string_list_append(out
, prefix
->buf
);
1670 * Set "end" to the index of the element _after_ the last one
1673 for (end
= i
+ 1; end
< nr
; end
++) {
1674 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1678 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1679 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1680 strbuf_setlen(prefix
, prefix
->len
- 1);
1686 static void find_longest_prefixes(struct string_list
*out
,
1687 const char **patterns
)
1689 struct strvec sorted
= STRVEC_INIT
;
1690 struct strbuf prefix
= STRBUF_INIT
;
1692 strvec_pushv(&sorted
, patterns
);
1693 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1695 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1697 strvec_clear(&sorted
);
1698 strbuf_release(&prefix
);
1701 int for_each_fullref_in_prefixes(const char *namespace,
1702 const char **patterns
,
1703 each_ref_fn fn
, void *cb_data
)
1705 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1706 struct string_list_item
*prefix
;
1707 struct strbuf buf
= STRBUF_INIT
;
1708 int ret
= 0, namespace_len
;
1710 find_longest_prefixes(&prefixes
, patterns
);
1713 strbuf_addstr(&buf
, namespace);
1714 namespace_len
= buf
.len
;
1716 for_each_string_list_item(prefix
, &prefixes
) {
1717 strbuf_addstr(&buf
, prefix
->string
);
1718 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
);
1721 strbuf_setlen(&buf
, namespace_len
);
1724 string_list_clear(&prefixes
, 0);
1725 strbuf_release(&buf
);
1729 static int refs_read_special_head(struct ref_store
*ref_store
,
1730 const char *refname
, struct object_id
*oid
,
1731 struct strbuf
*referent
, unsigned int *type
,
1734 struct strbuf full_path
= STRBUF_INIT
;
1735 struct strbuf content
= STRBUF_INIT
;
1737 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1739 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1742 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1746 strbuf_release(&full_path
);
1747 strbuf_release(&content
);
1751 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1752 struct object_id
*oid
, struct strbuf
*referent
,
1753 unsigned int *type
, int *failure_errno
)
1755 assert(failure_errno
);
1756 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1757 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1758 type
, failure_errno
);
1761 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1762 type
, failure_errno
);
1765 int refs_read_symbolic_ref(struct ref_store
*ref_store
, const char *refname
,
1766 struct strbuf
*referent
)
1768 return ref_store
->be
->read_symbolic_ref(ref_store
, refname
, referent
);
1771 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1772 const char *refname
,
1774 struct object_id
*oid
,
1777 static struct strbuf sb_refname
= STRBUF_INIT
;
1778 struct object_id unused_oid
;
1785 flags
= &unused_flags
;
1789 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1790 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1791 !refname_is_safe(refname
))
1795 * dwim_ref() uses REF_ISBROKEN to distinguish between
1796 * missing refs and refs that were present but invalid,
1797 * to complain about the latter to stderr.
1799 * We don't know whether the ref exists, so don't set
1802 *flags
|= REF_BAD_NAME
;
1805 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1806 unsigned int read_flags
= 0;
1809 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1810 &read_flags
, &failure_errno
)) {
1811 *flags
|= read_flags
;
1813 /* In reading mode, refs must eventually resolve */
1814 if (resolve_flags
& RESOLVE_REF_READING
)
1818 * Otherwise a missing ref is OK. But the files backend
1819 * may show errors besides ENOENT if there are
1820 * similarly-named refs.
1822 if (failure_errno
!= ENOENT
&&
1823 failure_errno
!= EISDIR
&&
1824 failure_errno
!= ENOTDIR
)
1828 if (*flags
& REF_BAD_NAME
)
1829 *flags
|= REF_ISBROKEN
;
1833 *flags
|= read_flags
;
1835 if (!(read_flags
& REF_ISSYMREF
)) {
1836 if (*flags
& REF_BAD_NAME
) {
1838 *flags
|= REF_ISBROKEN
;
1843 refname
= sb_refname
.buf
;
1844 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1848 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1849 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1850 !refname_is_safe(refname
))
1853 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1860 /* backend functions */
1861 int refs_init_db(struct strbuf
*err
)
1863 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1865 return refs
->be
->init_db(refs
, err
);
1868 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1869 struct object_id
*oid
, int *flags
)
1871 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1872 resolve_flags
, oid
, flags
);
1875 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1876 struct object_id
*oid
)
1878 struct ref_store
*refs
;
1881 refs
= get_submodule_ref_store(submodule
);
1886 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1892 struct ref_store_hash_entry
1894 struct hashmap_entry ent
;
1896 struct ref_store
*refs
;
1898 /* NUL-terminated identifier of the ref store: */
1899 char name
[FLEX_ARRAY
];
1902 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1903 const struct hashmap_entry
*eptr
,
1904 const struct hashmap_entry
*entry_or_key
,
1905 const void *keydata
)
1907 const struct ref_store_hash_entry
*e1
, *e2
;
1910 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1911 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1912 name
= keydata
? keydata
: e2
->name
;
1914 return strcmp(e1
->name
, name
);
1917 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1918 const char *name
, struct ref_store
*refs
)
1920 struct ref_store_hash_entry
*entry
;
1922 FLEX_ALLOC_STR(entry
, name
, name
);
1923 hashmap_entry_init(&entry
->ent
, strhash(name
));
1928 /* A hashmap of ref_stores, stored by submodule name: */
1929 static struct hashmap submodule_ref_stores
;
1931 /* A hashmap of ref_stores, stored by worktree id: */
1932 static struct hashmap worktree_ref_stores
;
1935 * Look up a ref store by name. If that ref_store hasn't been
1936 * registered yet, return NULL.
1938 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1941 struct ref_store_hash_entry
*entry
;
1944 if (!map
->tablesize
)
1945 /* It's initialized on demand in register_ref_store(). */
1948 hash
= strhash(name
);
1949 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1950 struct ref_store_hash_entry
, ent
);
1951 return entry
? entry
->refs
: NULL
;
1955 * Create, record, and return a ref_store instance for the specified
1958 static struct ref_store
*ref_store_init(struct repository
*repo
,
1962 const char *be_name
= "files";
1963 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1964 struct ref_store
*refs
;
1967 BUG("reference backend %s is unknown", be_name
);
1969 refs
= be
->init(repo
, gitdir
, flags
);
1973 struct ref_store
*get_main_ref_store(struct repository
*r
)
1975 if (r
->refs_private
)
1976 return r
->refs_private
;
1979 BUG("attempting to get main_ref_store outside of repository");
1981 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
1982 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1983 return r
->refs_private
;
1987 * Associate a ref store with a name. It is a fatal error to call this
1988 * function twice for the same name.
1990 static void register_ref_store_map(struct hashmap
*map
,
1992 struct ref_store
*refs
,
1995 struct ref_store_hash_entry
*entry
;
1997 if (!map
->tablesize
)
1998 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
2000 entry
= alloc_ref_store_hash_entry(name
, refs
);
2001 if (hashmap_put(map
, &entry
->ent
))
2002 BUG("%s ref_store '%s' initialized twice", type
, name
);
2005 struct ref_store
*get_submodule_ref_store(const char *submodule
)
2007 struct strbuf submodule_sb
= STRBUF_INIT
;
2008 struct ref_store
*refs
;
2009 char *to_free
= NULL
;
2011 struct repository
*subrepo
;
2016 len
= strlen(submodule
);
2017 while (len
&& is_dir_sep(submodule
[len
- 1]))
2023 /* We need to strip off one or more trailing slashes */
2024 submodule
= to_free
= xmemdupz(submodule
, len
);
2026 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
2030 strbuf_addstr(&submodule_sb
, submodule
);
2031 if (!is_nonbare_repository_dir(&submodule_sb
))
2034 if (submodule_to_gitdir(&submodule_sb
, submodule
))
2037 subrepo
= xmalloc(sizeof(*subrepo
));
2039 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2040 * superprojects other than the_repository. This probably should be
2041 * done by making it take a struct repository * parameter instead of a
2044 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
2049 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
2050 REF_STORE_READ
| REF_STORE_ODB
);
2051 register_ref_store_map(&submodule_ref_stores
, "submodule",
2055 strbuf_release(&submodule_sb
);
2061 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
2063 struct ref_store
*refs
;
2067 return get_main_ref_store(the_repository
);
2069 id
= wt
->id
? wt
->id
: "/";
2070 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
2075 refs
= ref_store_init(the_repository
,
2076 git_common_path("worktrees/%s", wt
->id
),
2077 REF_STORE_ALL_CAPS
);
2079 refs
= ref_store_init(the_repository
,
2080 get_git_common_dir(),
2081 REF_STORE_ALL_CAPS
);
2084 register_ref_store_map(&worktree_ref_stores
, "worktree",
2089 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
2090 const char *path
, const struct ref_storage_be
*be
)
2094 refs
->gitdir
= xstrdup(path
);
2097 /* backend functions */
2098 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
2100 return refs
->be
->pack_refs(refs
, flags
);
2103 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2105 if (current_ref_iter
&&
2106 (current_ref_iter
->oid
== base
||
2107 oideq(current_ref_iter
->oid
, base
)))
2108 return ref_iterator_peel(current_ref_iter
, peeled
);
2110 return peel_object(base
, peeled
) ? -1 : 0;
2113 int refs_create_symref(struct ref_store
*refs
,
2114 const char *ref_target
,
2115 const char *refs_heads_master
,
2121 msg
= normalize_reflog_message(logmsg
);
2122 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2128 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2131 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2132 refs_heads_master
, logmsg
);
2135 int ref_update_reject_duplicates(struct string_list
*refnames
,
2138 size_t i
, n
= refnames
->nr
;
2142 for (i
= 1; i
< n
; i
++) {
2143 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2144 refnames
->items
[i
].string
);
2148 _("multiple updates for ref '%s' not allowed"),
2149 refnames
->items
[i
].string
);
2151 } else if (cmp
> 0) {
2152 BUG("ref_update_reject_duplicates() received unsorted list");
2158 static int run_transaction_hook(struct ref_transaction
*transaction
,
2161 struct child_process proc
= CHILD_PROCESS_INIT
;
2162 struct strbuf buf
= STRBUF_INIT
;
2166 hook
= find_hook("reference-transaction");
2170 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2172 proc
.stdout_to_stderr
= 1;
2173 proc
.trace2_hook_name
= "reference-transaction";
2175 ret
= start_command(&proc
);
2179 sigchain_push(SIGPIPE
, SIG_IGN
);
2181 for (i
= 0; i
< transaction
->nr
; i
++) {
2182 struct ref_update
*update
= transaction
->updates
[i
];
2185 strbuf_addf(&buf
, "%s %s %s\n",
2186 oid_to_hex(&update
->old_oid
),
2187 oid_to_hex(&update
->new_oid
),
2190 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2191 if (errno
!= EPIPE
) {
2192 /* Don't leak errno outside this API */
2201 sigchain_pop(SIGPIPE
);
2202 strbuf_release(&buf
);
2204 ret
|= finish_command(&proc
);
2208 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2211 struct ref_store
*refs
= transaction
->ref_store
;
2214 switch (transaction
->state
) {
2215 case REF_TRANSACTION_OPEN
:
2218 case REF_TRANSACTION_PREPARED
:
2219 BUG("prepare called twice on reference transaction");
2221 case REF_TRANSACTION_CLOSED
:
2222 BUG("prepare called on a closed reference transaction");
2225 BUG("unexpected reference transaction state");
2229 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2231 _("ref updates forbidden inside quarantine environment"));
2235 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2239 ret
= run_transaction_hook(transaction
, "prepared");
2241 ref_transaction_abort(transaction
, err
);
2242 die(_("ref updates aborted by hook"));
2248 int ref_transaction_abort(struct ref_transaction
*transaction
,
2251 struct ref_store
*refs
= transaction
->ref_store
;
2254 switch (transaction
->state
) {
2255 case REF_TRANSACTION_OPEN
:
2256 /* No need to abort explicitly. */
2258 case REF_TRANSACTION_PREPARED
:
2259 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2261 case REF_TRANSACTION_CLOSED
:
2262 BUG("abort called on a closed reference transaction");
2265 BUG("unexpected reference transaction state");
2269 run_transaction_hook(transaction
, "aborted");
2271 ref_transaction_free(transaction
);
2275 int ref_transaction_commit(struct ref_transaction
*transaction
,
2278 struct ref_store
*refs
= transaction
->ref_store
;
2281 switch (transaction
->state
) {
2282 case REF_TRANSACTION_OPEN
:
2283 /* Need to prepare first. */
2284 ret
= ref_transaction_prepare(transaction
, err
);
2288 case REF_TRANSACTION_PREPARED
:
2289 /* Fall through to finish. */
2291 case REF_TRANSACTION_CLOSED
:
2292 BUG("commit called on a closed reference transaction");
2295 BUG("unexpected reference transaction state");
2299 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2301 run_transaction_hook(transaction
, "committed");
2305 int refs_verify_refname_available(struct ref_store
*refs
,
2306 const char *refname
,
2307 const struct string_list
*extras
,
2308 const struct string_list
*skip
,
2312 const char *extra_refname
;
2313 struct strbuf dirname
= STRBUF_INIT
;
2314 struct strbuf referent
= STRBUF_INIT
;
2315 struct object_id oid
;
2317 struct ref_iterator
*iter
;
2322 * For the sake of comments in this function, suppose that
2323 * refname is "refs/foo/bar".
2328 strbuf_grow(&dirname
, strlen(refname
) + 1);
2329 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2331 * Just saying "Is a directory" when we e.g. can't
2332 * lock some multi-level ref isn't very informative,
2333 * the user won't be told *what* is a directory, so
2334 * let's not use strerror() below.
2337 /* Expand dirname to the new prefix, not including the trailing slash: */
2338 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2341 * We are still at a leading dir of the refname (e.g.,
2342 * "refs/foo"; if there is a reference with that name,
2343 * it is a conflict, *unless* it is in skip.
2345 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2348 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2349 &type
, &ignore_errno
)) {
2350 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2351 dirname
.buf
, refname
);
2355 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2356 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2357 refname
, dirname
.buf
);
2363 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2364 * There is no point in searching for a reference with that
2365 * name, because a refname isn't considered to conflict with
2366 * itself. But we still need to check for references whose
2367 * names are in the "refs/foo/bar/" namespace, because they
2370 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2371 strbuf_addch(&dirname
, '/');
2373 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2374 DO_FOR_EACH_INCLUDE_BROKEN
);
2375 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2377 string_list_has_string(skip
, iter
->refname
))
2380 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2381 iter
->refname
, refname
);
2382 ref_iterator_abort(iter
);
2386 if (ok
!= ITER_DONE
)
2387 BUG("error while iterating over references");
2389 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2391 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2392 refname
, extra_refname
);
2397 strbuf_release(&referent
);
2398 strbuf_release(&dirname
);
2402 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2404 struct ref_iterator
*iter
;
2405 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2407 iter
= refs
->be
->reflog_iterator_begin(refs
);
2409 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2410 do_for_each_ref_helper
, &hp
);
2413 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2415 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2418 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2419 const char *refname
,
2420 each_reflog_ent_fn fn
,
2423 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2427 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2430 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2431 refname
, fn
, cb_data
);
2434 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2435 each_reflog_ent_fn fn
, void *cb_data
)
2437 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2440 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2443 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2447 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2449 return refs
->be
->reflog_exists(refs
, refname
);
2452 int reflog_exists(const char *refname
)
2454 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2457 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2460 return refs
->be
->create_reflog(refs
, refname
, err
);
2463 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2465 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2469 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2471 return refs
->be
->delete_reflog(refs
, refname
);
2474 int delete_reflog(const char *refname
)
2476 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2479 int refs_reflog_expire(struct ref_store
*refs
,
2480 const char *refname
,
2482 reflog_expiry_prepare_fn prepare_fn
,
2483 reflog_expiry_should_prune_fn should_prune_fn
,
2484 reflog_expiry_cleanup_fn cleanup_fn
,
2485 void *policy_cb_data
)
2487 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2488 prepare_fn
, should_prune_fn
,
2489 cleanup_fn
, policy_cb_data
);
2492 int reflog_expire(const char *refname
,
2494 reflog_expiry_prepare_fn prepare_fn
,
2495 reflog_expiry_should_prune_fn should_prune_fn
,
2496 reflog_expiry_cleanup_fn cleanup_fn
,
2497 void *policy_cb_data
)
2499 return refs_reflog_expire(get_main_ref_store(the_repository
),
2501 prepare_fn
, should_prune_fn
,
2502 cleanup_fn
, policy_cb_data
);
2505 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2508 struct ref_store
*refs
= transaction
->ref_store
;
2510 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2513 void ref_transaction_for_each_queued_update(struct ref_transaction
*transaction
,
2514 ref_transaction_for_each_queued_update_fn cb
,
2519 for (i
= 0; i
< transaction
->nr
; i
++) {
2520 struct ref_update
*update
= transaction
->updates
[i
];
2523 (update
->flags
& REF_HAVE_OLD
) ? &update
->old_oid
: NULL
,
2524 (update
->flags
& REF_HAVE_NEW
) ? &update
->new_oid
: NULL
,
2529 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2530 struct string_list
*refnames
, unsigned int flags
)
2535 msg
= normalize_reflog_message(logmsg
);
2536 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2541 int delete_refs(const char *msg
, struct string_list
*refnames
,
2544 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2547 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2548 const char *newref
, const char *logmsg
)
2553 msg
= normalize_reflog_message(logmsg
);
2554 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2559 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2561 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2564 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2565 const char *newref
, const char *logmsg
)
2570 msg
= normalize_reflog_message(logmsg
);
2571 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2576 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2578 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);