2 * The backend-independent part of the reference module.
11 #include "refs/refs-internal.h"
12 #include "run-command.h"
13 #include "object-store.h"
16 #include "submodule.h"
19 #include "repository.h"
23 * List of all available backends
25 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
27 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
29 struct ref_storage_be
*be
;
30 for (be
= refs_backends
; be
; be
= be
->next
)
31 if (!strcmp(be
->name
, name
))
36 int ref_storage_backend_exists(const char *name
)
38 return find_ref_storage_backend(name
) != NULL
;
42 * How to handle various characters in refnames:
43 * 0: An acceptable character for refs
45 * 2: ., look for a preceding . to reject .. in refs
46 * 3: {, look for a preceding @ to reject @{ in refs
47 * 4: A bad character: ASCII control characters, and
48 * ":", "?", "[", "\", "^", "~", SP, or TAB
49 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
51 static unsigned char refname_disposition
[256] = {
52 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
53 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
54 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
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, 4, 4, 0, 4, 0,
58 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
59 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
63 * Try to read one refname component from the front of refname.
64 * Return the length of the component found, or -1 if the component is
65 * not legal. It is legal if it is something reasonable to have under
66 * ".git/refs/"; We do not like it if:
68 * - it begins with ".", or
69 * - it has double dots "..", or
70 * - it has ASCII control characters, or
71 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
72 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
73 * - it ends with a "/", or
74 * - it ends with ".lock", or
75 * - it contains a "@{" portion
77 * When sanitized is not NULL, instead of rejecting the input refname
78 * as an error, try to come up with a usable replacement for the input
81 static int check_refname_component(const char *refname
, int *flags
,
82 struct strbuf
*sanitized
)
86 size_t component_start
= 0; /* garbage - not a reasonable initial value */
89 component_start
= sanitized
->len
;
91 for (cp
= refname
; ; cp
++) {
93 unsigned char disp
= refname_disposition
[ch
];
95 if (sanitized
&& disp
!= 1)
96 strbuf_addch(sanitized
, ch
);
102 if (last
== '.') { /* Refname contains "..". */
104 /* collapse ".." to single "." */
105 strbuf_setlen(sanitized
, sanitized
->len
- 1);
111 if (last
== '@') { /* Refname contains "@{". */
113 sanitized
->buf
[sanitized
->len
-1] = '-';
121 sanitized
->buf
[sanitized
->len
-1] = '-';
126 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
127 /* refspec can't be a pattern */
129 sanitized
->buf
[sanitized
->len
-1] = '-';
135 * Unset the pattern flag so that we only accept
136 * a single asterisk for one side of refspec.
138 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
145 return 0; /* Component has zero length. */
147 if (refname
[0] == '.') { /* Component starts with '.'. */
149 sanitized
->buf
[component_start
] = '-';
153 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
154 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
157 /* Refname ends with ".lock". */
158 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
159 /* try again in case we have .lock.lock */
165 static int check_or_sanitize_refname(const char *refname
, int flags
,
166 struct strbuf
*sanitized
)
168 int component_len
, component_count
= 0;
170 if (!strcmp(refname
, "@")) {
171 /* Refname is a single character '@'. */
173 strbuf_addch(sanitized
, '-');
179 if (sanitized
&& sanitized
->len
)
180 strbuf_complete(sanitized
, '/');
182 /* We are at the start of a path component. */
183 component_len
= check_refname_component(refname
, &flags
,
185 if (sanitized
&& component_len
== 0)
186 ; /* OK, omit empty component */
187 else if (component_len
<= 0)
191 if (refname
[component_len
] == '\0')
193 /* Skip to next component. */
194 refname
+= component_len
+ 1;
197 if (refname
[component_len
- 1] == '.') {
198 /* Refname ends with '.'. */
200 ; /* omit ending dot */
204 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
205 return -1; /* Refname has only one component. */
209 int check_refname_format(const char *refname
, int flags
)
211 return check_or_sanitize_refname(refname
, flags
, NULL
);
214 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
216 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
217 BUG("sanitizing refname '%s' check returned error", refname
);
220 int refname_is_safe(const char *refname
)
224 if (skip_prefix(refname
, "refs/", &rest
)) {
227 size_t restlen
= strlen(rest
);
229 /* rest must not be empty, or start or end with "/" */
230 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
234 * Does the refname try to escape refs/?
235 * For example: refs/foo/../bar is safe but refs/foo/../../bar
238 buf
= xmallocz(restlen
);
239 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
245 if (!isupper(*refname
) && *refname
!= '_')
253 * Return true if refname, which has the specified oid and flags, can
254 * be resolved to an object in the database. If the referred-to object
255 * does not exist, emit a warning and return false.
257 int ref_resolves_to_object(const char *refname
,
258 const struct object_id
*oid
,
261 if (flags
& REF_ISBROKEN
)
263 if (!has_object_file(oid
)) {
264 error(_("%s does not point to a valid object!"), refname
);
270 char *refs_resolve_refdup(struct ref_store
*refs
,
271 const char *refname
, int resolve_flags
,
272 struct object_id
*oid
, int *flags
)
276 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
278 return xstrdup_or_null(result
);
281 char *resolve_refdup(const char *refname
, int resolve_flags
,
282 struct object_id
*oid
, int *flags
)
284 return refs_resolve_refdup(get_main_ref_store(the_repository
),
285 refname
, resolve_flags
,
289 /* The argument to filter_refs */
297 int refs_read_ref_full(struct ref_store
*refs
, const char *refname
,
298 int resolve_flags
, struct object_id
*oid
, int *flags
)
300 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
, oid
, flags
))
305 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
307 return refs_read_ref_full(get_main_ref_store(the_repository
), refname
,
308 resolve_flags
, oid
, flags
);
311 int read_ref(const char *refname
, struct object_id
*oid
)
313 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
316 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
318 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
, NULL
, NULL
);
321 int ref_exists(const char *refname
)
323 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
326 static int filter_refs(const char *refname
, const struct object_id
*oid
,
327 int flags
, void *data
)
329 struct ref_filter
*filter
= (struct ref_filter
*)data
;
331 if (wildmatch(filter
->pattern
, refname
, 0))
334 skip_prefix(refname
, filter
->prefix
, &refname
);
335 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
338 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
340 struct object
*o
= lookup_unknown_object(name
);
342 if (o
->type
== OBJ_NONE
) {
343 int type
= oid_object_info(the_repository
, name
, NULL
);
344 if (type
< 0 || !object_as_type(o
, type
, 0))
348 if (o
->type
!= OBJ_TAG
)
351 o
= deref_tag_noverify(o
);
355 oidcpy(oid
, &o
->oid
);
359 struct warn_if_dangling_data
{
362 const struct string_list
*refnames
;
366 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
367 int flags
, void *cb_data
)
369 struct warn_if_dangling_data
*d
= cb_data
;
370 const char *resolves_to
;
372 if (!(flags
& REF_ISSYMREF
))
375 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
378 ? strcmp(resolves_to
, d
->refname
)
379 : !string_list_has_string(d
->refnames
, resolves_to
))) {
383 fprintf(d
->fp
, d
->msg_fmt
, refname
);
388 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
390 struct warn_if_dangling_data data
;
393 data
.refname
= refname
;
394 data
.refnames
= NULL
;
395 data
.msg_fmt
= msg_fmt
;
396 for_each_rawref(warn_if_dangling_symref
, &data
);
399 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
401 struct warn_if_dangling_data data
;
405 data
.refnames
= refnames
;
406 data
.msg_fmt
= msg_fmt
;
407 for_each_rawref(warn_if_dangling_symref
, &data
);
410 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
412 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
415 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
417 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
420 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
422 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
425 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
427 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
430 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
432 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
435 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
437 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
440 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
442 struct strbuf buf
= STRBUF_INIT
;
444 struct object_id oid
;
447 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
448 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
449 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
450 strbuf_release(&buf
);
455 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
458 struct strbuf normalized_pattern
= STRBUF_INIT
;
461 BUG("pattern must not start with '/'");
464 strbuf_addstr(&normalized_pattern
, prefix
);
466 else if (!starts_with(pattern
, "refs/"))
467 strbuf_addstr(&normalized_pattern
, "refs/");
468 strbuf_addstr(&normalized_pattern
, pattern
);
469 strbuf_strip_suffix(&normalized_pattern
, "/");
471 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
472 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
473 strbuf_release(&normalized_pattern
);
476 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
477 const char *prefix
, void *cb_data
)
479 struct strbuf real_pattern
= STRBUF_INIT
;
480 struct ref_filter filter
;
483 if (!prefix
&& !starts_with(pattern
, "refs/"))
484 strbuf_addstr(&real_pattern
, "refs/");
486 strbuf_addstr(&real_pattern
, prefix
);
487 strbuf_addstr(&real_pattern
, pattern
);
489 if (!has_glob_specials(pattern
)) {
490 /* Append implied '/' '*' if not present. */
491 strbuf_complete(&real_pattern
, '/');
492 /* No need to check for '*', there is none. */
493 strbuf_addch(&real_pattern
, '*');
496 filter
.pattern
= real_pattern
.buf
;
497 filter
.prefix
= prefix
;
499 filter
.cb_data
= cb_data
;
500 ret
= for_each_ref(filter_refs
, &filter
);
502 strbuf_release(&real_pattern
);
506 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
508 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
511 const char *prettify_refname(const char *name
)
513 if (skip_prefix(name
, "refs/heads/", &name
) ||
514 skip_prefix(name
, "refs/tags/", &name
) ||
515 skip_prefix(name
, "refs/remotes/", &name
))
520 static const char *ref_rev_parse_rules
[] = {
526 "refs/remotes/%.*s/HEAD",
530 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
533 * Is it possible that the caller meant full_name with abbrev_name?
534 * If so return a non-zero value to signal "yes"; the magnitude of
535 * the returned value gives the precedence used for disambiguation.
537 * If abbrev_name cannot mean full_name, return 0.
539 int refname_match(const char *abbrev_name
, const char *full_name
)
542 const int abbrev_name_len
= strlen(abbrev_name
);
543 const int num_rules
= NUM_REV_PARSE_RULES
;
545 for (p
= ref_rev_parse_rules
; *p
; p
++)
546 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
547 return &ref_rev_parse_rules
[num_rules
] - p
;
553 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
554 * the results to 'prefixes'
556 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
559 int len
= strlen(prefix
);
561 for (p
= ref_rev_parse_rules
; *p
; p
++)
562 strvec_pushf(prefixes
, *p
, len
, prefix
);
565 char *repo_default_branch_name(struct repository
*r
)
567 const char *config_key
= "init.defaultbranch";
568 const char *config_display_key
= "init.defaultBranch";
569 char *ret
= NULL
, *full_ref
;
570 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
574 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
575 die(_("could not retrieve `%s`"), config_display_key
);
578 ret
= xstrdup("master");
580 full_ref
= xstrfmt("refs/heads/%s", ret
);
581 if (check_refname_format(full_ref
, 0))
582 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
588 const char *git_default_branch_name(void)
593 ret
= repo_default_branch_name(the_repository
);
599 * *string and *len will only be substituted, and *string returned (for
600 * later free()ing) if the string passed in is a magic short-hand form
603 static char *substitute_branch_name(struct repository
*r
,
604 const char **string
, int *len
,
605 int nonfatal_dangling_mark
)
607 struct strbuf buf
= STRBUF_INIT
;
608 struct interpret_branch_name_options options
= {
609 .nonfatal_dangling_mark
= nonfatal_dangling_mark
611 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
615 *string
= strbuf_detach(&buf
, &size
);
617 return (char *)*string
;
623 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
624 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
626 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
627 nonfatal_dangling_mark
);
628 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
633 int expand_ref(struct repository
*repo
, const char *str
, int len
,
634 struct object_id
*oid
, char **ref
)
638 struct strbuf fullref
= STRBUF_INIT
;
641 for (p
= ref_rev_parse_rules
; *p
; p
++) {
642 struct object_id oid_from_ref
;
643 struct object_id
*this_result
;
646 this_result
= refs_found
? &oid_from_ref
: oid
;
647 strbuf_reset(&fullref
);
648 strbuf_addf(&fullref
, *p
, len
, str
);
649 r
= refs_resolve_ref_unsafe(get_main_ref_store(repo
),
650 fullref
.buf
, RESOLVE_REF_READING
,
655 if (!warn_ambiguous_refs
)
657 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
658 warning(_("ignoring dangling symref %s"), fullref
.buf
);
659 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
660 warning(_("ignoring broken ref %s"), fullref
.buf
);
663 strbuf_release(&fullref
);
667 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
668 struct object_id
*oid
, char **log
)
670 struct ref_store
*refs
= get_main_ref_store(r
);
671 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
674 struct strbuf path
= STRBUF_INIT
;
677 for (p
= ref_rev_parse_rules
; *p
; p
++) {
678 struct object_id hash
;
679 const char *ref
, *it
;
682 strbuf_addf(&path
, *p
, len
, str
);
683 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
688 if (refs_reflog_exists(refs
, path
.buf
))
690 else if (strcmp(ref
, path
.buf
) &&
691 refs_reflog_exists(refs
, ref
))
699 if (!warn_ambiguous_refs
)
702 strbuf_release(&path
);
707 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
709 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
712 static int is_per_worktree_ref(const char *refname
)
714 return starts_with(refname
, "refs/worktree/") ||
715 starts_with(refname
, "refs/bisect/") ||
716 starts_with(refname
, "refs/rewritten/");
719 static int is_pseudoref_syntax(const char *refname
)
723 for (c
= refname
; *c
; c
++) {
724 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
731 static int is_main_pseudoref_syntax(const char *refname
)
733 return skip_prefix(refname
, "main-worktree/", &refname
) &&
735 is_pseudoref_syntax(refname
);
738 static int is_other_pseudoref_syntax(const char *refname
)
740 if (!skip_prefix(refname
, "worktrees/", &refname
))
742 refname
= strchr(refname
, '/');
743 if (!refname
|| !refname
[1])
745 return is_pseudoref_syntax(refname
+ 1);
748 enum ref_type
ref_type(const char *refname
)
750 if (is_per_worktree_ref(refname
))
751 return REF_TYPE_PER_WORKTREE
;
752 if (is_pseudoref_syntax(refname
))
753 return REF_TYPE_PSEUDOREF
;
754 if (is_main_pseudoref_syntax(refname
))
755 return REF_TYPE_MAIN_PSEUDOREF
;
756 if (is_other_pseudoref_syntax(refname
))
757 return REF_TYPE_OTHER_PSEUDOREF
;
758 return REF_TYPE_NORMAL
;
761 long get_files_ref_lock_timeout_ms(void)
763 static int configured
= 0;
765 /* The default timeout is 100 ms: */
766 static int timeout_ms
= 100;
769 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
776 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
778 const struct object_id
*old_oid
,
781 struct ref_transaction
*transaction
;
782 struct strbuf err
= STRBUF_INIT
;
784 transaction
= ref_store_transaction_begin(refs
, &err
);
786 ref_transaction_delete(transaction
, refname
, old_oid
,
788 ref_transaction_commit(transaction
, &err
)) {
789 error("%s", err
.buf
);
790 ref_transaction_free(transaction
);
791 strbuf_release(&err
);
794 ref_transaction_free(transaction
);
795 strbuf_release(&err
);
799 int delete_ref(const char *msg
, const char *refname
,
800 const struct object_id
*old_oid
, unsigned int flags
)
802 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
806 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
811 while ((c
= *msg
++)) {
812 if (wasspace
&& isspace(c
))
814 wasspace
= isspace(c
);
822 static char *normalize_reflog_message(const char *msg
)
824 struct strbuf sb
= STRBUF_INIT
;
827 copy_reflog_msg(&sb
, msg
);
828 return strbuf_detach(&sb
, NULL
);
831 int should_autocreate_reflog(const char *refname
)
833 switch (log_all_ref_updates
) {
834 case LOG_REFS_ALWAYS
:
836 case LOG_REFS_NORMAL
:
837 return starts_with(refname
, "refs/heads/") ||
838 starts_with(refname
, "refs/remotes/") ||
839 starts_with(refname
, "refs/notes/") ||
840 !strcmp(refname
, "HEAD");
846 int is_branch(const char *refname
)
848 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
851 struct read_ref_at_cb
{
856 struct object_id
*oid
;
859 struct object_id ooid
;
860 struct object_id noid
;
864 timestamp_t
*cutoff_time
;
869 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
870 const char *email
, timestamp_t timestamp
, int tz
,
871 const char *message
, void *cb_data
)
873 struct read_ref_at_cb
*cb
= cb_data
;
877 cb
->date
= timestamp
;
879 if (timestamp
<= cb
->at_time
|| cb
->cnt
== 0) {
881 *cb
->msg
= xstrdup(message
);
883 *cb
->cutoff_time
= timestamp
;
887 *cb
->cutoff_cnt
= cb
->reccnt
- 1;
889 * we have not yet updated cb->[n|o]oid so they still
890 * hold the values for the previous record.
892 if (!is_null_oid(&cb
->ooid
)) {
893 oidcpy(cb
->oid
, noid
);
894 if (!oideq(&cb
->ooid
, noid
))
895 warning(_("log for ref %s has gap after %s"),
896 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
898 else if (cb
->date
== cb
->at_time
)
899 oidcpy(cb
->oid
, noid
);
900 else if (!oideq(noid
, cb
->oid
))
901 warning(_("log for ref %s unexpectedly ended on %s"),
902 cb
->refname
, show_date(cb
->date
, cb
->tz
,
903 DATE_MODE(RFC2822
)));
904 oidcpy(&cb
->ooid
, ooid
);
905 oidcpy(&cb
->noid
, noid
);
909 oidcpy(&cb
->ooid
, ooid
);
910 oidcpy(&cb
->noid
, noid
);
916 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
917 const char *email
, timestamp_t timestamp
,
918 int tz
, const char *message
, void *cb_data
)
920 struct read_ref_at_cb
*cb
= cb_data
;
923 *cb
->msg
= xstrdup(message
);
925 *cb
->cutoff_time
= timestamp
;
929 *cb
->cutoff_cnt
= cb
->reccnt
;
930 oidcpy(cb
->oid
, ooid
);
931 if (is_null_oid(cb
->oid
))
932 oidcpy(cb
->oid
, noid
);
933 /* We just want the first entry */
937 int read_ref_at(struct ref_store
*refs
, const char *refname
,
938 unsigned int flags
, timestamp_t at_time
, int cnt
,
939 struct object_id
*oid
, char **msg
,
940 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
942 struct read_ref_at_cb cb
;
944 memset(&cb
, 0, sizeof(cb
));
945 cb
.refname
= refname
;
946 cb
.at_time
= at_time
;
949 cb
.cutoff_time
= cutoff_time
;
950 cb
.cutoff_tz
= cutoff_tz
;
951 cb
.cutoff_cnt
= cutoff_cnt
;
954 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
957 if (flags
& GET_OID_QUIETLY
)
960 die(_("log for %s is empty"), refname
);
965 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
970 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
973 struct ref_transaction
*tr
;
976 tr
= xcalloc(1, sizeof(struct ref_transaction
));
977 tr
->ref_store
= refs
;
981 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
983 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
986 void ref_transaction_free(struct ref_transaction
*transaction
)
993 switch (transaction
->state
) {
994 case REF_TRANSACTION_OPEN
:
995 case REF_TRANSACTION_CLOSED
:
998 case REF_TRANSACTION_PREPARED
:
999 BUG("free called on a prepared reference transaction");
1002 BUG("unexpected reference transaction state");
1006 for (i
= 0; i
< transaction
->nr
; i
++) {
1007 free(transaction
->updates
[i
]->msg
);
1008 free(transaction
->updates
[i
]);
1010 free(transaction
->updates
);
1014 struct ref_update
*ref_transaction_add_update(
1015 struct ref_transaction
*transaction
,
1016 const char *refname
, unsigned int flags
,
1017 const struct object_id
*new_oid
,
1018 const struct object_id
*old_oid
,
1021 struct ref_update
*update
;
1023 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1024 BUG("update called for transaction that is not open");
1026 FLEX_ALLOC_STR(update
, refname
, refname
);
1027 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1028 transaction
->updates
[transaction
->nr
++] = update
;
1030 update
->flags
= flags
;
1032 if (flags
& REF_HAVE_NEW
)
1033 oidcpy(&update
->new_oid
, new_oid
);
1034 if (flags
& REF_HAVE_OLD
)
1035 oidcpy(&update
->old_oid
, old_oid
);
1036 update
->msg
= normalize_reflog_message(msg
);
1040 int ref_transaction_update(struct ref_transaction
*transaction
,
1041 const char *refname
,
1042 const struct object_id
*new_oid
,
1043 const struct object_id
*old_oid
,
1044 unsigned int flags
, const char *msg
,
1049 if ((new_oid
&& !is_null_oid(new_oid
)) ?
1050 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1051 !refname_is_safe(refname
)) {
1052 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1057 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1058 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1060 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1062 ref_transaction_add_update(transaction
, refname
, flags
,
1063 new_oid
, old_oid
, msg
);
1067 int ref_transaction_create(struct ref_transaction
*transaction
,
1068 const char *refname
,
1069 const struct object_id
*new_oid
,
1070 unsigned int flags
, const char *msg
,
1073 if (!new_oid
|| is_null_oid(new_oid
))
1074 BUG("create called without valid new_oid");
1075 return ref_transaction_update(transaction
, refname
, new_oid
,
1076 &null_oid
, flags
, msg
, err
);
1079 int ref_transaction_delete(struct ref_transaction
*transaction
,
1080 const char *refname
,
1081 const struct object_id
*old_oid
,
1082 unsigned int flags
, const char *msg
,
1085 if (old_oid
&& is_null_oid(old_oid
))
1086 BUG("delete called with old_oid set to zeros");
1087 return ref_transaction_update(transaction
, refname
,
1092 int ref_transaction_verify(struct ref_transaction
*transaction
,
1093 const char *refname
,
1094 const struct object_id
*old_oid
,
1099 BUG("verify called with old_oid set to NULL");
1100 return ref_transaction_update(transaction
, refname
,
1105 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1106 const char *refname
, const struct object_id
*new_oid
,
1107 const struct object_id
*old_oid
, unsigned int flags
,
1108 enum action_on_err onerr
)
1110 struct ref_transaction
*t
= NULL
;
1111 struct strbuf err
= STRBUF_INIT
;
1114 t
= ref_store_transaction_begin(refs
, &err
);
1116 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1118 ref_transaction_commit(t
, &err
)) {
1120 ref_transaction_free(t
);
1123 const char *str
= _("update_ref failed for ref '%s': %s");
1126 case UPDATE_REFS_MSG_ON_ERR
:
1127 error(str
, refname
, err
.buf
);
1129 case UPDATE_REFS_DIE_ON_ERR
:
1130 die(str
, refname
, err
.buf
);
1132 case UPDATE_REFS_QUIET_ON_ERR
:
1135 strbuf_release(&err
);
1138 strbuf_release(&err
);
1140 ref_transaction_free(t
);
1144 int update_ref(const char *msg
, const char *refname
,
1145 const struct object_id
*new_oid
,
1146 const struct object_id
*old_oid
,
1147 unsigned int flags
, enum action_on_err onerr
)
1149 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1150 old_oid
, flags
, onerr
);
1153 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1154 const char *refname
, int strict
)
1157 static char **scanf_fmts
;
1158 static int nr_rules
;
1160 struct strbuf resolved_buf
= STRBUF_INIT
;
1164 * Pre-generate scanf formats from ref_rev_parse_rules[].
1165 * Generate a format suitable for scanf from a
1166 * ref_rev_parse_rules rule by interpolating "%s" at the
1167 * location of the "%.*s".
1169 size_t total_len
= 0;
1172 /* the rule list is NULL terminated, count them first */
1173 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1174 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1175 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1177 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1180 for (i
= 0; i
< nr_rules
; i
++) {
1181 assert(offset
< total_len
);
1182 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1183 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1184 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1188 /* bail out if there are no rules */
1190 return xstrdup(refname
);
1192 /* buffer for scanf result, at most refname must fit */
1193 short_name
= xstrdup(refname
);
1195 /* skip first rule, it will always match */
1196 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1198 int rules_to_fail
= i
;
1201 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1204 short_name_len
= strlen(short_name
);
1207 * in strict mode, all (except the matched one) rules
1208 * must fail to resolve to a valid non-ambiguous ref
1211 rules_to_fail
= nr_rules
;
1214 * check if the short name resolves to a valid ref,
1215 * but use only rules prior to the matched one
1217 for (j
= 0; j
< rules_to_fail
; j
++) {
1218 const char *rule
= ref_rev_parse_rules
[j
];
1220 /* skip matched rule */
1225 * the short name is ambiguous, if it resolves
1226 * (with this previous rule) to a valid ref
1227 * read_ref() returns 0 on success
1229 strbuf_reset(&resolved_buf
);
1230 strbuf_addf(&resolved_buf
, rule
,
1231 short_name_len
, short_name
);
1232 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1237 * short name is non-ambiguous if all previous rules
1238 * haven't resolved to a valid ref
1240 if (j
== rules_to_fail
) {
1241 strbuf_release(&resolved_buf
);
1246 strbuf_release(&resolved_buf
);
1248 return xstrdup(refname
);
1251 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1253 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1257 static struct string_list
*hide_refs
;
1259 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1262 if (!strcmp("transfer.hiderefs", var
) ||
1263 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1264 !strcmp(key
, "hiderefs"))) {
1269 return config_error_nonbool(var
);
1270 ref
= xstrdup(value
);
1272 while (len
&& ref
[len
- 1] == '/')
1275 hide_refs
= xcalloc(1, sizeof(*hide_refs
));
1276 hide_refs
->strdup_strings
= 1;
1278 string_list_append(hide_refs
, ref
);
1283 int ref_is_hidden(const char *refname
, const char *refname_full
)
1289 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1290 const char *match
= hide_refs
->items
[i
].string
;
1291 const char *subject
;
1295 if (*match
== '!') {
1300 if (*match
== '^') {
1301 subject
= refname_full
;
1307 /* refname can be NULL when namespaces are used. */
1309 skip_prefix(subject
, match
, &p
) &&
1316 const char *find_descendant_ref(const char *dirname
,
1317 const struct string_list
*extras
,
1318 const struct string_list
*skip
)
1326 * Look at the place where dirname would be inserted into
1327 * extras. If there is an entry at that position that starts
1328 * with dirname (remember, dirname includes the trailing
1329 * slash) and is not in skip, then we have a conflict.
1331 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1332 pos
< extras
->nr
; pos
++) {
1333 const char *extra_refname
= extras
->items
[pos
].string
;
1335 if (!starts_with(extra_refname
, dirname
))
1338 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1339 return extra_refname
;
1344 int refs_rename_ref_available(struct ref_store
*refs
,
1345 const char *old_refname
,
1346 const char *new_refname
)
1348 struct string_list skip
= STRING_LIST_INIT_NODUP
;
1349 struct strbuf err
= STRBUF_INIT
;
1352 string_list_insert(&skip
, old_refname
);
1353 ok
= !refs_verify_refname_available(refs
, new_refname
,
1356 error("%s", err
.buf
);
1358 string_list_clear(&skip
, 0);
1359 strbuf_release(&err
);
1363 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1365 struct object_id oid
;
1368 if (!refs_read_ref_full(refs
, "HEAD", RESOLVE_REF_READING
,
1370 return fn("HEAD", &oid
, flag
, cb_data
);
1375 int head_ref(each_ref_fn fn
, void *cb_data
)
1377 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1380 struct ref_iterator
*refs_ref_iterator_begin(
1381 struct ref_store
*refs
,
1382 const char *prefix
, int trim
, int flags
)
1384 struct ref_iterator
*iter
;
1386 if (ref_paranoia
< 0)
1387 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 0);
1389 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1391 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1394 * `iterator_begin()` already takes care of prefix, but we
1395 * might need to do some trimming:
1398 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1400 /* Sanity check for subclasses: */
1402 BUG("reference iterator is not ordered");
1408 * Call fn for each reference in the specified submodule for which the
1409 * refname begins with prefix. If trim is non-zero, then trim that
1410 * many characters off the beginning of each refname before passing
1411 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1412 * include broken references in the iteration. If fn ever returns a
1413 * non-zero value, stop the iteration and return that value;
1414 * otherwise, return 0.
1416 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1417 each_repo_ref_fn fn
, int trim
, int flags
,
1420 struct ref_iterator
*iter
;
1421 struct ref_store
*refs
= get_main_ref_store(r
);
1426 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1428 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1431 struct do_for_each_ref_help
{
1436 static int do_for_each_ref_helper(struct repository
*r
,
1437 const char *refname
,
1438 const struct object_id
*oid
,
1442 struct do_for_each_ref_help
*hp
= cb_data
;
1444 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1447 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1448 each_ref_fn fn
, int trim
, int flags
, void *cb_data
)
1450 struct ref_iterator
*iter
;
1451 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1456 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1458 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1459 do_for_each_ref_helper
, &hp
);
1462 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1464 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1467 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1469 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1472 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1473 each_ref_fn fn
, void *cb_data
)
1475 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1478 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1480 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1483 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
, unsigned int broken
)
1485 unsigned int flag
= 0;
1488 flag
= DO_FOR_EACH_INCLUDE_BROKEN
;
1489 return do_for_each_ref(get_main_ref_store(the_repository
),
1490 prefix
, fn
, 0, flag
, cb_data
);
1493 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1494 each_ref_fn fn
, void *cb_data
,
1495 unsigned int broken
)
1497 unsigned int flag
= 0;
1500 flag
= DO_FOR_EACH_INCLUDE_BROKEN
;
1501 return do_for_each_ref(refs
, prefix
, fn
, 0, flag
, cb_data
);
1504 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1506 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1507 strlen(git_replace_ref_base
),
1508 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1511 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1513 struct strbuf buf
= STRBUF_INIT
;
1515 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1516 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1517 buf
.buf
, fn
, 0, 0, cb_data
);
1518 strbuf_release(&buf
);
1522 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1524 return do_for_each_ref(refs
, "", fn
, 0,
1525 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1528 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1530 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1533 static int refs_read_special_head(struct ref_store
*ref_store
,
1534 const char *refname
, struct object_id
*oid
,
1535 struct strbuf
*referent
, unsigned int *type
)
1537 struct strbuf full_path
= STRBUF_INIT
;
1538 struct strbuf content
= STRBUF_INIT
;
1540 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1542 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1545 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
);
1548 strbuf_release(&full_path
);
1549 strbuf_release(&content
);
1553 int refs_read_raw_ref(struct ref_store
*ref_store
,
1554 const char *refname
, struct object_id
*oid
,
1555 struct strbuf
*referent
, unsigned int *type
)
1557 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1558 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1562 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1566 /* This function needs to return a meaningful errno on failure */
1567 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1568 const char *refname
,
1570 struct object_id
*oid
, int *flags
)
1572 static struct strbuf sb_refname
= STRBUF_INIT
;
1573 struct object_id unused_oid
;
1580 flags
= &unused_flags
;
1584 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1585 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1586 !refname_is_safe(refname
)) {
1592 * dwim_ref() uses REF_ISBROKEN to distinguish between
1593 * missing refs and refs that were present but invalid,
1594 * to complain about the latter to stderr.
1596 * We don't know whether the ref exists, so don't set
1599 *flags
|= REF_BAD_NAME
;
1602 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1603 unsigned int read_flags
= 0;
1605 if (refs_read_raw_ref(refs
, refname
,
1606 oid
, &sb_refname
, &read_flags
)) {
1607 *flags
|= read_flags
;
1609 /* In reading mode, refs must eventually resolve */
1610 if (resolve_flags
& RESOLVE_REF_READING
)
1614 * Otherwise a missing ref is OK. But the files backend
1615 * may show errors besides ENOENT if there are
1616 * similarly-named refs.
1618 if (errno
!= ENOENT
&&
1624 if (*flags
& REF_BAD_NAME
)
1625 *flags
|= REF_ISBROKEN
;
1629 *flags
|= read_flags
;
1631 if (!(read_flags
& REF_ISSYMREF
)) {
1632 if (*flags
& REF_BAD_NAME
) {
1634 *flags
|= REF_ISBROKEN
;
1639 refname
= sb_refname
.buf
;
1640 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1644 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1645 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1646 !refname_is_safe(refname
)) {
1651 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1659 /* backend functions */
1660 int refs_init_db(struct strbuf
*err
)
1662 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1664 return refs
->be
->init_db(refs
, err
);
1667 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1668 struct object_id
*oid
, int *flags
)
1670 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1671 resolve_flags
, oid
, flags
);
1674 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1675 struct object_id
*oid
)
1677 struct ref_store
*refs
;
1680 refs
= get_submodule_ref_store(submodule
);
1685 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1691 struct ref_store_hash_entry
1693 struct hashmap_entry ent
;
1695 struct ref_store
*refs
;
1697 /* NUL-terminated identifier of the ref store: */
1698 char name
[FLEX_ARRAY
];
1701 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1702 const struct hashmap_entry
*eptr
,
1703 const struct hashmap_entry
*entry_or_key
,
1704 const void *keydata
)
1706 const struct ref_store_hash_entry
*e1
, *e2
;
1709 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1710 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1711 name
= keydata
? keydata
: e2
->name
;
1713 return strcmp(e1
->name
, name
);
1716 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1717 const char *name
, struct ref_store
*refs
)
1719 struct ref_store_hash_entry
*entry
;
1721 FLEX_ALLOC_STR(entry
, name
, name
);
1722 hashmap_entry_init(&entry
->ent
, strhash(name
));
1727 /* A hashmap of ref_stores, stored by submodule name: */
1728 static struct hashmap submodule_ref_stores
;
1730 /* A hashmap of ref_stores, stored by worktree id: */
1731 static struct hashmap worktree_ref_stores
;
1734 * Look up a ref store by name. If that ref_store hasn't been
1735 * registered yet, return NULL.
1737 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1740 struct ref_store_hash_entry
*entry
;
1743 if (!map
->tablesize
)
1744 /* It's initialized on demand in register_ref_store(). */
1747 hash
= strhash(name
);
1748 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1749 struct ref_store_hash_entry
, ent
);
1750 return entry
? entry
->refs
: NULL
;
1754 * Create, record, and return a ref_store instance for the specified
1757 static struct ref_store
*ref_store_init(const char *gitdir
,
1760 const char *be_name
= "files";
1761 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1762 struct ref_store
*refs
;
1765 BUG("reference backend %s is unknown", be_name
);
1767 refs
= be
->init(gitdir
, flags
);
1771 struct ref_store
*get_main_ref_store(struct repository
*r
)
1773 if (r
->refs_private
)
1774 return r
->refs_private
;
1777 BUG("attempting to get main_ref_store outside of repository");
1779 r
->refs_private
= ref_store_init(r
->gitdir
, REF_STORE_ALL_CAPS
);
1780 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1781 return r
->refs_private
;
1785 * Associate a ref store with a name. It is a fatal error to call this
1786 * function twice for the same name.
1788 static void register_ref_store_map(struct hashmap
*map
,
1790 struct ref_store
*refs
,
1793 struct ref_store_hash_entry
*entry
;
1795 if (!map
->tablesize
)
1796 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1798 entry
= alloc_ref_store_hash_entry(name
, refs
);
1799 if (hashmap_put(map
, &entry
->ent
))
1800 BUG("%s ref_store '%s' initialized twice", type
, name
);
1803 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1805 struct strbuf submodule_sb
= STRBUF_INIT
;
1806 struct ref_store
*refs
;
1807 char *to_free
= NULL
;
1813 len
= strlen(submodule
);
1814 while (len
&& is_dir_sep(submodule
[len
- 1]))
1820 /* We need to strip off one or more trailing slashes */
1821 submodule
= to_free
= xmemdupz(submodule
, len
);
1823 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1827 strbuf_addstr(&submodule_sb
, submodule
);
1828 if (!is_nonbare_repository_dir(&submodule_sb
))
1831 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1834 /* assume that add_submodule_odb() has been called */
1835 refs
= ref_store_init(submodule_sb
.buf
,
1836 REF_STORE_READ
| REF_STORE_ODB
);
1837 register_ref_store_map(&submodule_ref_stores
, "submodule",
1841 strbuf_release(&submodule_sb
);
1847 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1849 struct ref_store
*refs
;
1853 return get_main_ref_store(the_repository
);
1855 id
= wt
->id
? wt
->id
: "/";
1856 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1861 refs
= ref_store_init(git_common_path("worktrees/%s", wt
->id
),
1862 REF_STORE_ALL_CAPS
);
1864 refs
= ref_store_init(get_git_common_dir(),
1865 REF_STORE_ALL_CAPS
);
1868 register_ref_store_map(&worktree_ref_stores
, "worktree",
1873 void base_ref_store_init(struct ref_store
*refs
,
1874 const struct ref_storage_be
*be
)
1879 /* backend functions */
1880 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
1882 return refs
->be
->pack_refs(refs
, flags
);
1885 int refs_peel_ref(struct ref_store
*refs
, const char *refname
,
1886 struct object_id
*oid
)
1889 struct object_id base
;
1891 if (current_ref_iter
&& current_ref_iter
->refname
== refname
) {
1892 struct object_id peeled
;
1894 if (ref_iterator_peel(current_ref_iter
, &peeled
))
1896 oidcpy(oid
, &peeled
);
1900 if (refs_read_ref_full(refs
, refname
,
1901 RESOLVE_REF_READING
, &base
, &flag
))
1904 return peel_object(&base
, oid
);
1907 int peel_ref(const char *refname
, struct object_id
*oid
)
1909 return refs_peel_ref(get_main_ref_store(the_repository
), refname
, oid
);
1912 int refs_create_symref(struct ref_store
*refs
,
1913 const char *ref_target
,
1914 const char *refs_heads_master
,
1920 msg
= normalize_reflog_message(logmsg
);
1921 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
1927 int create_symref(const char *ref_target
, const char *refs_heads_master
,
1930 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
1931 refs_heads_master
, logmsg
);
1934 int ref_update_reject_duplicates(struct string_list
*refnames
,
1937 size_t i
, n
= refnames
->nr
;
1941 for (i
= 1; i
< n
; i
++) {
1942 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
1943 refnames
->items
[i
].string
);
1947 _("multiple updates for ref '%s' not allowed"),
1948 refnames
->items
[i
].string
);
1950 } else if (cmp
> 0) {
1951 BUG("ref_update_reject_duplicates() received unsorted list");
1957 static int run_transaction_hook(struct ref_transaction
*transaction
,
1960 struct child_process proc
= CHILD_PROCESS_INIT
;
1961 struct strbuf buf
= STRBUF_INIT
;
1965 hook
= find_hook("reference-transaction");
1969 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
1971 proc
.stdout_to_stderr
= 1;
1972 proc
.trace2_hook_name
= "reference-transaction";
1974 ret
= start_command(&proc
);
1978 sigchain_push(SIGPIPE
, SIG_IGN
);
1980 for (i
= 0; i
< transaction
->nr
; i
++) {
1981 struct ref_update
*update
= transaction
->updates
[i
];
1984 strbuf_addf(&buf
, "%s %s %s\n",
1985 oid_to_hex(&update
->old_oid
),
1986 oid_to_hex(&update
->new_oid
),
1989 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
1997 sigchain_pop(SIGPIPE
);
1998 strbuf_release(&buf
);
2000 ret
|= finish_command(&proc
);
2004 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2007 struct ref_store
*refs
= transaction
->ref_store
;
2010 switch (transaction
->state
) {
2011 case REF_TRANSACTION_OPEN
:
2014 case REF_TRANSACTION_PREPARED
:
2015 BUG("prepare called twice on reference transaction");
2017 case REF_TRANSACTION_CLOSED
:
2018 BUG("prepare called on a closed reference transaction");
2021 BUG("unexpected reference transaction state");
2025 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
2027 _("ref updates forbidden inside quarantine environment"));
2031 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2035 ret
= run_transaction_hook(transaction
, "prepared");
2037 ref_transaction_abort(transaction
, err
);
2038 die(_("ref updates aborted by hook"));
2044 int ref_transaction_abort(struct ref_transaction
*transaction
,
2047 struct ref_store
*refs
= transaction
->ref_store
;
2050 switch (transaction
->state
) {
2051 case REF_TRANSACTION_OPEN
:
2052 /* No need to abort explicitly. */
2054 case REF_TRANSACTION_PREPARED
:
2055 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2057 case REF_TRANSACTION_CLOSED
:
2058 BUG("abort called on a closed reference transaction");
2061 BUG("unexpected reference transaction state");
2065 run_transaction_hook(transaction
, "aborted");
2067 ref_transaction_free(transaction
);
2071 int ref_transaction_commit(struct ref_transaction
*transaction
,
2074 struct ref_store
*refs
= transaction
->ref_store
;
2077 switch (transaction
->state
) {
2078 case REF_TRANSACTION_OPEN
:
2079 /* Need to prepare first. */
2080 ret
= ref_transaction_prepare(transaction
, err
);
2084 case REF_TRANSACTION_PREPARED
:
2085 /* Fall through to finish. */
2087 case REF_TRANSACTION_CLOSED
:
2088 BUG("commit called on a closed reference transaction");
2091 BUG("unexpected reference transaction state");
2095 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2097 run_transaction_hook(transaction
, "committed");
2101 int refs_verify_refname_available(struct ref_store
*refs
,
2102 const char *refname
,
2103 const struct string_list
*extras
,
2104 const struct string_list
*skip
,
2108 const char *extra_refname
;
2109 struct strbuf dirname
= STRBUF_INIT
;
2110 struct strbuf referent
= STRBUF_INIT
;
2111 struct object_id oid
;
2113 struct ref_iterator
*iter
;
2118 * For the sake of comments in this function, suppose that
2119 * refname is "refs/foo/bar".
2124 strbuf_grow(&dirname
, strlen(refname
) + 1);
2125 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2126 /* Expand dirname to the new prefix, not including the trailing slash: */
2127 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2130 * We are still at a leading dir of the refname (e.g.,
2131 * "refs/foo"; if there is a reference with that name,
2132 * it is a conflict, *unless* it is in skip.
2134 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2137 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
, &type
)) {
2138 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2139 dirname
.buf
, refname
);
2143 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2144 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2145 refname
, dirname
.buf
);
2151 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2152 * There is no point in searching for a reference with that
2153 * name, because a refname isn't considered to conflict with
2154 * itself. But we still need to check for references whose
2155 * names are in the "refs/foo/bar/" namespace, because they
2158 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2159 strbuf_addch(&dirname
, '/');
2161 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2162 DO_FOR_EACH_INCLUDE_BROKEN
);
2163 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2165 string_list_has_string(skip
, iter
->refname
))
2168 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2169 iter
->refname
, refname
);
2170 ref_iterator_abort(iter
);
2174 if (ok
!= ITER_DONE
)
2175 BUG("error while iterating over references");
2177 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2179 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2180 refname
, extra_refname
);
2185 strbuf_release(&referent
);
2186 strbuf_release(&dirname
);
2190 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2192 struct ref_iterator
*iter
;
2193 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2195 iter
= refs
->be
->reflog_iterator_begin(refs
);
2197 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2198 do_for_each_ref_helper
, &hp
);
2201 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2203 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2206 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2207 const char *refname
,
2208 each_reflog_ent_fn fn
,
2211 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2215 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2218 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2219 refname
, fn
, cb_data
);
2222 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2223 each_reflog_ent_fn fn
, void *cb_data
)
2225 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2228 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2231 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2235 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2237 return refs
->be
->reflog_exists(refs
, refname
);
2240 int reflog_exists(const char *refname
)
2242 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2245 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2246 int force_create
, struct strbuf
*err
)
2248 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2251 int safe_create_reflog(const char *refname
, int force_create
,
2254 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2258 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2260 return refs
->be
->delete_reflog(refs
, refname
);
2263 int delete_reflog(const char *refname
)
2265 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2268 int refs_reflog_expire(struct ref_store
*refs
,
2269 const char *refname
, const struct object_id
*oid
,
2271 reflog_expiry_prepare_fn prepare_fn
,
2272 reflog_expiry_should_prune_fn should_prune_fn
,
2273 reflog_expiry_cleanup_fn cleanup_fn
,
2274 void *policy_cb_data
)
2276 return refs
->be
->reflog_expire(refs
, refname
, oid
, flags
,
2277 prepare_fn
, should_prune_fn
,
2278 cleanup_fn
, policy_cb_data
);
2281 int reflog_expire(const char *refname
, const struct object_id
*oid
,
2283 reflog_expiry_prepare_fn prepare_fn
,
2284 reflog_expiry_should_prune_fn should_prune_fn
,
2285 reflog_expiry_cleanup_fn cleanup_fn
,
2286 void *policy_cb_data
)
2288 return refs_reflog_expire(get_main_ref_store(the_repository
),
2289 refname
, oid
, flags
,
2290 prepare_fn
, should_prune_fn
,
2291 cleanup_fn
, policy_cb_data
);
2294 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2297 struct ref_store
*refs
= transaction
->ref_store
;
2299 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2302 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2303 struct string_list
*refnames
, unsigned int flags
)
2308 msg
= normalize_reflog_message(logmsg
);
2309 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2314 int delete_refs(const char *msg
, struct string_list
*refnames
,
2317 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2320 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2321 const char *newref
, const char *logmsg
)
2326 msg
= normalize_reflog_message(logmsg
);
2327 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2332 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2334 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2337 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2338 const char *newref
, const char *logmsg
)
2343 msg
= normalize_reflog_message(logmsg
);
2344 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2349 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2351 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);