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
))
37 * How to handle various characters in refnames:
38 * 0: An acceptable character for refs
40 * 2: ., look for a preceding . to reject .. in refs
41 * 3: {, look for a preceding @ to reject @{ in refs
42 * 4: A bad character: ASCII control characters, and
43 * ":", "?", "[", "\", "^", "~", SP, or TAB
44 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
46 static unsigned char refname_disposition
[256] = {
47 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
48 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
49 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
50 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
51 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
58 * Try to read one refname component from the front of refname.
59 * Return the length of the component found, or -1 if the component is
60 * not legal. It is legal if it is something reasonable to have under
61 * ".git/refs/"; We do not like it if:
63 * - it begins with ".", or
64 * - it has double dots "..", or
65 * - it has ASCII control characters, or
66 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
67 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
68 * - it ends with a "/", or
69 * - it ends with ".lock", or
70 * - it contains a "@{" portion
72 * When sanitized is not NULL, instead of rejecting the input refname
73 * as an error, try to come up with a usable replacement for the input
76 static int check_refname_component(const char *refname
, int *flags
,
77 struct strbuf
*sanitized
)
81 size_t component_start
= 0; /* garbage - not a reasonable initial value */
84 component_start
= sanitized
->len
;
86 for (cp
= refname
; ; cp
++) {
88 unsigned char disp
= refname_disposition
[ch
];
90 if (sanitized
&& disp
!= 1)
91 strbuf_addch(sanitized
, ch
);
97 if (last
== '.') { /* Refname contains "..". */
99 /* collapse ".." to single "." */
100 strbuf_setlen(sanitized
, sanitized
->len
- 1);
106 if (last
== '@') { /* Refname contains "@{". */
108 sanitized
->buf
[sanitized
->len
-1] = '-';
116 sanitized
->buf
[sanitized
->len
-1] = '-';
121 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
122 /* refspec can't be a pattern */
124 sanitized
->buf
[sanitized
->len
-1] = '-';
130 * Unset the pattern flag so that we only accept
131 * a single asterisk for one side of refspec.
133 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
140 return 0; /* Component has zero length. */
142 if (refname
[0] == '.') { /* Component starts with '.'. */
144 sanitized
->buf
[component_start
] = '-';
148 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
149 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
152 /* Refname ends with ".lock". */
153 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
154 /* try again in case we have .lock.lock */
160 static int check_or_sanitize_refname(const char *refname
, int flags
,
161 struct strbuf
*sanitized
)
163 int component_len
, component_count
= 0;
165 if (!strcmp(refname
, "@")) {
166 /* Refname is a single character '@'. */
168 strbuf_addch(sanitized
, '-');
174 if (sanitized
&& sanitized
->len
)
175 strbuf_complete(sanitized
, '/');
177 /* We are at the start of a path component. */
178 component_len
= check_refname_component(refname
, &flags
,
180 if (sanitized
&& component_len
== 0)
181 ; /* OK, omit empty component */
182 else if (component_len
<= 0)
186 if (refname
[component_len
] == '\0')
188 /* Skip to next component. */
189 refname
+= component_len
+ 1;
192 if (refname
[component_len
- 1] == '.') {
193 /* Refname ends with '.'. */
195 ; /* omit ending dot */
199 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
200 return -1; /* Refname has only one component. */
204 int check_refname_format(const char *refname
, int flags
)
206 return check_or_sanitize_refname(refname
, flags
, NULL
);
209 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
211 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
212 BUG("sanitizing refname '%s' check returned error", refname
);
215 int refname_is_safe(const char *refname
)
219 if (skip_prefix(refname
, "refs/", &rest
)) {
222 size_t restlen
= strlen(rest
);
224 /* rest must not be empty, or start or end with "/" */
225 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
229 * Does the refname try to escape refs/?
230 * For example: refs/foo/../bar is safe but refs/foo/../../bar
233 buf
= xmallocz(restlen
);
234 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
240 if (!isupper(*refname
) && *refname
!= '_')
248 * Return true if refname, which has the specified oid and flags, can
249 * be resolved to an object in the database. If the referred-to object
250 * does not exist, emit a warning and return false.
252 int ref_resolves_to_object(const char *refname
,
253 const struct object_id
*oid
,
256 if (flags
& REF_ISBROKEN
)
258 if (!has_object_file(oid
)) {
259 error(_("%s does not point to a valid object!"), refname
);
265 char *refs_resolve_refdup(struct ref_store
*refs
,
266 const char *refname
, int resolve_flags
,
267 struct object_id
*oid
, int *flags
)
271 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
273 return xstrdup_or_null(result
);
276 char *resolve_refdup(const char *refname
, int resolve_flags
,
277 struct object_id
*oid
, int *flags
)
279 return refs_resolve_refdup(get_main_ref_store(the_repository
),
280 refname
, resolve_flags
,
284 /* The argument to filter_refs */
292 int refs_read_ref_full(struct ref_store
*refs
, const char *refname
,
293 int resolve_flags
, struct object_id
*oid
, int *flags
)
295 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
, oid
, flags
))
300 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
302 return refs_read_ref_full(get_main_ref_store(the_repository
), refname
,
303 resolve_flags
, oid
, flags
);
306 int read_ref(const char *refname
, struct object_id
*oid
)
308 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
311 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
313 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
, NULL
, NULL
);
316 int ref_exists(const char *refname
)
318 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
321 static int filter_refs(const char *refname
, const struct object_id
*oid
,
322 int flags
, void *data
)
324 struct ref_filter
*filter
= (struct ref_filter
*)data
;
326 if (wildmatch(filter
->pattern
, refname
, 0))
329 skip_prefix(refname
, filter
->prefix
, &refname
);
330 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
333 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
335 struct object
*o
= lookup_unknown_object(the_repository
, name
);
337 if (o
->type
== OBJ_NONE
) {
338 int type
= oid_object_info(the_repository
, name
, NULL
);
339 if (type
< 0 || !object_as_type(o
, type
, 0))
343 if (o
->type
!= OBJ_TAG
)
346 o
= deref_tag_noverify(o
);
350 oidcpy(oid
, &o
->oid
);
354 struct warn_if_dangling_data
{
357 const struct string_list
*refnames
;
361 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
362 int flags
, void *cb_data
)
364 struct warn_if_dangling_data
*d
= cb_data
;
365 const char *resolves_to
;
367 if (!(flags
& REF_ISSYMREF
))
370 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
373 ? strcmp(resolves_to
, d
->refname
)
374 : !string_list_has_string(d
->refnames
, resolves_to
))) {
378 fprintf(d
->fp
, d
->msg_fmt
, refname
);
383 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
385 struct warn_if_dangling_data data
;
388 data
.refname
= refname
;
389 data
.refnames
= NULL
;
390 data
.msg_fmt
= msg_fmt
;
391 for_each_rawref(warn_if_dangling_symref
, &data
);
394 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
396 struct warn_if_dangling_data data
;
400 data
.refnames
= refnames
;
401 data
.msg_fmt
= msg_fmt
;
402 for_each_rawref(warn_if_dangling_symref
, &data
);
405 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
407 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
410 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
412 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
415 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
417 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
420 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
422 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
425 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
427 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
430 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
432 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
435 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
437 struct strbuf buf
= STRBUF_INIT
;
439 struct object_id oid
;
442 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
443 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
444 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
445 strbuf_release(&buf
);
450 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
453 struct strbuf normalized_pattern
= STRBUF_INIT
;
456 BUG("pattern must not start with '/'");
459 strbuf_addstr(&normalized_pattern
, prefix
);
461 else if (!starts_with(pattern
, "refs/"))
462 strbuf_addstr(&normalized_pattern
, "refs/");
463 strbuf_addstr(&normalized_pattern
, pattern
);
464 strbuf_strip_suffix(&normalized_pattern
, "/");
466 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
467 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
468 strbuf_release(&normalized_pattern
);
471 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
472 const char *prefix
, void *cb_data
)
474 struct strbuf real_pattern
= STRBUF_INIT
;
475 struct ref_filter filter
;
478 if (!prefix
&& !starts_with(pattern
, "refs/"))
479 strbuf_addstr(&real_pattern
, "refs/");
481 strbuf_addstr(&real_pattern
, prefix
);
482 strbuf_addstr(&real_pattern
, pattern
);
484 if (!has_glob_specials(pattern
)) {
485 /* Append implied '/' '*' if not present. */
486 strbuf_complete(&real_pattern
, '/');
487 /* No need to check for '*', there is none. */
488 strbuf_addch(&real_pattern
, '*');
491 filter
.pattern
= real_pattern
.buf
;
492 filter
.prefix
= prefix
;
494 filter
.cb_data
= cb_data
;
495 ret
= for_each_ref(filter_refs
, &filter
);
497 strbuf_release(&real_pattern
);
501 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
503 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
506 const char *prettify_refname(const char *name
)
508 if (skip_prefix(name
, "refs/heads/", &name
) ||
509 skip_prefix(name
, "refs/tags/", &name
) ||
510 skip_prefix(name
, "refs/remotes/", &name
))
515 static const char *ref_rev_parse_rules
[] = {
521 "refs/remotes/%.*s/HEAD",
525 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
528 * Is it possible that the caller meant full_name with abbrev_name?
529 * If so return a non-zero value to signal "yes"; the magnitude of
530 * the returned value gives the precedence used for disambiguation.
532 * If abbrev_name cannot mean full_name, return 0.
534 int refname_match(const char *abbrev_name
, const char *full_name
)
537 const int abbrev_name_len
= strlen(abbrev_name
);
538 const int num_rules
= NUM_REV_PARSE_RULES
;
540 for (p
= ref_rev_parse_rules
; *p
; p
++)
541 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
542 return &ref_rev_parse_rules
[num_rules
] - p
;
548 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
549 * the results to 'prefixes'
551 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
554 int len
= strlen(prefix
);
556 for (p
= ref_rev_parse_rules
; *p
; p
++)
557 strvec_pushf(prefixes
, *p
, len
, prefix
);
560 static const char default_branch_name_advice
[] = N_(
561 "Using '%s' as the name for the initial branch. This default branch name\n"
562 "is subject to change. To configure the initial branch name to use in all\n"
563 "of your new repositories, which will suppress this warning, call:\n"
565 "\tgit config --global init.defaultBranch <name>\n"
567 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
568 "'development'. The just-created branch can be renamed via this command:\n"
570 "\tgit branch -m <name>\n"
573 char *repo_default_branch_name(struct repository
*r
, int quiet
)
575 const char *config_key
= "init.defaultbranch";
576 const char *config_display_key
= "init.defaultBranch";
577 char *ret
= NULL
, *full_ref
;
578 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
582 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
583 die(_("could not retrieve `%s`"), config_display_key
);
586 ret
= xstrdup("master");
588 advise(_(default_branch_name_advice
), ret
);
591 full_ref
= xstrfmt("refs/heads/%s", ret
);
592 if (check_refname_format(full_ref
, 0))
593 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
599 const char *git_default_branch_name(int quiet
)
604 ret
= repo_default_branch_name(the_repository
, quiet
);
610 * *string and *len will only be substituted, and *string returned (for
611 * later free()ing) if the string passed in is a magic short-hand form
614 static char *substitute_branch_name(struct repository
*r
,
615 const char **string
, int *len
,
616 int nonfatal_dangling_mark
)
618 struct strbuf buf
= STRBUF_INIT
;
619 struct interpret_branch_name_options options
= {
620 .nonfatal_dangling_mark
= nonfatal_dangling_mark
622 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
626 *string
= strbuf_detach(&buf
, &size
);
628 return (char *)*string
;
634 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
635 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
637 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
638 nonfatal_dangling_mark
);
639 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
644 int expand_ref(struct repository
*repo
, const char *str
, int len
,
645 struct object_id
*oid
, char **ref
)
649 struct strbuf fullref
= STRBUF_INIT
;
652 for (p
= ref_rev_parse_rules
; *p
; p
++) {
653 struct object_id oid_from_ref
;
654 struct object_id
*this_result
;
657 this_result
= refs_found
? &oid_from_ref
: oid
;
658 strbuf_reset(&fullref
);
659 strbuf_addf(&fullref
, *p
, len
, str
);
660 r
= refs_resolve_ref_unsafe(get_main_ref_store(repo
),
661 fullref
.buf
, RESOLVE_REF_READING
,
666 if (!warn_ambiguous_refs
)
668 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
669 warning(_("ignoring dangling symref %s"), fullref
.buf
);
670 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
671 warning(_("ignoring broken ref %s"), fullref
.buf
);
674 strbuf_release(&fullref
);
678 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
679 struct object_id
*oid
, char **log
)
681 struct ref_store
*refs
= get_main_ref_store(r
);
682 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
685 struct strbuf path
= STRBUF_INIT
;
688 for (p
= ref_rev_parse_rules
; *p
; p
++) {
689 struct object_id hash
;
690 const char *ref
, *it
;
693 strbuf_addf(&path
, *p
, len
, str
);
694 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
696 oid
? &hash
: NULL
, NULL
);
699 if (refs_reflog_exists(refs
, path
.buf
))
701 else if (strcmp(ref
, path
.buf
) &&
702 refs_reflog_exists(refs
, ref
))
711 if (!warn_ambiguous_refs
)
714 strbuf_release(&path
);
719 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
721 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
724 static int is_per_worktree_ref(const char *refname
)
726 return starts_with(refname
, "refs/worktree/") ||
727 starts_with(refname
, "refs/bisect/") ||
728 starts_with(refname
, "refs/rewritten/");
731 static int is_pseudoref_syntax(const char *refname
)
735 for (c
= refname
; *c
; c
++) {
736 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
743 static int is_main_pseudoref_syntax(const char *refname
)
745 return skip_prefix(refname
, "main-worktree/", &refname
) &&
747 is_pseudoref_syntax(refname
);
750 static int is_other_pseudoref_syntax(const char *refname
)
752 if (!skip_prefix(refname
, "worktrees/", &refname
))
754 refname
= strchr(refname
, '/');
755 if (!refname
|| !refname
[1])
757 return is_pseudoref_syntax(refname
+ 1);
760 enum ref_type
ref_type(const char *refname
)
762 if (is_per_worktree_ref(refname
))
763 return REF_TYPE_PER_WORKTREE
;
764 if (is_pseudoref_syntax(refname
))
765 return REF_TYPE_PSEUDOREF
;
766 if (is_main_pseudoref_syntax(refname
))
767 return REF_TYPE_MAIN_PSEUDOREF
;
768 if (is_other_pseudoref_syntax(refname
))
769 return REF_TYPE_OTHER_PSEUDOREF
;
770 return REF_TYPE_NORMAL
;
773 long get_files_ref_lock_timeout_ms(void)
775 static int configured
= 0;
777 /* The default timeout is 100 ms: */
778 static int timeout_ms
= 100;
781 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
788 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
790 const struct object_id
*old_oid
,
793 struct ref_transaction
*transaction
;
794 struct strbuf err
= STRBUF_INIT
;
796 transaction
= ref_store_transaction_begin(refs
, &err
);
798 ref_transaction_delete(transaction
, refname
, old_oid
,
800 ref_transaction_commit(transaction
, &err
)) {
801 error("%s", err
.buf
);
802 ref_transaction_free(transaction
);
803 strbuf_release(&err
);
806 ref_transaction_free(transaction
);
807 strbuf_release(&err
);
811 int delete_ref(const char *msg
, const char *refname
,
812 const struct object_id
*old_oid
, unsigned int flags
)
814 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
818 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
823 while ((c
= *msg
++)) {
824 if (wasspace
&& isspace(c
))
826 wasspace
= isspace(c
);
834 static char *normalize_reflog_message(const char *msg
)
836 struct strbuf sb
= STRBUF_INIT
;
839 copy_reflog_msg(&sb
, msg
);
840 return strbuf_detach(&sb
, NULL
);
843 int should_autocreate_reflog(const char *refname
)
845 switch (log_all_ref_updates
) {
846 case LOG_REFS_ALWAYS
:
848 case LOG_REFS_NORMAL
:
849 return starts_with(refname
, "refs/heads/") ||
850 starts_with(refname
, "refs/remotes/") ||
851 starts_with(refname
, "refs/notes/") ||
852 !strcmp(refname
, "HEAD");
858 int is_branch(const char *refname
)
860 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
863 struct read_ref_at_cb
{
868 struct object_id
*oid
;
871 struct object_id ooid
;
872 struct object_id noid
;
876 timestamp_t
*cutoff_time
;
881 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
882 timestamp_t timestamp
, int tz
, const char *message
)
885 *cb
->msg
= xstrdup(message
);
887 *cb
->cutoff_time
= timestamp
;
891 *cb
->cutoff_cnt
= cb
->reccnt
;
894 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
895 const char *email
, timestamp_t timestamp
, int tz
,
896 const char *message
, void *cb_data
)
898 struct read_ref_at_cb
*cb
= cb_data
;
902 cb
->date
= timestamp
;
905 * It is not possible for cb->cnt == 0 on the first iteration because
906 * that special case is handled in read_ref_at().
910 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
911 if (timestamp
<= cb
->at_time
|| reached_count
) {
912 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
914 * we have not yet updated cb->[n|o]oid so they still
915 * hold the values for the previous record.
917 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
918 warning(_("log for ref %s has gap after %s"),
919 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
921 oidcpy(cb
->oid
, ooid
);
922 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
923 oidcpy(cb
->oid
, noid
);
924 else if (!oideq(noid
, cb
->oid
))
925 warning(_("log for ref %s unexpectedly ended on %s"),
926 cb
->refname
, show_date(cb
->date
, cb
->tz
,
927 DATE_MODE(RFC2822
)));
931 oidcpy(&cb
->ooid
, ooid
);
932 oidcpy(&cb
->noid
, noid
);
936 static int read_ref_at_ent_newest(struct object_id
*ooid
, struct object_id
*noid
,
937 const char *email
, timestamp_t timestamp
,
938 int tz
, const char *message
, void *cb_data
)
940 struct read_ref_at_cb
*cb
= cb_data
;
942 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
943 oidcpy(cb
->oid
, noid
);
944 /* We just want the first entry */
948 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
949 const char *email
, timestamp_t timestamp
,
950 int tz
, const char *message
, void *cb_data
)
952 struct read_ref_at_cb
*cb
= cb_data
;
954 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
955 oidcpy(cb
->oid
, ooid
);
956 if (is_null_oid(cb
->oid
))
957 oidcpy(cb
->oid
, noid
);
958 /* We just want the first entry */
962 int read_ref_at(struct ref_store
*refs
, const char *refname
,
963 unsigned int flags
, timestamp_t at_time
, int cnt
,
964 struct object_id
*oid
, char **msg
,
965 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
967 struct read_ref_at_cb cb
;
969 memset(&cb
, 0, sizeof(cb
));
970 cb
.refname
= refname
;
971 cb
.at_time
= at_time
;
974 cb
.cutoff_time
= cutoff_time
;
975 cb
.cutoff_tz
= cutoff_tz
;
976 cb
.cutoff_cnt
= cutoff_cnt
;
980 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
984 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
987 if (flags
& GET_OID_QUIETLY
)
990 die(_("log for %s is empty"), refname
);
995 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1000 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1003 struct ref_transaction
*tr
;
1006 CALLOC_ARRAY(tr
, 1);
1007 tr
->ref_store
= refs
;
1011 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1013 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1016 void ref_transaction_free(struct ref_transaction
*transaction
)
1023 switch (transaction
->state
) {
1024 case REF_TRANSACTION_OPEN
:
1025 case REF_TRANSACTION_CLOSED
:
1028 case REF_TRANSACTION_PREPARED
:
1029 BUG("free called on a prepared reference transaction");
1032 BUG("unexpected reference transaction state");
1036 for (i
= 0; i
< transaction
->nr
; i
++) {
1037 free(transaction
->updates
[i
]->msg
);
1038 free(transaction
->updates
[i
]);
1040 free(transaction
->updates
);
1044 struct ref_update
*ref_transaction_add_update(
1045 struct ref_transaction
*transaction
,
1046 const char *refname
, unsigned int flags
,
1047 const struct object_id
*new_oid
,
1048 const struct object_id
*old_oid
,
1051 struct ref_update
*update
;
1053 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1054 BUG("update called for transaction that is not open");
1056 FLEX_ALLOC_STR(update
, refname
, refname
);
1057 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1058 transaction
->updates
[transaction
->nr
++] = update
;
1060 update
->flags
= flags
;
1062 if (flags
& REF_HAVE_NEW
)
1063 oidcpy(&update
->new_oid
, new_oid
);
1064 if (flags
& REF_HAVE_OLD
)
1065 oidcpy(&update
->old_oid
, old_oid
);
1066 update
->msg
= normalize_reflog_message(msg
);
1070 int ref_transaction_update(struct ref_transaction
*transaction
,
1071 const char *refname
,
1072 const struct object_id
*new_oid
,
1073 const struct object_id
*old_oid
,
1074 unsigned int flags
, const char *msg
,
1079 if ((new_oid
&& !is_null_oid(new_oid
)) ?
1080 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1081 !refname_is_safe(refname
)) {
1082 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1087 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1088 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1090 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1092 ref_transaction_add_update(transaction
, refname
, flags
,
1093 new_oid
, old_oid
, msg
);
1097 int ref_transaction_create(struct ref_transaction
*transaction
,
1098 const char *refname
,
1099 const struct object_id
*new_oid
,
1100 unsigned int flags
, const char *msg
,
1103 if (!new_oid
|| is_null_oid(new_oid
))
1104 BUG("create called without valid new_oid");
1105 return ref_transaction_update(transaction
, refname
, new_oid
,
1106 null_oid(), flags
, msg
, err
);
1109 int ref_transaction_delete(struct ref_transaction
*transaction
,
1110 const char *refname
,
1111 const struct object_id
*old_oid
,
1112 unsigned int flags
, const char *msg
,
1115 if (old_oid
&& is_null_oid(old_oid
))
1116 BUG("delete called with old_oid set to zeros");
1117 return ref_transaction_update(transaction
, refname
,
1118 null_oid(), old_oid
,
1122 int ref_transaction_verify(struct ref_transaction
*transaction
,
1123 const char *refname
,
1124 const struct object_id
*old_oid
,
1129 BUG("verify called with old_oid set to NULL");
1130 return ref_transaction_update(transaction
, refname
,
1135 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1136 const char *refname
, const struct object_id
*new_oid
,
1137 const struct object_id
*old_oid
, unsigned int flags
,
1138 enum action_on_err onerr
)
1140 struct ref_transaction
*t
= NULL
;
1141 struct strbuf err
= STRBUF_INIT
;
1144 t
= ref_store_transaction_begin(refs
, &err
);
1146 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1148 ref_transaction_commit(t
, &err
)) {
1150 ref_transaction_free(t
);
1153 const char *str
= _("update_ref failed for ref '%s': %s");
1156 case UPDATE_REFS_MSG_ON_ERR
:
1157 error(str
, refname
, err
.buf
);
1159 case UPDATE_REFS_DIE_ON_ERR
:
1160 die(str
, refname
, err
.buf
);
1162 case UPDATE_REFS_QUIET_ON_ERR
:
1165 strbuf_release(&err
);
1168 strbuf_release(&err
);
1170 ref_transaction_free(t
);
1174 int update_ref(const char *msg
, const char *refname
,
1175 const struct object_id
*new_oid
,
1176 const struct object_id
*old_oid
,
1177 unsigned int flags
, enum action_on_err onerr
)
1179 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1180 old_oid
, flags
, onerr
);
1183 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1184 const char *refname
, int strict
)
1187 static char **scanf_fmts
;
1188 static int nr_rules
;
1190 struct strbuf resolved_buf
= STRBUF_INIT
;
1194 * Pre-generate scanf formats from ref_rev_parse_rules[].
1195 * Generate a format suitable for scanf from a
1196 * ref_rev_parse_rules rule by interpolating "%s" at the
1197 * location of the "%.*s".
1199 size_t total_len
= 0;
1202 /* the rule list is NULL terminated, count them first */
1203 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1204 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1205 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1207 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1210 for (i
= 0; i
< nr_rules
; i
++) {
1211 assert(offset
< total_len
);
1212 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1213 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1214 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1218 /* bail out if there are no rules */
1220 return xstrdup(refname
);
1222 /* buffer for scanf result, at most refname must fit */
1223 short_name
= xstrdup(refname
);
1225 /* skip first rule, it will always match */
1226 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1228 int rules_to_fail
= i
;
1231 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1234 short_name_len
= strlen(short_name
);
1237 * in strict mode, all (except the matched one) rules
1238 * must fail to resolve to a valid non-ambiguous ref
1241 rules_to_fail
= nr_rules
;
1244 * check if the short name resolves to a valid ref,
1245 * but use only rules prior to the matched one
1247 for (j
= 0; j
< rules_to_fail
; j
++) {
1248 const char *rule
= ref_rev_parse_rules
[j
];
1250 /* skip matched rule */
1255 * the short name is ambiguous, if it resolves
1256 * (with this previous rule) to a valid ref
1257 * read_ref() returns 0 on success
1259 strbuf_reset(&resolved_buf
);
1260 strbuf_addf(&resolved_buf
, rule
,
1261 short_name_len
, short_name
);
1262 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1267 * short name is non-ambiguous if all previous rules
1268 * haven't resolved to a valid ref
1270 if (j
== rules_to_fail
) {
1271 strbuf_release(&resolved_buf
);
1276 strbuf_release(&resolved_buf
);
1278 return xstrdup(refname
);
1281 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1283 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1287 static struct string_list
*hide_refs
;
1289 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1292 if (!strcmp("transfer.hiderefs", var
) ||
1293 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1294 !strcmp(key
, "hiderefs"))) {
1299 return config_error_nonbool(var
);
1300 ref
= xstrdup(value
);
1302 while (len
&& ref
[len
- 1] == '/')
1305 CALLOC_ARRAY(hide_refs
, 1);
1306 hide_refs
->strdup_strings
= 1;
1308 string_list_append(hide_refs
, ref
);
1313 int ref_is_hidden(const char *refname
, const char *refname_full
)
1319 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1320 const char *match
= hide_refs
->items
[i
].string
;
1321 const char *subject
;
1325 if (*match
== '!') {
1330 if (*match
== '^') {
1331 subject
= refname_full
;
1337 /* refname can be NULL when namespaces are used. */
1339 skip_prefix(subject
, match
, &p
) &&
1346 const char *find_descendant_ref(const char *dirname
,
1347 const struct string_list
*extras
,
1348 const struct string_list
*skip
)
1356 * Look at the place where dirname would be inserted into
1357 * extras. If there is an entry at that position that starts
1358 * with dirname (remember, dirname includes the trailing
1359 * slash) and is not in skip, then we have a conflict.
1361 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1362 pos
< extras
->nr
; pos
++) {
1363 const char *extra_refname
= extras
->items
[pos
].string
;
1365 if (!starts_with(extra_refname
, dirname
))
1368 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1369 return extra_refname
;
1374 int refs_rename_ref_available(struct ref_store
*refs
,
1375 const char *old_refname
,
1376 const char *new_refname
)
1378 struct string_list skip
= STRING_LIST_INIT_NODUP
;
1379 struct strbuf err
= STRBUF_INIT
;
1382 string_list_insert(&skip
, old_refname
);
1383 ok
= !refs_verify_refname_available(refs
, new_refname
,
1386 error("%s", err
.buf
);
1388 string_list_clear(&skip
, 0);
1389 strbuf_release(&err
);
1393 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1395 struct object_id oid
;
1398 if (!refs_read_ref_full(refs
, "HEAD", RESOLVE_REF_READING
,
1400 return fn("HEAD", &oid
, flag
, cb_data
);
1405 int head_ref(each_ref_fn fn
, void *cb_data
)
1407 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1410 struct ref_iterator
*refs_ref_iterator_begin(
1411 struct ref_store
*refs
,
1412 const char *prefix
, int trim
,
1413 enum do_for_each_ref_flags flags
)
1415 struct ref_iterator
*iter
;
1417 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1418 static int ref_paranoia
= -1;
1420 if (ref_paranoia
< 0)
1421 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1423 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1424 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1428 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1431 * `iterator_begin()` already takes care of prefix, but we
1432 * might need to do some trimming:
1435 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1437 /* Sanity check for subclasses: */
1439 BUG("reference iterator is not ordered");
1445 * Call fn for each reference in the specified submodule for which the
1446 * refname begins with prefix. If trim is non-zero, then trim that
1447 * many characters off the beginning of each refname before passing
1448 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1449 * include broken references in the iteration. If fn ever returns a
1450 * non-zero value, stop the iteration and return that value;
1451 * otherwise, return 0.
1453 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1454 each_repo_ref_fn fn
, int trim
, int flags
,
1457 struct ref_iterator
*iter
;
1458 struct ref_store
*refs
= get_main_ref_store(r
);
1463 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1465 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1468 struct do_for_each_ref_help
{
1473 static int do_for_each_ref_helper(struct repository
*r
,
1474 const char *refname
,
1475 const struct object_id
*oid
,
1479 struct do_for_each_ref_help
*hp
= cb_data
;
1481 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1484 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1485 each_ref_fn fn
, int trim
,
1486 enum do_for_each_ref_flags flags
, void *cb_data
)
1488 struct ref_iterator
*iter
;
1489 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1494 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1496 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1497 do_for_each_ref_helper
, &hp
);
1500 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1502 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1505 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1507 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1510 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1511 each_ref_fn fn
, void *cb_data
)
1513 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1516 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1518 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1521 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1523 return do_for_each_ref(get_main_ref_store(the_repository
),
1524 prefix
, fn
, 0, 0, cb_data
);
1527 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1528 each_ref_fn fn
, void *cb_data
)
1530 return do_for_each_ref(refs
, prefix
, fn
, 0, 0, cb_data
);
1533 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1535 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1536 strlen(git_replace_ref_base
),
1537 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1540 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1542 struct strbuf buf
= STRBUF_INIT
;
1544 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1545 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1546 buf
.buf
, fn
, 0, 0, cb_data
);
1547 strbuf_release(&buf
);
1551 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1553 return do_for_each_ref(refs
, "", fn
, 0,
1554 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1557 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1559 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1562 static int qsort_strcmp(const void *va
, const void *vb
)
1564 const char *a
= *(const char **)va
;
1565 const char *b
= *(const char **)vb
;
1567 return strcmp(a
, b
);
1570 static void find_longest_prefixes_1(struct string_list
*out
,
1571 struct strbuf
*prefix
,
1572 const char **patterns
, size_t nr
)
1576 for (i
= 0; i
< nr
; i
++) {
1577 char c
= patterns
[i
][prefix
->len
];
1578 if (!c
|| is_glob_special(c
)) {
1579 string_list_append(out
, prefix
->buf
);
1589 * Set "end" to the index of the element _after_ the last one
1592 for (end
= i
+ 1; end
< nr
; end
++) {
1593 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1597 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1598 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1599 strbuf_setlen(prefix
, prefix
->len
- 1);
1605 static void find_longest_prefixes(struct string_list
*out
,
1606 const char **patterns
)
1608 struct strvec sorted
= STRVEC_INIT
;
1609 struct strbuf prefix
= STRBUF_INIT
;
1611 strvec_pushv(&sorted
, patterns
);
1612 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1614 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1616 strvec_clear(&sorted
);
1617 strbuf_release(&prefix
);
1620 int for_each_fullref_in_prefixes(const char *namespace,
1621 const char **patterns
,
1622 each_ref_fn fn
, void *cb_data
)
1624 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1625 struct string_list_item
*prefix
;
1626 struct strbuf buf
= STRBUF_INIT
;
1627 int ret
= 0, namespace_len
;
1629 find_longest_prefixes(&prefixes
, patterns
);
1632 strbuf_addstr(&buf
, namespace);
1633 namespace_len
= buf
.len
;
1635 for_each_string_list_item(prefix
, &prefixes
) {
1636 strbuf_addstr(&buf
, prefix
->string
);
1637 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
);
1640 strbuf_setlen(&buf
, namespace_len
);
1643 string_list_clear(&prefixes
, 0);
1644 strbuf_release(&buf
);
1648 static int refs_read_special_head(struct ref_store
*ref_store
,
1649 const char *refname
, struct object_id
*oid
,
1650 struct strbuf
*referent
, unsigned int *type
)
1652 struct strbuf full_path
= STRBUF_INIT
;
1653 struct strbuf content
= STRBUF_INIT
;
1655 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1657 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1660 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
);
1663 strbuf_release(&full_path
);
1664 strbuf_release(&content
);
1668 int refs_read_raw_ref(struct ref_store
*ref_store
,
1669 const char *refname
, struct object_id
*oid
,
1670 struct strbuf
*referent
, unsigned int *type
)
1672 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1673 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1677 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1681 /* This function needs to return a meaningful errno on failure */
1682 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1683 const char *refname
,
1685 struct object_id
*oid
, int *flags
)
1687 static struct strbuf sb_refname
= STRBUF_INIT
;
1688 struct object_id unused_oid
;
1695 flags
= &unused_flags
;
1699 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1700 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1701 !refname_is_safe(refname
)) {
1707 * dwim_ref() uses REF_ISBROKEN to distinguish between
1708 * missing refs and refs that were present but invalid,
1709 * to complain about the latter to stderr.
1711 * We don't know whether the ref exists, so don't set
1714 *flags
|= REF_BAD_NAME
;
1717 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1718 unsigned int read_flags
= 0;
1720 if (refs_read_raw_ref(refs
, refname
,
1721 oid
, &sb_refname
, &read_flags
)) {
1722 *flags
|= read_flags
;
1724 /* In reading mode, refs must eventually resolve */
1725 if (resolve_flags
& RESOLVE_REF_READING
)
1729 * Otherwise a missing ref is OK. But the files backend
1730 * may show errors besides ENOENT if there are
1731 * similarly-named refs.
1733 if (errno
!= ENOENT
&&
1739 if (*flags
& REF_BAD_NAME
)
1740 *flags
|= REF_ISBROKEN
;
1744 *flags
|= read_flags
;
1746 if (!(read_flags
& REF_ISSYMREF
)) {
1747 if (*flags
& REF_BAD_NAME
) {
1749 *flags
|= REF_ISBROKEN
;
1754 refname
= sb_refname
.buf
;
1755 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1759 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1760 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1761 !refname_is_safe(refname
)) {
1766 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1774 /* backend functions */
1775 int refs_init_db(struct strbuf
*err
)
1777 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1779 return refs
->be
->init_db(refs
, err
);
1782 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1783 struct object_id
*oid
, int *flags
)
1785 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1786 resolve_flags
, oid
, flags
);
1789 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1790 struct object_id
*oid
)
1792 struct ref_store
*refs
;
1795 refs
= get_submodule_ref_store(submodule
);
1800 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1806 struct ref_store_hash_entry
1808 struct hashmap_entry ent
;
1810 struct ref_store
*refs
;
1812 /* NUL-terminated identifier of the ref store: */
1813 char name
[FLEX_ARRAY
];
1816 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1817 const struct hashmap_entry
*eptr
,
1818 const struct hashmap_entry
*entry_or_key
,
1819 const void *keydata
)
1821 const struct ref_store_hash_entry
*e1
, *e2
;
1824 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1825 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1826 name
= keydata
? keydata
: e2
->name
;
1828 return strcmp(e1
->name
, name
);
1831 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1832 const char *name
, struct ref_store
*refs
)
1834 struct ref_store_hash_entry
*entry
;
1836 FLEX_ALLOC_STR(entry
, name
, name
);
1837 hashmap_entry_init(&entry
->ent
, strhash(name
));
1842 /* A hashmap of ref_stores, stored by submodule name: */
1843 static struct hashmap submodule_ref_stores
;
1845 /* A hashmap of ref_stores, stored by worktree id: */
1846 static struct hashmap worktree_ref_stores
;
1849 * Look up a ref store by name. If that ref_store hasn't been
1850 * registered yet, return NULL.
1852 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1855 struct ref_store_hash_entry
*entry
;
1858 if (!map
->tablesize
)
1859 /* It's initialized on demand in register_ref_store(). */
1862 hash
= strhash(name
);
1863 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1864 struct ref_store_hash_entry
, ent
);
1865 return entry
? entry
->refs
: NULL
;
1869 * Create, record, and return a ref_store instance for the specified
1872 static struct ref_store
*ref_store_init(const char *gitdir
,
1875 const char *be_name
= "files";
1876 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1877 struct ref_store
*refs
;
1880 BUG("reference backend %s is unknown", be_name
);
1882 refs
= be
->init(gitdir
, flags
);
1886 struct ref_store
*get_main_ref_store(struct repository
*r
)
1888 if (r
->refs_private
)
1889 return r
->refs_private
;
1892 BUG("attempting to get main_ref_store outside of repository");
1894 r
->refs_private
= ref_store_init(r
->gitdir
, REF_STORE_ALL_CAPS
);
1895 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1896 return r
->refs_private
;
1900 * Associate a ref store with a name. It is a fatal error to call this
1901 * function twice for the same name.
1903 static void register_ref_store_map(struct hashmap
*map
,
1905 struct ref_store
*refs
,
1908 struct ref_store_hash_entry
*entry
;
1910 if (!map
->tablesize
)
1911 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1913 entry
= alloc_ref_store_hash_entry(name
, refs
);
1914 if (hashmap_put(map
, &entry
->ent
))
1915 BUG("%s ref_store '%s' initialized twice", type
, name
);
1918 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1920 struct strbuf submodule_sb
= STRBUF_INIT
;
1921 struct ref_store
*refs
;
1922 char *to_free
= NULL
;
1928 len
= strlen(submodule
);
1929 while (len
&& is_dir_sep(submodule
[len
- 1]))
1935 /* We need to strip off one or more trailing slashes */
1936 submodule
= to_free
= xmemdupz(submodule
, len
);
1938 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1942 strbuf_addstr(&submodule_sb
, submodule
);
1943 if (!is_nonbare_repository_dir(&submodule_sb
))
1946 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1949 /* assume that add_submodule_odb() has been called */
1950 refs
= ref_store_init(submodule_sb
.buf
,
1951 REF_STORE_READ
| REF_STORE_ODB
);
1952 register_ref_store_map(&submodule_ref_stores
, "submodule",
1956 strbuf_release(&submodule_sb
);
1962 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1964 struct ref_store
*refs
;
1968 return get_main_ref_store(the_repository
);
1970 id
= wt
->id
? wt
->id
: "/";
1971 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1976 refs
= ref_store_init(git_common_path("worktrees/%s", wt
->id
),
1977 REF_STORE_ALL_CAPS
);
1979 refs
= ref_store_init(get_git_common_dir(),
1980 REF_STORE_ALL_CAPS
);
1983 register_ref_store_map(&worktree_ref_stores
, "worktree",
1988 void base_ref_store_init(struct ref_store
*refs
,
1989 const struct ref_storage_be
*be
)
1994 /* backend functions */
1995 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
1997 return refs
->be
->pack_refs(refs
, flags
);
2000 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2002 if (current_ref_iter
&&
2003 (current_ref_iter
->oid
== base
||
2004 oideq(current_ref_iter
->oid
, base
)))
2005 return ref_iterator_peel(current_ref_iter
, peeled
);
2007 return peel_object(base
, peeled
) ? -1 : 0;
2010 int refs_create_symref(struct ref_store
*refs
,
2011 const char *ref_target
,
2012 const char *refs_heads_master
,
2018 msg
= normalize_reflog_message(logmsg
);
2019 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2025 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2028 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2029 refs_heads_master
, logmsg
);
2032 int ref_update_reject_duplicates(struct string_list
*refnames
,
2035 size_t i
, n
= refnames
->nr
;
2039 for (i
= 1; i
< n
; i
++) {
2040 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2041 refnames
->items
[i
].string
);
2045 _("multiple updates for ref '%s' not allowed"),
2046 refnames
->items
[i
].string
);
2048 } else if (cmp
> 0) {
2049 BUG("ref_update_reject_duplicates() received unsorted list");
2055 static int run_transaction_hook(struct ref_transaction
*transaction
,
2058 struct child_process proc
= CHILD_PROCESS_INIT
;
2059 struct strbuf buf
= STRBUF_INIT
;
2063 hook
= find_hook("reference-transaction");
2067 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2069 proc
.stdout_to_stderr
= 1;
2070 proc
.trace2_hook_name
= "reference-transaction";
2072 ret
= start_command(&proc
);
2076 sigchain_push(SIGPIPE
, SIG_IGN
);
2078 for (i
= 0; i
< transaction
->nr
; i
++) {
2079 struct ref_update
*update
= transaction
->updates
[i
];
2082 strbuf_addf(&buf
, "%s %s %s\n",
2083 oid_to_hex(&update
->old_oid
),
2084 oid_to_hex(&update
->new_oid
),
2087 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2095 sigchain_pop(SIGPIPE
);
2096 strbuf_release(&buf
);
2098 ret
|= finish_command(&proc
);
2102 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2105 struct ref_store
*refs
= transaction
->ref_store
;
2108 switch (transaction
->state
) {
2109 case REF_TRANSACTION_OPEN
:
2112 case REF_TRANSACTION_PREPARED
:
2113 BUG("prepare called twice on reference transaction");
2115 case REF_TRANSACTION_CLOSED
:
2116 BUG("prepare called on a closed reference transaction");
2119 BUG("unexpected reference transaction state");
2123 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
2125 _("ref updates forbidden inside quarantine environment"));
2129 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2133 ret
= run_transaction_hook(transaction
, "prepared");
2135 ref_transaction_abort(transaction
, err
);
2136 die(_("ref updates aborted by hook"));
2142 int ref_transaction_abort(struct ref_transaction
*transaction
,
2145 struct ref_store
*refs
= transaction
->ref_store
;
2148 switch (transaction
->state
) {
2149 case REF_TRANSACTION_OPEN
:
2150 /* No need to abort explicitly. */
2152 case REF_TRANSACTION_PREPARED
:
2153 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2155 case REF_TRANSACTION_CLOSED
:
2156 BUG("abort called on a closed reference transaction");
2159 BUG("unexpected reference transaction state");
2163 run_transaction_hook(transaction
, "aborted");
2165 ref_transaction_free(transaction
);
2169 int ref_transaction_commit(struct ref_transaction
*transaction
,
2172 struct ref_store
*refs
= transaction
->ref_store
;
2175 switch (transaction
->state
) {
2176 case REF_TRANSACTION_OPEN
:
2177 /* Need to prepare first. */
2178 ret
= ref_transaction_prepare(transaction
, err
);
2182 case REF_TRANSACTION_PREPARED
:
2183 /* Fall through to finish. */
2185 case REF_TRANSACTION_CLOSED
:
2186 BUG("commit called on a closed reference transaction");
2189 BUG("unexpected reference transaction state");
2193 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2195 run_transaction_hook(transaction
, "committed");
2199 int refs_verify_refname_available(struct ref_store
*refs
,
2200 const char *refname
,
2201 const struct string_list
*extras
,
2202 const struct string_list
*skip
,
2206 const char *extra_refname
;
2207 struct strbuf dirname
= STRBUF_INIT
;
2208 struct strbuf referent
= STRBUF_INIT
;
2209 struct object_id oid
;
2211 struct ref_iterator
*iter
;
2216 * For the sake of comments in this function, suppose that
2217 * refname is "refs/foo/bar".
2222 strbuf_grow(&dirname
, strlen(refname
) + 1);
2223 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2224 /* Expand dirname to the new prefix, not including the trailing slash: */
2225 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2228 * We are still at a leading dir of the refname (e.g.,
2229 * "refs/foo"; if there is a reference with that name,
2230 * it is a conflict, *unless* it is in skip.
2232 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2235 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
, &type
)) {
2236 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2237 dirname
.buf
, refname
);
2241 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2242 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2243 refname
, dirname
.buf
);
2249 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2250 * There is no point in searching for a reference with that
2251 * name, because a refname isn't considered to conflict with
2252 * itself. But we still need to check for references whose
2253 * names are in the "refs/foo/bar/" namespace, because they
2256 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2257 strbuf_addch(&dirname
, '/');
2259 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2260 DO_FOR_EACH_INCLUDE_BROKEN
);
2261 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2263 string_list_has_string(skip
, iter
->refname
))
2266 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2267 iter
->refname
, refname
);
2268 ref_iterator_abort(iter
);
2272 if (ok
!= ITER_DONE
)
2273 BUG("error while iterating over references");
2275 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2277 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2278 refname
, extra_refname
);
2283 strbuf_release(&referent
);
2284 strbuf_release(&dirname
);
2288 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2290 struct ref_iterator
*iter
;
2291 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2293 iter
= refs
->be
->reflog_iterator_begin(refs
);
2295 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2296 do_for_each_ref_helper
, &hp
);
2299 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2301 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2304 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2305 const char *refname
,
2306 each_reflog_ent_fn fn
,
2309 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2313 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2316 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2317 refname
, fn
, cb_data
);
2320 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2321 each_reflog_ent_fn fn
, void *cb_data
)
2323 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2326 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2329 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2333 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2335 return refs
->be
->reflog_exists(refs
, refname
);
2338 int reflog_exists(const char *refname
)
2340 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2343 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2344 int force_create
, struct strbuf
*err
)
2346 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2349 int safe_create_reflog(const char *refname
, int force_create
,
2352 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2356 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2358 return refs
->be
->delete_reflog(refs
, refname
);
2361 int delete_reflog(const char *refname
)
2363 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2366 int refs_reflog_expire(struct ref_store
*refs
,
2367 const char *refname
,
2369 reflog_expiry_prepare_fn prepare_fn
,
2370 reflog_expiry_should_prune_fn should_prune_fn
,
2371 reflog_expiry_cleanup_fn cleanup_fn
,
2372 void *policy_cb_data
)
2374 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2375 prepare_fn
, should_prune_fn
,
2376 cleanup_fn
, policy_cb_data
);
2379 int reflog_expire(const char *refname
,
2381 reflog_expiry_prepare_fn prepare_fn
,
2382 reflog_expiry_should_prune_fn should_prune_fn
,
2383 reflog_expiry_cleanup_fn cleanup_fn
,
2384 void *policy_cb_data
)
2386 return refs_reflog_expire(get_main_ref_store(the_repository
),
2388 prepare_fn
, should_prune_fn
,
2389 cleanup_fn
, policy_cb_data
);
2392 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2395 struct ref_store
*refs
= transaction
->ref_store
;
2397 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2400 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2401 struct string_list
*refnames
, unsigned int flags
)
2406 msg
= normalize_reflog_message(logmsg
);
2407 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2412 int delete_refs(const char *msg
, struct string_list
*refnames
,
2415 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2418 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2419 const char *newref
, const char *logmsg
)
2424 msg
= normalize_reflog_message(logmsg
);
2425 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2430 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2432 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2435 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2436 const char *newref
, const char *logmsg
)
2441 msg
= normalize_reflog_message(logmsg
);
2442 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2447 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2449 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);