2 * The backend-independent part of the reference module.
11 #include "refs/refs-internal.h"
12 #include "run-command.h"
14 #include "object-store.h"
17 #include "submodule.h"
20 #include "repository.h"
24 * List of all available backends
26 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
28 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
30 struct ref_storage_be
*be
;
31 for (be
= refs_backends
; be
; be
= be
->next
)
32 if (!strcmp(be
->name
, name
))
38 * How to handle various characters in refnames:
39 * 0: An acceptable character for refs
41 * 2: ., look for a preceding . to reject .. in refs
42 * 3: {, look for a preceding @ to reject @{ in refs
43 * 4: A bad character: ASCII control characters, and
44 * ":", "?", "[", "\", "^", "~", SP, or TAB
45 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
47 static unsigned char refname_disposition
[256] = {
48 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
49 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
50 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
51 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
59 * Try to read one refname component from the front of refname.
60 * Return the length of the component found, or -1 if the component is
61 * not legal. It is legal if it is something reasonable to have under
62 * ".git/refs/"; We do not like it if:
64 * - it begins with ".", or
65 * - it has double dots "..", or
66 * - it has ASCII control characters, or
67 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
68 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
69 * - it ends with a "/", or
70 * - it ends with ".lock", or
71 * - it contains a "@{" portion
73 * When sanitized is not NULL, instead of rejecting the input refname
74 * as an error, try to come up with a usable replacement for the input
77 static int check_refname_component(const char *refname
, int *flags
,
78 struct strbuf
*sanitized
)
82 size_t component_start
= 0; /* garbage - not a reasonable initial value */
85 component_start
= sanitized
->len
;
87 for (cp
= refname
; ; cp
++) {
89 unsigned char disp
= refname_disposition
[ch
];
91 if (sanitized
&& disp
!= 1)
92 strbuf_addch(sanitized
, ch
);
98 if (last
== '.') { /* Refname contains "..". */
100 /* collapse ".." to single "." */
101 strbuf_setlen(sanitized
, sanitized
->len
- 1);
107 if (last
== '@') { /* Refname contains "@{". */
109 sanitized
->buf
[sanitized
->len
-1] = '-';
117 sanitized
->buf
[sanitized
->len
-1] = '-';
122 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
123 /* refspec can't be a pattern */
125 sanitized
->buf
[sanitized
->len
-1] = '-';
131 * Unset the pattern flag so that we only accept
132 * a single asterisk for one side of refspec.
134 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
141 return 0; /* Component has zero length. */
143 if (refname
[0] == '.') { /* Component starts with '.'. */
145 sanitized
->buf
[component_start
] = '-';
149 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
150 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
153 /* Refname ends with ".lock". */
154 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
155 /* try again in case we have .lock.lock */
161 static int check_or_sanitize_refname(const char *refname
, int flags
,
162 struct strbuf
*sanitized
)
164 int component_len
, component_count
= 0;
166 if (!strcmp(refname
, "@")) {
167 /* Refname is a single character '@'. */
169 strbuf_addch(sanitized
, '-');
175 if (sanitized
&& sanitized
->len
)
176 strbuf_complete(sanitized
, '/');
178 /* We are at the start of a path component. */
179 component_len
= check_refname_component(refname
, &flags
,
181 if (sanitized
&& component_len
== 0)
182 ; /* OK, omit empty component */
183 else if (component_len
<= 0)
187 if (refname
[component_len
] == '\0')
189 /* Skip to next component. */
190 refname
+= component_len
+ 1;
193 if (refname
[component_len
- 1] == '.') {
194 /* Refname ends with '.'. */
196 ; /* omit ending dot */
200 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
201 return -1; /* Refname has only one component. */
205 int check_refname_format(const char *refname
, int flags
)
207 return check_or_sanitize_refname(refname
, flags
, NULL
);
210 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
212 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
213 BUG("sanitizing refname '%s' check returned error", refname
);
216 int refname_is_safe(const char *refname
)
220 if (skip_prefix(refname
, "refs/", &rest
)) {
223 size_t restlen
= strlen(rest
);
225 /* rest must not be empty, or start or end with "/" */
226 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
230 * Does the refname try to escape refs/?
231 * For example: refs/foo/../bar is safe but refs/foo/../../bar
234 buf
= xmallocz(restlen
);
235 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
241 if (!isupper(*refname
) && *refname
!= '_')
249 * Return true if refname, which has the specified oid and flags, can
250 * be resolved to an object in the database. If the referred-to object
251 * does not exist, emit a warning and return false.
253 int ref_resolves_to_object(const char *refname
,
254 struct repository
*repo
,
255 const struct object_id
*oid
,
258 if (flags
& REF_ISBROKEN
)
260 if (!repo_has_object_file(repo
, oid
)) {
261 error(_("%s does not point to a valid object!"), refname
);
267 char *refs_resolve_refdup(struct ref_store
*refs
,
268 const char *refname
, int resolve_flags
,
269 struct object_id
*oid
, int *flags
)
274 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
275 oid
, flags
, &ignore_errno
);
276 return xstrdup_or_null(result
);
279 char *resolve_refdup(const char *refname
, int resolve_flags
,
280 struct object_id
*oid
, int *flags
)
282 return refs_resolve_refdup(get_main_ref_store(the_repository
),
283 refname
, resolve_flags
,
287 /* The argument to filter_refs */
295 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
298 struct ref_store
*refs
= get_main_ref_store(the_repository
);
300 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
301 oid
, flags
, &ignore_errno
))
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
)
314 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
315 NULL
, NULL
, &ignore_errno
);
318 int ref_exists(const char *refname
)
320 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
323 static int filter_refs(const char *refname
, const struct object_id
*oid
,
324 int flags
, void *data
)
326 struct ref_filter
*filter
= (struct ref_filter
*)data
;
328 if (wildmatch(filter
->pattern
, refname
, 0))
331 skip_prefix(refname
, filter
->prefix
, &refname
);
332 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
335 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
337 struct object
*o
= lookup_unknown_object(the_repository
, name
);
339 if (o
->type
== OBJ_NONE
) {
340 int type
= oid_object_info(the_repository
, name
, NULL
);
341 if (type
< 0 || !object_as_type(o
, type
, 0))
345 if (o
->type
!= OBJ_TAG
)
348 o
= deref_tag_noverify(o
);
352 oidcpy(oid
, &o
->oid
);
356 struct warn_if_dangling_data
{
359 const struct string_list
*refnames
;
363 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
364 int flags
, void *cb_data
)
366 struct warn_if_dangling_data
*d
= cb_data
;
367 const char *resolves_to
;
369 if (!(flags
& REF_ISSYMREF
))
372 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
375 ? strcmp(resolves_to
, d
->refname
)
376 : !string_list_has_string(d
->refnames
, resolves_to
))) {
380 fprintf(d
->fp
, d
->msg_fmt
, refname
);
385 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
387 struct warn_if_dangling_data data
;
390 data
.refname
= refname
;
391 data
.refnames
= NULL
;
392 data
.msg_fmt
= msg_fmt
;
393 for_each_rawref(warn_if_dangling_symref
, &data
);
396 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
398 struct warn_if_dangling_data data
;
402 data
.refnames
= refnames
;
403 data
.msg_fmt
= msg_fmt
;
404 for_each_rawref(warn_if_dangling_symref
, &data
);
407 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
409 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
412 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
414 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
417 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
419 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
422 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
424 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
427 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
429 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
432 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
434 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
437 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
439 struct strbuf buf
= STRBUF_INIT
;
441 struct object_id oid
;
444 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
445 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
446 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
447 strbuf_release(&buf
);
452 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
455 struct strbuf normalized_pattern
= STRBUF_INIT
;
458 BUG("pattern must not start with '/'");
461 strbuf_addstr(&normalized_pattern
, prefix
);
463 else if (!starts_with(pattern
, "refs/"))
464 strbuf_addstr(&normalized_pattern
, "refs/");
465 strbuf_addstr(&normalized_pattern
, pattern
);
466 strbuf_strip_suffix(&normalized_pattern
, "/");
468 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
469 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
470 strbuf_release(&normalized_pattern
);
473 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
474 const char *prefix
, void *cb_data
)
476 struct strbuf real_pattern
= STRBUF_INIT
;
477 struct ref_filter filter
;
480 if (!prefix
&& !starts_with(pattern
, "refs/"))
481 strbuf_addstr(&real_pattern
, "refs/");
483 strbuf_addstr(&real_pattern
, prefix
);
484 strbuf_addstr(&real_pattern
, pattern
);
486 if (!has_glob_specials(pattern
)) {
487 /* Append implied '/' '*' if not present. */
488 strbuf_complete(&real_pattern
, '/');
489 /* No need to check for '*', there is none. */
490 strbuf_addch(&real_pattern
, '*');
493 filter
.pattern
= real_pattern
.buf
;
494 filter
.prefix
= prefix
;
496 filter
.cb_data
= cb_data
;
497 ret
= for_each_ref(filter_refs
, &filter
);
499 strbuf_release(&real_pattern
);
503 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
505 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
508 const char *prettify_refname(const char *name
)
510 if (skip_prefix(name
, "refs/heads/", &name
) ||
511 skip_prefix(name
, "refs/tags/", &name
) ||
512 skip_prefix(name
, "refs/remotes/", &name
))
517 static const char *ref_rev_parse_rules
[] = {
523 "refs/remotes/%.*s/HEAD",
527 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
530 * Is it possible that the caller meant full_name with abbrev_name?
531 * If so return a non-zero value to signal "yes"; the magnitude of
532 * the returned value gives the precedence used for disambiguation.
534 * If abbrev_name cannot mean full_name, return 0.
536 int refname_match(const char *abbrev_name
, const char *full_name
)
539 const int abbrev_name_len
= strlen(abbrev_name
);
540 const int num_rules
= NUM_REV_PARSE_RULES
;
542 for (p
= ref_rev_parse_rules
; *p
; p
++)
543 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
544 return &ref_rev_parse_rules
[num_rules
] - p
;
550 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
551 * the results to 'prefixes'
553 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
556 int len
= strlen(prefix
);
558 for (p
= ref_rev_parse_rules
; *p
; p
++)
559 strvec_pushf(prefixes
, *p
, len
, prefix
);
562 static const char default_branch_name_advice
[] = N_(
563 "Using '%s' as the name for the initial branch. This default branch name\n"
564 "is subject to change. To configure the initial branch name to use in all\n"
565 "of your new repositories, which will suppress this warning, call:\n"
567 "\tgit config --global init.defaultBranch <name>\n"
569 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
570 "'development'. The just-created branch can be renamed via this command:\n"
572 "\tgit branch -m <name>\n"
575 char *repo_default_branch_name(struct repository
*r
, int quiet
)
577 const char *config_key
= "init.defaultbranch";
578 const char *config_display_key
= "init.defaultBranch";
579 char *ret
= NULL
, *full_ref
;
580 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
584 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
585 die(_("could not retrieve `%s`"), config_display_key
);
588 ret
= xstrdup("master");
590 advise(_(default_branch_name_advice
), ret
);
593 full_ref
= xstrfmt("refs/heads/%s", ret
);
594 if (check_refname_format(full_ref
, 0))
595 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
601 const char *git_default_branch_name(int quiet
)
606 ret
= repo_default_branch_name(the_repository
, quiet
);
612 * *string and *len will only be substituted, and *string returned (for
613 * later free()ing) if the string passed in is a magic short-hand form
616 static char *substitute_branch_name(struct repository
*r
,
617 const char **string
, int *len
,
618 int nonfatal_dangling_mark
)
620 struct strbuf buf
= STRBUF_INIT
;
621 struct interpret_branch_name_options options
= {
622 .nonfatal_dangling_mark
= nonfatal_dangling_mark
624 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
628 *string
= strbuf_detach(&buf
, &size
);
630 return (char *)*string
;
636 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
637 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
639 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
640 nonfatal_dangling_mark
);
641 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
646 int expand_ref(struct repository
*repo
, const char *str
, int len
,
647 struct object_id
*oid
, char **ref
)
651 struct strbuf fullref
= STRBUF_INIT
;
654 for (p
= ref_rev_parse_rules
; *p
; p
++) {
655 struct object_id oid_from_ref
;
656 struct object_id
*this_result
;
658 struct ref_store
*refs
= get_main_ref_store(repo
);
661 this_result
= refs_found
? &oid_from_ref
: oid
;
662 strbuf_reset(&fullref
);
663 strbuf_addf(&fullref
, *p
, len
, str
);
664 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
671 if (!warn_ambiguous_refs
)
673 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
674 warning(_("ignoring dangling symref %s"), fullref
.buf
);
675 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
676 warning(_("ignoring broken ref %s"), fullref
.buf
);
679 strbuf_release(&fullref
);
683 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
684 struct object_id
*oid
, char **log
)
686 struct ref_store
*refs
= get_main_ref_store(r
);
687 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
690 struct strbuf path
= STRBUF_INIT
;
693 for (p
= ref_rev_parse_rules
; *p
; p
++) {
694 struct object_id hash
;
695 const char *ref
, *it
;
699 strbuf_addf(&path
, *p
, len
, str
);
700 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
702 oid
? &hash
: NULL
, NULL
,
706 if (refs_reflog_exists(refs
, path
.buf
))
708 else if (strcmp(ref
, path
.buf
) &&
709 refs_reflog_exists(refs
, ref
))
718 if (!warn_ambiguous_refs
)
721 strbuf_release(&path
);
726 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
728 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
731 static int is_per_worktree_ref(const char *refname
)
733 return starts_with(refname
, "refs/worktree/") ||
734 starts_with(refname
, "refs/bisect/") ||
735 starts_with(refname
, "refs/rewritten/");
738 static int is_pseudoref_syntax(const char *refname
)
742 for (c
= refname
; *c
; c
++) {
743 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
750 static int is_main_pseudoref_syntax(const char *refname
)
752 return skip_prefix(refname
, "main-worktree/", &refname
) &&
754 is_pseudoref_syntax(refname
);
757 static int is_other_pseudoref_syntax(const char *refname
)
759 if (!skip_prefix(refname
, "worktrees/", &refname
))
761 refname
= strchr(refname
, '/');
762 if (!refname
|| !refname
[1])
764 return is_pseudoref_syntax(refname
+ 1);
767 enum ref_type
ref_type(const char *refname
)
769 if (is_per_worktree_ref(refname
))
770 return REF_TYPE_PER_WORKTREE
;
771 if (is_pseudoref_syntax(refname
))
772 return REF_TYPE_PSEUDOREF
;
773 if (is_main_pseudoref_syntax(refname
))
774 return REF_TYPE_MAIN_PSEUDOREF
;
775 if (is_other_pseudoref_syntax(refname
))
776 return REF_TYPE_OTHER_PSEUDOREF
;
777 return REF_TYPE_NORMAL
;
780 long get_files_ref_lock_timeout_ms(void)
782 static int configured
= 0;
784 /* The default timeout is 100 ms: */
785 static int timeout_ms
= 100;
788 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
795 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
797 const struct object_id
*old_oid
,
800 struct ref_transaction
*transaction
;
801 struct strbuf err
= STRBUF_INIT
;
803 transaction
= ref_store_transaction_begin(refs
, &err
);
805 ref_transaction_delete(transaction
, refname
, old_oid
,
807 ref_transaction_commit(transaction
, &err
)) {
808 error("%s", err
.buf
);
809 ref_transaction_free(transaction
);
810 strbuf_release(&err
);
813 ref_transaction_free(transaction
);
814 strbuf_release(&err
);
818 int delete_ref(const char *msg
, const char *refname
,
819 const struct object_id
*old_oid
, unsigned int flags
)
821 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
825 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
830 while ((c
= *msg
++)) {
831 if (wasspace
&& isspace(c
))
833 wasspace
= isspace(c
);
841 static char *normalize_reflog_message(const char *msg
)
843 struct strbuf sb
= STRBUF_INIT
;
846 copy_reflog_msg(&sb
, msg
);
847 return strbuf_detach(&sb
, NULL
);
850 int should_autocreate_reflog(const char *refname
)
852 switch (log_all_ref_updates
) {
853 case LOG_REFS_ALWAYS
:
855 case LOG_REFS_NORMAL
:
856 return starts_with(refname
, "refs/heads/") ||
857 starts_with(refname
, "refs/remotes/") ||
858 starts_with(refname
, "refs/notes/") ||
859 !strcmp(refname
, "HEAD");
865 int is_branch(const char *refname
)
867 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
870 struct read_ref_at_cb
{
875 struct object_id
*oid
;
878 struct object_id ooid
;
879 struct object_id noid
;
883 timestamp_t
*cutoff_time
;
888 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
889 timestamp_t timestamp
, int tz
, const char *message
)
892 *cb
->msg
= xstrdup(message
);
894 *cb
->cutoff_time
= timestamp
;
898 *cb
->cutoff_cnt
= cb
->reccnt
;
901 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
902 const char *email
, timestamp_t timestamp
, int tz
,
903 const char *message
, void *cb_data
)
905 struct read_ref_at_cb
*cb
= cb_data
;
909 cb
->date
= timestamp
;
912 * It is not possible for cb->cnt == 0 on the first iteration because
913 * that special case is handled in read_ref_at().
917 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
918 if (timestamp
<= cb
->at_time
|| reached_count
) {
919 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
921 * we have not yet updated cb->[n|o]oid so they still
922 * hold the values for the previous record.
924 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
925 warning(_("log for ref %s has gap after %s"),
926 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
928 oidcpy(cb
->oid
, ooid
);
929 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
930 oidcpy(cb
->oid
, noid
);
931 else if (!oideq(noid
, cb
->oid
))
932 warning(_("log for ref %s unexpectedly ended on %s"),
933 cb
->refname
, show_date(cb
->date
, cb
->tz
,
934 DATE_MODE(RFC2822
)));
938 oidcpy(&cb
->ooid
, ooid
);
939 oidcpy(&cb
->noid
, noid
);
943 static int read_ref_at_ent_newest(struct object_id
*ooid
, struct object_id
*noid
,
944 const char *email
, timestamp_t timestamp
,
945 int tz
, const char *message
, void *cb_data
)
947 struct read_ref_at_cb
*cb
= cb_data
;
949 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
950 oidcpy(cb
->oid
, noid
);
951 /* We just want the first entry */
955 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
956 const char *email
, timestamp_t timestamp
,
957 int tz
, const char *message
, void *cb_data
)
959 struct read_ref_at_cb
*cb
= cb_data
;
961 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
962 oidcpy(cb
->oid
, ooid
);
963 if (is_null_oid(cb
->oid
))
964 oidcpy(cb
->oid
, noid
);
965 /* We just want the first entry */
969 int read_ref_at(struct ref_store
*refs
, const char *refname
,
970 unsigned int flags
, timestamp_t at_time
, int cnt
,
971 struct object_id
*oid
, char **msg
,
972 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
974 struct read_ref_at_cb cb
;
976 memset(&cb
, 0, sizeof(cb
));
977 cb
.refname
= refname
;
978 cb
.at_time
= at_time
;
981 cb
.cutoff_time
= cutoff_time
;
982 cb
.cutoff_tz
= cutoff_tz
;
983 cb
.cutoff_cnt
= cutoff_cnt
;
987 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
991 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
994 if (flags
& GET_OID_QUIETLY
)
997 die(_("log for %s is empty"), refname
);
1002 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1007 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1010 struct ref_transaction
*tr
;
1013 CALLOC_ARRAY(tr
, 1);
1014 tr
->ref_store
= refs
;
1018 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1020 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1023 void ref_transaction_free(struct ref_transaction
*transaction
)
1030 switch (transaction
->state
) {
1031 case REF_TRANSACTION_OPEN
:
1032 case REF_TRANSACTION_CLOSED
:
1035 case REF_TRANSACTION_PREPARED
:
1036 BUG("free called on a prepared reference transaction");
1039 BUG("unexpected reference transaction state");
1043 for (i
= 0; i
< transaction
->nr
; i
++) {
1044 free(transaction
->updates
[i
]->msg
);
1045 free(transaction
->updates
[i
]);
1047 free(transaction
->updates
);
1051 struct ref_update
*ref_transaction_add_update(
1052 struct ref_transaction
*transaction
,
1053 const char *refname
, unsigned int flags
,
1054 const struct object_id
*new_oid
,
1055 const struct object_id
*old_oid
,
1058 struct ref_update
*update
;
1060 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1061 BUG("update called for transaction that is not open");
1063 FLEX_ALLOC_STR(update
, refname
, refname
);
1064 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1065 transaction
->updates
[transaction
->nr
++] = update
;
1067 update
->flags
= flags
;
1069 if (flags
& REF_HAVE_NEW
)
1070 oidcpy(&update
->new_oid
, new_oid
);
1071 if (flags
& REF_HAVE_OLD
)
1072 oidcpy(&update
->old_oid
, old_oid
);
1073 update
->msg
= normalize_reflog_message(msg
);
1077 int ref_transaction_update(struct ref_transaction
*transaction
,
1078 const char *refname
,
1079 const struct object_id
*new_oid
,
1080 const struct object_id
*old_oid
,
1081 unsigned int flags
, const char *msg
,
1086 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1087 ((new_oid
&& !is_null_oid(new_oid
)) ?
1088 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1089 !refname_is_safe(refname
))) {
1090 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1095 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1096 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1098 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1100 ref_transaction_add_update(transaction
, refname
, flags
,
1101 new_oid
, old_oid
, msg
);
1105 int ref_transaction_create(struct ref_transaction
*transaction
,
1106 const char *refname
,
1107 const struct object_id
*new_oid
,
1108 unsigned int flags
, const char *msg
,
1111 if (!new_oid
|| is_null_oid(new_oid
))
1112 BUG("create called without valid new_oid");
1113 return ref_transaction_update(transaction
, refname
, new_oid
,
1114 null_oid(), flags
, msg
, err
);
1117 int ref_transaction_delete(struct ref_transaction
*transaction
,
1118 const char *refname
,
1119 const struct object_id
*old_oid
,
1120 unsigned int flags
, const char *msg
,
1123 if (old_oid
&& is_null_oid(old_oid
))
1124 BUG("delete called with old_oid set to zeros");
1125 return ref_transaction_update(transaction
, refname
,
1126 null_oid(), old_oid
,
1130 int ref_transaction_verify(struct ref_transaction
*transaction
,
1131 const char *refname
,
1132 const struct object_id
*old_oid
,
1137 BUG("verify called with old_oid set to NULL");
1138 return ref_transaction_update(transaction
, refname
,
1143 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1144 const char *refname
, const struct object_id
*new_oid
,
1145 const struct object_id
*old_oid
, unsigned int flags
,
1146 enum action_on_err onerr
)
1148 struct ref_transaction
*t
= NULL
;
1149 struct strbuf err
= STRBUF_INIT
;
1152 t
= ref_store_transaction_begin(refs
, &err
);
1154 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1156 ref_transaction_commit(t
, &err
)) {
1158 ref_transaction_free(t
);
1161 const char *str
= _("update_ref failed for ref '%s': %s");
1164 case UPDATE_REFS_MSG_ON_ERR
:
1165 error(str
, refname
, err
.buf
);
1167 case UPDATE_REFS_DIE_ON_ERR
:
1168 die(str
, refname
, err
.buf
);
1170 case UPDATE_REFS_QUIET_ON_ERR
:
1173 strbuf_release(&err
);
1176 strbuf_release(&err
);
1178 ref_transaction_free(t
);
1182 int update_ref(const char *msg
, const char *refname
,
1183 const struct object_id
*new_oid
,
1184 const struct object_id
*old_oid
,
1185 unsigned int flags
, enum action_on_err onerr
)
1187 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1188 old_oid
, flags
, onerr
);
1191 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1192 const char *refname
, int strict
)
1195 static char **scanf_fmts
;
1196 static int nr_rules
;
1198 struct strbuf resolved_buf
= STRBUF_INIT
;
1202 * Pre-generate scanf formats from ref_rev_parse_rules[].
1203 * Generate a format suitable for scanf from a
1204 * ref_rev_parse_rules rule by interpolating "%s" at the
1205 * location of the "%.*s".
1207 size_t total_len
= 0;
1210 /* the rule list is NULL terminated, count them first */
1211 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1212 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1213 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1215 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1218 for (i
= 0; i
< nr_rules
; i
++) {
1219 assert(offset
< total_len
);
1220 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1221 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1222 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1226 /* bail out if there are no rules */
1228 return xstrdup(refname
);
1230 /* buffer for scanf result, at most refname must fit */
1231 short_name
= xstrdup(refname
);
1233 /* skip first rule, it will always match */
1234 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1236 int rules_to_fail
= i
;
1239 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1242 short_name_len
= strlen(short_name
);
1245 * in strict mode, all (except the matched one) rules
1246 * must fail to resolve to a valid non-ambiguous ref
1249 rules_to_fail
= nr_rules
;
1252 * check if the short name resolves to a valid ref,
1253 * but use only rules prior to the matched one
1255 for (j
= 0; j
< rules_to_fail
; j
++) {
1256 const char *rule
= ref_rev_parse_rules
[j
];
1258 /* skip matched rule */
1263 * the short name is ambiguous, if it resolves
1264 * (with this previous rule) to a valid ref
1265 * read_ref() returns 0 on success
1267 strbuf_reset(&resolved_buf
);
1268 strbuf_addf(&resolved_buf
, rule
,
1269 short_name_len
, short_name
);
1270 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1275 * short name is non-ambiguous if all previous rules
1276 * haven't resolved to a valid ref
1278 if (j
== rules_to_fail
) {
1279 strbuf_release(&resolved_buf
);
1284 strbuf_release(&resolved_buf
);
1286 return xstrdup(refname
);
1289 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1291 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1295 static struct string_list
*hide_refs
;
1297 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1300 if (!strcmp("transfer.hiderefs", var
) ||
1301 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1302 !strcmp(key
, "hiderefs"))) {
1307 return config_error_nonbool(var
);
1308 ref
= xstrdup(value
);
1310 while (len
&& ref
[len
- 1] == '/')
1313 CALLOC_ARRAY(hide_refs
, 1);
1314 hide_refs
->strdup_strings
= 1;
1316 string_list_append(hide_refs
, ref
);
1321 int ref_is_hidden(const char *refname
, const char *refname_full
)
1327 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1328 const char *match
= hide_refs
->items
[i
].string
;
1329 const char *subject
;
1333 if (*match
== '!') {
1338 if (*match
== '^') {
1339 subject
= refname_full
;
1345 /* refname can be NULL when namespaces are used. */
1347 skip_prefix(subject
, match
, &p
) &&
1354 const char *find_descendant_ref(const char *dirname
,
1355 const struct string_list
*extras
,
1356 const struct string_list
*skip
)
1364 * Look at the place where dirname would be inserted into
1365 * extras. If there is an entry at that position that starts
1366 * with dirname (remember, dirname includes the trailing
1367 * slash) and is not in skip, then we have a conflict.
1369 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1370 pos
< extras
->nr
; pos
++) {
1371 const char *extra_refname
= extras
->items
[pos
].string
;
1373 if (!starts_with(extra_refname
, dirname
))
1376 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1377 return extra_refname
;
1382 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1384 struct object_id oid
;
1388 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1389 &oid
, &flag
, &ignore_errno
))
1390 return fn("HEAD", &oid
, flag
, cb_data
);
1395 int head_ref(each_ref_fn fn
, void *cb_data
)
1397 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1400 struct ref_iterator
*refs_ref_iterator_begin(
1401 struct ref_store
*refs
,
1402 const char *prefix
, int trim
,
1403 enum do_for_each_ref_flags flags
)
1405 struct ref_iterator
*iter
;
1407 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1408 static int ref_paranoia
= -1;
1410 if (ref_paranoia
< 0)
1411 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1413 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1414 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1418 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1421 * `iterator_begin()` already takes care of prefix, but we
1422 * might need to do some trimming:
1425 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1427 /* Sanity check for subclasses: */
1429 BUG("reference iterator is not ordered");
1435 * Call fn for each reference in the specified submodule for which the
1436 * refname begins with prefix. If trim is non-zero, then trim that
1437 * many characters off the beginning of each refname before passing
1438 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1439 * include broken references in the iteration. If fn ever returns a
1440 * non-zero value, stop the iteration and return that value;
1441 * otherwise, return 0.
1443 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1444 each_repo_ref_fn fn
, int trim
, int flags
,
1447 struct ref_iterator
*iter
;
1448 struct ref_store
*refs
= get_main_ref_store(r
);
1453 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1455 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1458 struct do_for_each_ref_help
{
1463 static int do_for_each_ref_helper(struct repository
*r
,
1464 const char *refname
,
1465 const struct object_id
*oid
,
1469 struct do_for_each_ref_help
*hp
= cb_data
;
1471 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1474 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1475 each_ref_fn fn
, int trim
,
1476 enum do_for_each_ref_flags flags
, void *cb_data
)
1478 struct ref_iterator
*iter
;
1479 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1484 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1486 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1487 do_for_each_ref_helper
, &hp
);
1490 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1492 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1495 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1497 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1500 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1501 each_ref_fn fn
, void *cb_data
)
1503 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1506 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1508 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1511 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1513 return do_for_each_ref(get_main_ref_store(the_repository
),
1514 prefix
, fn
, 0, 0, cb_data
);
1517 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1518 each_ref_fn fn
, void *cb_data
)
1520 return do_for_each_ref(refs
, prefix
, fn
, 0, 0, cb_data
);
1523 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1525 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1526 strlen(git_replace_ref_base
),
1527 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1530 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1532 struct strbuf buf
= STRBUF_INIT
;
1534 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1535 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1536 buf
.buf
, fn
, 0, 0, cb_data
);
1537 strbuf_release(&buf
);
1541 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1543 return do_for_each_ref(refs
, "", fn
, 0,
1544 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1547 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1549 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1552 static int qsort_strcmp(const void *va
, const void *vb
)
1554 const char *a
= *(const char **)va
;
1555 const char *b
= *(const char **)vb
;
1557 return strcmp(a
, b
);
1560 static void find_longest_prefixes_1(struct string_list
*out
,
1561 struct strbuf
*prefix
,
1562 const char **patterns
, size_t nr
)
1566 for (i
= 0; i
< nr
; i
++) {
1567 char c
= patterns
[i
][prefix
->len
];
1568 if (!c
|| is_glob_special(c
)) {
1569 string_list_append(out
, prefix
->buf
);
1579 * Set "end" to the index of the element _after_ the last one
1582 for (end
= i
+ 1; end
< nr
; end
++) {
1583 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1587 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1588 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1589 strbuf_setlen(prefix
, prefix
->len
- 1);
1595 static void find_longest_prefixes(struct string_list
*out
,
1596 const char **patterns
)
1598 struct strvec sorted
= STRVEC_INIT
;
1599 struct strbuf prefix
= STRBUF_INIT
;
1601 strvec_pushv(&sorted
, patterns
);
1602 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1604 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1606 strvec_clear(&sorted
);
1607 strbuf_release(&prefix
);
1610 int for_each_fullref_in_prefixes(const char *namespace,
1611 const char **patterns
,
1612 each_ref_fn fn
, void *cb_data
)
1614 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1615 struct string_list_item
*prefix
;
1616 struct strbuf buf
= STRBUF_INIT
;
1617 int ret
= 0, namespace_len
;
1619 find_longest_prefixes(&prefixes
, patterns
);
1622 strbuf_addstr(&buf
, namespace);
1623 namespace_len
= buf
.len
;
1625 for_each_string_list_item(prefix
, &prefixes
) {
1626 strbuf_addstr(&buf
, prefix
->string
);
1627 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
);
1630 strbuf_setlen(&buf
, namespace_len
);
1633 string_list_clear(&prefixes
, 0);
1634 strbuf_release(&buf
);
1638 static int refs_read_special_head(struct ref_store
*ref_store
,
1639 const char *refname
, struct object_id
*oid
,
1640 struct strbuf
*referent
, unsigned int *type
,
1643 struct strbuf full_path
= STRBUF_INIT
;
1644 struct strbuf content
= STRBUF_INIT
;
1646 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1648 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1651 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1655 strbuf_release(&full_path
);
1656 strbuf_release(&content
);
1660 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1661 struct object_id
*oid
, struct strbuf
*referent
,
1662 unsigned int *type
, int *failure_errno
)
1664 assert(failure_errno
);
1665 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1666 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1667 type
, failure_errno
);
1670 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1671 type
, failure_errno
);
1674 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1675 const char *refname
,
1677 struct object_id
*oid
,
1678 int *flags
, int *failure_errno
)
1680 static struct strbuf sb_refname
= STRBUF_INIT
;
1681 struct object_id unused_oid
;
1685 assert(failure_errno
);
1690 flags
= &unused_flags
;
1694 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1695 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1696 !refname_is_safe(refname
)) {
1697 *failure_errno
= EINVAL
;
1702 * dwim_ref() uses REF_ISBROKEN to distinguish between
1703 * missing refs and refs that were present but invalid,
1704 * to complain about the latter to stderr.
1706 * We don't know whether the ref exists, so don't set
1709 *flags
|= REF_BAD_NAME
;
1712 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1713 unsigned int read_flags
= 0;
1715 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1716 &read_flags
, failure_errno
)) {
1717 *flags
|= read_flags
;
1719 *failure_errno
= errno
;
1721 /* In reading mode, refs must eventually resolve */
1722 if (resolve_flags
& RESOLVE_REF_READING
)
1726 * Otherwise a missing ref is OK. But the files backend
1727 * may show errors besides ENOENT if there are
1728 * similarly-named refs.
1730 if (*failure_errno
!= ENOENT
&&
1731 *failure_errno
!= EISDIR
&&
1732 *failure_errno
!= ENOTDIR
)
1736 if (*flags
& REF_BAD_NAME
)
1737 *flags
|= REF_ISBROKEN
;
1741 *flags
|= read_flags
;
1743 if (!(read_flags
& REF_ISSYMREF
)) {
1744 if (*flags
& REF_BAD_NAME
) {
1746 *flags
|= REF_ISBROKEN
;
1751 refname
= sb_refname
.buf
;
1752 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1756 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1757 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1758 !refname_is_safe(refname
)) {
1759 *failure_errno
= EINVAL
;
1763 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1767 *failure_errno
= ELOOP
;
1771 /* backend functions */
1772 int refs_init_db(struct strbuf
*err
)
1774 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1776 return refs
->be
->init_db(refs
, err
);
1779 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1780 struct object_id
*oid
, int *flags
)
1784 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1785 resolve_flags
, oid
, flags
, &ignore_errno
);
1788 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1789 struct object_id
*oid
)
1791 struct ref_store
*refs
;
1795 refs
= get_submodule_ref_store(submodule
);
1800 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
,
1801 &ignore_errno
) || is_null_oid(oid
))
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(struct repository
*repo
,
1876 const char *be_name
= "files";
1877 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1878 struct ref_store
*refs
;
1881 BUG("reference backend %s is unknown", be_name
);
1883 refs
= be
->init(repo
, gitdir
, flags
);
1887 struct ref_store
*get_main_ref_store(struct repository
*r
)
1889 if (r
->refs_private
)
1890 return r
->refs_private
;
1893 BUG("attempting to get main_ref_store outside of repository");
1895 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
1896 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1897 return r
->refs_private
;
1901 * Associate a ref store with a name. It is a fatal error to call this
1902 * function twice for the same name.
1904 static void register_ref_store_map(struct hashmap
*map
,
1906 struct ref_store
*refs
,
1909 struct ref_store_hash_entry
*entry
;
1911 if (!map
->tablesize
)
1912 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1914 entry
= alloc_ref_store_hash_entry(name
, refs
);
1915 if (hashmap_put(map
, &entry
->ent
))
1916 BUG("%s ref_store '%s' initialized twice", type
, name
);
1919 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1921 struct strbuf submodule_sb
= STRBUF_INIT
;
1922 struct ref_store
*refs
;
1923 char *to_free
= NULL
;
1925 struct repository
*subrepo
;
1930 len
= strlen(submodule
);
1931 while (len
&& is_dir_sep(submodule
[len
- 1]))
1937 /* We need to strip off one or more trailing slashes */
1938 submodule
= to_free
= xmemdupz(submodule
, len
);
1940 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1944 strbuf_addstr(&submodule_sb
, submodule
);
1945 if (!is_nonbare_repository_dir(&submodule_sb
))
1948 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1951 subrepo
= xmalloc(sizeof(*subrepo
));
1953 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
1954 * superprojects other than the_repository. This probably should be
1955 * done by making it take a struct repository * parameter instead of a
1958 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
1963 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
1964 REF_STORE_READ
| REF_STORE_ODB
);
1965 register_ref_store_map(&submodule_ref_stores
, "submodule",
1969 strbuf_release(&submodule_sb
);
1975 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1977 struct ref_store
*refs
;
1981 return get_main_ref_store(the_repository
);
1983 id
= wt
->id
? wt
->id
: "/";
1984 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1989 refs
= ref_store_init(the_repository
,
1990 git_common_path("worktrees/%s", wt
->id
),
1991 REF_STORE_ALL_CAPS
);
1993 refs
= ref_store_init(the_repository
,
1994 get_git_common_dir(),
1995 REF_STORE_ALL_CAPS
);
1998 register_ref_store_map(&worktree_ref_stores
, "worktree",
2003 void base_ref_store_init(struct ref_store
*refs
,
2004 const struct ref_storage_be
*be
)
2009 /* backend functions */
2010 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
2012 return refs
->be
->pack_refs(refs
, flags
);
2015 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2017 if (current_ref_iter
&&
2018 (current_ref_iter
->oid
== base
||
2019 oideq(current_ref_iter
->oid
, base
)))
2020 return ref_iterator_peel(current_ref_iter
, peeled
);
2022 return peel_object(base
, peeled
) ? -1 : 0;
2025 int refs_create_symref(struct ref_store
*refs
,
2026 const char *ref_target
,
2027 const char *refs_heads_master
,
2033 msg
= normalize_reflog_message(logmsg
);
2034 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2040 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2043 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2044 refs_heads_master
, logmsg
);
2047 int ref_update_reject_duplicates(struct string_list
*refnames
,
2050 size_t i
, n
= refnames
->nr
;
2054 for (i
= 1; i
< n
; i
++) {
2055 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2056 refnames
->items
[i
].string
);
2060 _("multiple updates for ref '%s' not allowed"),
2061 refnames
->items
[i
].string
);
2063 } else if (cmp
> 0) {
2064 BUG("ref_update_reject_duplicates() received unsorted list");
2070 static int run_transaction_hook(struct ref_transaction
*transaction
,
2073 struct child_process proc
= CHILD_PROCESS_INIT
;
2074 struct strbuf buf
= STRBUF_INIT
;
2078 hook
= find_hook("reference-transaction");
2082 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2084 proc
.stdout_to_stderr
= 1;
2085 proc
.trace2_hook_name
= "reference-transaction";
2087 ret
= start_command(&proc
);
2091 sigchain_push(SIGPIPE
, SIG_IGN
);
2093 for (i
= 0; i
< transaction
->nr
; i
++) {
2094 struct ref_update
*update
= transaction
->updates
[i
];
2097 strbuf_addf(&buf
, "%s %s %s\n",
2098 oid_to_hex(&update
->old_oid
),
2099 oid_to_hex(&update
->new_oid
),
2102 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2103 if (errno
!= EPIPE
) {
2104 /* Don't leak errno outside this API */
2113 sigchain_pop(SIGPIPE
);
2114 strbuf_release(&buf
);
2116 ret
|= finish_command(&proc
);
2120 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2123 struct ref_store
*refs
= transaction
->ref_store
;
2126 switch (transaction
->state
) {
2127 case REF_TRANSACTION_OPEN
:
2130 case REF_TRANSACTION_PREPARED
:
2131 BUG("prepare called twice on reference transaction");
2133 case REF_TRANSACTION_CLOSED
:
2134 BUG("prepare called on a closed reference transaction");
2137 BUG("unexpected reference transaction state");
2141 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
2143 _("ref updates forbidden inside quarantine environment"));
2147 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2151 ret
= run_transaction_hook(transaction
, "prepared");
2153 ref_transaction_abort(transaction
, err
);
2154 die(_("ref updates aborted by hook"));
2160 int ref_transaction_abort(struct ref_transaction
*transaction
,
2163 struct ref_store
*refs
= transaction
->ref_store
;
2166 switch (transaction
->state
) {
2167 case REF_TRANSACTION_OPEN
:
2168 /* No need to abort explicitly. */
2170 case REF_TRANSACTION_PREPARED
:
2171 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2173 case REF_TRANSACTION_CLOSED
:
2174 BUG("abort called on a closed reference transaction");
2177 BUG("unexpected reference transaction state");
2181 run_transaction_hook(transaction
, "aborted");
2183 ref_transaction_free(transaction
);
2187 int ref_transaction_commit(struct ref_transaction
*transaction
,
2190 struct ref_store
*refs
= transaction
->ref_store
;
2193 switch (transaction
->state
) {
2194 case REF_TRANSACTION_OPEN
:
2195 /* Need to prepare first. */
2196 ret
= ref_transaction_prepare(transaction
, err
);
2200 case REF_TRANSACTION_PREPARED
:
2201 /* Fall through to finish. */
2203 case REF_TRANSACTION_CLOSED
:
2204 BUG("commit called on a closed reference transaction");
2207 BUG("unexpected reference transaction state");
2211 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2213 run_transaction_hook(transaction
, "committed");
2217 int refs_verify_refname_available(struct ref_store
*refs
,
2218 const char *refname
,
2219 const struct string_list
*extras
,
2220 const struct string_list
*skip
,
2224 const char *extra_refname
;
2225 struct strbuf dirname
= STRBUF_INIT
;
2226 struct strbuf referent
= STRBUF_INIT
;
2227 struct object_id oid
;
2229 struct ref_iterator
*iter
;
2234 * For the sake of comments in this function, suppose that
2235 * refname is "refs/foo/bar".
2240 strbuf_grow(&dirname
, strlen(refname
) + 1);
2241 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2243 * Just saying "Is a directory" when we e.g. can't
2244 * lock some multi-level ref isn't very informative,
2245 * the user won't be told *what* is a directory, so
2246 * let's not use strerror() below.
2249 /* Expand dirname to the new prefix, not including the trailing slash: */
2250 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2253 * We are still at a leading dir of the refname (e.g.,
2254 * "refs/foo"; if there is a reference with that name,
2255 * it is a conflict, *unless* it is in skip.
2257 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2260 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2261 &type
, &ignore_errno
)) {
2262 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2263 dirname
.buf
, refname
);
2267 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2268 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2269 refname
, dirname
.buf
);
2275 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2276 * There is no point in searching for a reference with that
2277 * name, because a refname isn't considered to conflict with
2278 * itself. But we still need to check for references whose
2279 * names are in the "refs/foo/bar/" namespace, because they
2282 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2283 strbuf_addch(&dirname
, '/');
2285 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2286 DO_FOR_EACH_INCLUDE_BROKEN
);
2287 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2289 string_list_has_string(skip
, iter
->refname
))
2292 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2293 iter
->refname
, refname
);
2294 ref_iterator_abort(iter
);
2298 if (ok
!= ITER_DONE
)
2299 BUG("error while iterating over references");
2301 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2303 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2304 refname
, extra_refname
);
2309 strbuf_release(&referent
);
2310 strbuf_release(&dirname
);
2314 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2316 struct ref_iterator
*iter
;
2317 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2319 iter
= refs
->be
->reflog_iterator_begin(refs
);
2321 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2322 do_for_each_ref_helper
, &hp
);
2325 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2327 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2330 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2331 const char *refname
,
2332 each_reflog_ent_fn fn
,
2335 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2339 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2342 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2343 refname
, fn
, cb_data
);
2346 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2347 each_reflog_ent_fn fn
, void *cb_data
)
2349 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2352 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2355 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2359 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2361 return refs
->be
->reflog_exists(refs
, refname
);
2364 int reflog_exists(const char *refname
)
2366 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2369 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2370 int force_create
, struct strbuf
*err
)
2372 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2375 int safe_create_reflog(const char *refname
, int force_create
,
2378 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2382 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2384 return refs
->be
->delete_reflog(refs
, refname
);
2387 int delete_reflog(const char *refname
)
2389 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2392 int refs_reflog_expire(struct ref_store
*refs
,
2393 const char *refname
,
2395 reflog_expiry_prepare_fn prepare_fn
,
2396 reflog_expiry_should_prune_fn should_prune_fn
,
2397 reflog_expiry_cleanup_fn cleanup_fn
,
2398 void *policy_cb_data
)
2400 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2401 prepare_fn
, should_prune_fn
,
2402 cleanup_fn
, policy_cb_data
);
2405 int reflog_expire(const char *refname
,
2407 reflog_expiry_prepare_fn prepare_fn
,
2408 reflog_expiry_should_prune_fn should_prune_fn
,
2409 reflog_expiry_cleanup_fn cleanup_fn
,
2410 void *policy_cb_data
)
2412 return refs_reflog_expire(get_main_ref_store(the_repository
),
2414 prepare_fn
, should_prune_fn
,
2415 cleanup_fn
, policy_cb_data
);
2418 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2421 struct ref_store
*refs
= transaction
->ref_store
;
2423 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2426 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2427 struct string_list
*refnames
, unsigned int flags
)
2432 msg
= normalize_reflog_message(logmsg
);
2433 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2438 int delete_refs(const char *msg
, struct string_list
*refnames
,
2441 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2444 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2445 const char *newref
, const char *logmsg
)
2450 msg
= normalize_reflog_message(logmsg
);
2451 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2456 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2458 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2461 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2462 const char *newref
, const char *logmsg
)
2467 msg
= normalize_reflog_message(logmsg
);
2468 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2473 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2475 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);