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 const struct object_id
*oid
,
257 if (flags
& REF_ISBROKEN
)
259 if (!has_object_file(oid
)) {
260 error(_("%s does not point to a valid object!"), refname
);
266 char *refs_resolve_refdup(struct ref_store
*refs
,
267 const char *refname
, int resolve_flags
,
268 struct object_id
*oid
, int *flags
)
273 result
= refs_werrres_ref_unsafe(refs
, refname
, resolve_flags
,
274 oid
, flags
, &ignore_errno
);
275 return xstrdup_or_null(result
);
278 char *resolve_refdup(const char *refname
, int resolve_flags
,
279 struct object_id
*oid
, int *flags
)
281 return refs_resolve_refdup(get_main_ref_store(the_repository
),
282 refname
, resolve_flags
,
286 /* The argument to filter_refs */
294 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
297 struct ref_store
*refs
= get_main_ref_store(the_repository
);
299 if (refs_werrres_ref_unsafe(refs
, refname
, resolve_flags
,
300 oid
, flags
, &ignore_errno
))
305 int read_ref(const char *refname
, struct object_id
*oid
)
307 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
310 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
313 return !!refs_werrres_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
,
314 NULL
, NULL
, &ignore_errno
);
317 int ref_exists(const char *refname
)
319 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
322 static int filter_refs(const char *refname
, const struct object_id
*oid
,
323 int flags
, void *data
)
325 struct ref_filter
*filter
= (struct ref_filter
*)data
;
327 if (wildmatch(filter
->pattern
, refname
, 0))
330 skip_prefix(refname
, filter
->prefix
, &refname
);
331 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
334 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
336 struct object
*o
= lookup_unknown_object(the_repository
, name
);
338 if (o
->type
== OBJ_NONE
) {
339 int type
= oid_object_info(the_repository
, name
, NULL
);
340 if (type
< 0 || !object_as_type(o
, type
, 0))
344 if (o
->type
!= OBJ_TAG
)
347 o
= deref_tag_noverify(o
);
351 oidcpy(oid
, &o
->oid
);
355 struct warn_if_dangling_data
{
358 const struct string_list
*refnames
;
362 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
363 int flags
, void *cb_data
)
365 struct warn_if_dangling_data
*d
= cb_data
;
366 const char *resolves_to
;
368 if (!(flags
& REF_ISSYMREF
))
371 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
374 ? strcmp(resolves_to
, d
->refname
)
375 : !string_list_has_string(d
->refnames
, resolves_to
))) {
379 fprintf(d
->fp
, d
->msg_fmt
, refname
);
384 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
386 struct warn_if_dangling_data data
;
389 data
.refname
= refname
;
390 data
.refnames
= NULL
;
391 data
.msg_fmt
= msg_fmt
;
392 for_each_rawref(warn_if_dangling_symref
, &data
);
395 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
397 struct warn_if_dangling_data data
;
401 data
.refnames
= refnames
;
402 data
.msg_fmt
= msg_fmt
;
403 for_each_rawref(warn_if_dangling_symref
, &data
);
406 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
408 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
411 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
413 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
416 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
418 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
421 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
423 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
426 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
428 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
431 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
433 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
436 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
438 struct strbuf buf
= STRBUF_INIT
;
440 struct object_id oid
;
443 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
444 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
445 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
446 strbuf_release(&buf
);
451 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
454 struct strbuf normalized_pattern
= STRBUF_INIT
;
457 BUG("pattern must not start with '/'");
460 strbuf_addstr(&normalized_pattern
, prefix
);
462 else if (!starts_with(pattern
, "refs/"))
463 strbuf_addstr(&normalized_pattern
, "refs/");
464 strbuf_addstr(&normalized_pattern
, pattern
);
465 strbuf_strip_suffix(&normalized_pattern
, "/");
467 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
468 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
469 strbuf_release(&normalized_pattern
);
472 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
473 const char *prefix
, void *cb_data
)
475 struct strbuf real_pattern
= STRBUF_INIT
;
476 struct ref_filter filter
;
479 if (!prefix
&& !starts_with(pattern
, "refs/"))
480 strbuf_addstr(&real_pattern
, "refs/");
482 strbuf_addstr(&real_pattern
, prefix
);
483 strbuf_addstr(&real_pattern
, pattern
);
485 if (!has_glob_specials(pattern
)) {
486 /* Append implied '/' '*' if not present. */
487 strbuf_complete(&real_pattern
, '/');
488 /* No need to check for '*', there is none. */
489 strbuf_addch(&real_pattern
, '*');
492 filter
.pattern
= real_pattern
.buf
;
493 filter
.prefix
= prefix
;
495 filter
.cb_data
= cb_data
;
496 ret
= for_each_ref(filter_refs
, &filter
);
498 strbuf_release(&real_pattern
);
502 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
504 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
507 const char *prettify_refname(const char *name
)
509 if (skip_prefix(name
, "refs/heads/", &name
) ||
510 skip_prefix(name
, "refs/tags/", &name
) ||
511 skip_prefix(name
, "refs/remotes/", &name
))
516 static const char *ref_rev_parse_rules
[] = {
522 "refs/remotes/%.*s/HEAD",
526 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
529 * Is it possible that the caller meant full_name with abbrev_name?
530 * If so return a non-zero value to signal "yes"; the magnitude of
531 * the returned value gives the precedence used for disambiguation.
533 * If abbrev_name cannot mean full_name, return 0.
535 int refname_match(const char *abbrev_name
, const char *full_name
)
538 const int abbrev_name_len
= strlen(abbrev_name
);
539 const int num_rules
= NUM_REV_PARSE_RULES
;
541 for (p
= ref_rev_parse_rules
; *p
; p
++)
542 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
543 return &ref_rev_parse_rules
[num_rules
] - p
;
549 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
550 * the results to 'prefixes'
552 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
555 int len
= strlen(prefix
);
557 for (p
= ref_rev_parse_rules
; *p
; p
++)
558 strvec_pushf(prefixes
, *p
, len
, prefix
);
561 static const char default_branch_name_advice
[] = N_(
562 "Using '%s' as the name for the initial branch. This default branch name\n"
563 "is subject to change. To configure the initial branch name to use in all\n"
564 "of your new repositories, which will suppress this warning, call:\n"
566 "\tgit config --global init.defaultBranch <name>\n"
568 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
569 "'development'. The just-created branch can be renamed via this command:\n"
571 "\tgit branch -m <name>\n"
574 char *repo_default_branch_name(struct repository
*r
, int quiet
)
576 const char *config_key
= "init.defaultbranch";
577 const char *config_display_key
= "init.defaultBranch";
578 char *ret
= NULL
, *full_ref
;
579 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
583 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
584 die(_("could not retrieve `%s`"), config_display_key
);
587 ret
= xstrdup("master");
589 advise(_(default_branch_name_advice
), ret
);
592 full_ref
= xstrfmt("refs/heads/%s", ret
);
593 if (check_refname_format(full_ref
, 0))
594 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
600 const char *git_default_branch_name(int quiet
)
605 ret
= repo_default_branch_name(the_repository
, quiet
);
611 * *string and *len will only be substituted, and *string returned (for
612 * later free()ing) if the string passed in is a magic short-hand form
615 static char *substitute_branch_name(struct repository
*r
,
616 const char **string
, int *len
,
617 int nonfatal_dangling_mark
)
619 struct strbuf buf
= STRBUF_INIT
;
620 struct interpret_branch_name_options options
= {
621 .nonfatal_dangling_mark
= nonfatal_dangling_mark
623 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
627 *string
= strbuf_detach(&buf
, &size
);
629 return (char *)*string
;
635 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
636 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
638 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
639 nonfatal_dangling_mark
);
640 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
645 int expand_ref(struct repository
*repo
, const char *str
, int len
,
646 struct object_id
*oid
, char **ref
)
650 struct strbuf fullref
= STRBUF_INIT
;
653 for (p
= ref_rev_parse_rules
; *p
; p
++) {
654 struct object_id oid_from_ref
;
655 struct object_id
*this_result
;
658 this_result
= refs_found
? &oid_from_ref
: oid
;
659 strbuf_reset(&fullref
);
660 strbuf_addf(&fullref
, *p
, len
, str
);
661 r
= refs_resolve_ref_unsafe(get_main_ref_store(repo
),
662 fullref
.buf
, RESOLVE_REF_READING
,
667 if (!warn_ambiguous_refs
)
669 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
670 warning(_("ignoring dangling symref %s"), fullref
.buf
);
671 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
672 warning(_("ignoring broken ref %s"), fullref
.buf
);
675 strbuf_release(&fullref
);
679 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
680 struct object_id
*oid
, char **log
)
682 struct ref_store
*refs
= get_main_ref_store(r
);
683 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
686 struct strbuf path
= STRBUF_INIT
;
689 for (p
= ref_rev_parse_rules
; *p
; p
++) {
690 struct object_id hash
;
691 const char *ref
, *it
;
694 strbuf_addf(&path
, *p
, len
, str
);
695 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
697 oid
? &hash
: NULL
, NULL
);
700 if (refs_reflog_exists(refs
, path
.buf
))
702 else if (strcmp(ref
, path
.buf
) &&
703 refs_reflog_exists(refs
, ref
))
712 if (!warn_ambiguous_refs
)
715 strbuf_release(&path
);
720 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
722 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
725 static int is_per_worktree_ref(const char *refname
)
727 return starts_with(refname
, "refs/worktree/") ||
728 starts_with(refname
, "refs/bisect/") ||
729 starts_with(refname
, "refs/rewritten/");
732 static int is_pseudoref_syntax(const char *refname
)
736 for (c
= refname
; *c
; c
++) {
737 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
744 static int is_main_pseudoref_syntax(const char *refname
)
746 return skip_prefix(refname
, "main-worktree/", &refname
) &&
748 is_pseudoref_syntax(refname
);
751 static int is_other_pseudoref_syntax(const char *refname
)
753 if (!skip_prefix(refname
, "worktrees/", &refname
))
755 refname
= strchr(refname
, '/');
756 if (!refname
|| !refname
[1])
758 return is_pseudoref_syntax(refname
+ 1);
761 enum ref_type
ref_type(const char *refname
)
763 if (is_per_worktree_ref(refname
))
764 return REF_TYPE_PER_WORKTREE
;
765 if (is_pseudoref_syntax(refname
))
766 return REF_TYPE_PSEUDOREF
;
767 if (is_main_pseudoref_syntax(refname
))
768 return REF_TYPE_MAIN_PSEUDOREF
;
769 if (is_other_pseudoref_syntax(refname
))
770 return REF_TYPE_OTHER_PSEUDOREF
;
771 return REF_TYPE_NORMAL
;
774 long get_files_ref_lock_timeout_ms(void)
776 static int configured
= 0;
778 /* The default timeout is 100 ms: */
779 static int timeout_ms
= 100;
782 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
789 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
791 const struct object_id
*old_oid
,
794 struct ref_transaction
*transaction
;
795 struct strbuf err
= STRBUF_INIT
;
797 transaction
= ref_store_transaction_begin(refs
, &err
);
799 ref_transaction_delete(transaction
, refname
, old_oid
,
801 ref_transaction_commit(transaction
, &err
)) {
802 error("%s", err
.buf
);
803 ref_transaction_free(transaction
);
804 strbuf_release(&err
);
807 ref_transaction_free(transaction
);
808 strbuf_release(&err
);
812 int delete_ref(const char *msg
, const char *refname
,
813 const struct object_id
*old_oid
, unsigned int flags
)
815 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
819 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
824 while ((c
= *msg
++)) {
825 if (wasspace
&& isspace(c
))
827 wasspace
= isspace(c
);
835 static char *normalize_reflog_message(const char *msg
)
837 struct strbuf sb
= STRBUF_INIT
;
840 copy_reflog_msg(&sb
, msg
);
841 return strbuf_detach(&sb
, NULL
);
844 int should_autocreate_reflog(const char *refname
)
846 switch (log_all_ref_updates
) {
847 case LOG_REFS_ALWAYS
:
849 case LOG_REFS_NORMAL
:
850 return starts_with(refname
, "refs/heads/") ||
851 starts_with(refname
, "refs/remotes/") ||
852 starts_with(refname
, "refs/notes/") ||
853 !strcmp(refname
, "HEAD");
859 int is_branch(const char *refname
)
861 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
864 struct read_ref_at_cb
{
869 struct object_id
*oid
;
872 struct object_id ooid
;
873 struct object_id noid
;
877 timestamp_t
*cutoff_time
;
882 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
883 timestamp_t timestamp
, int tz
, const char *message
)
886 *cb
->msg
= xstrdup(message
);
888 *cb
->cutoff_time
= timestamp
;
892 *cb
->cutoff_cnt
= cb
->reccnt
;
895 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
896 const char *email
, timestamp_t timestamp
, int tz
,
897 const char *message
, void *cb_data
)
899 struct read_ref_at_cb
*cb
= cb_data
;
903 cb
->date
= timestamp
;
906 * It is not possible for cb->cnt == 0 on the first iteration because
907 * that special case is handled in read_ref_at().
911 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
912 if (timestamp
<= cb
->at_time
|| reached_count
) {
913 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
915 * we have not yet updated cb->[n|o]oid so they still
916 * hold the values for the previous record.
918 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
919 warning(_("log for ref %s has gap after %s"),
920 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
922 oidcpy(cb
->oid
, ooid
);
923 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
924 oidcpy(cb
->oid
, noid
);
925 else if (!oideq(noid
, cb
->oid
))
926 warning(_("log for ref %s unexpectedly ended on %s"),
927 cb
->refname
, show_date(cb
->date
, cb
->tz
,
928 DATE_MODE(RFC2822
)));
932 oidcpy(&cb
->ooid
, ooid
);
933 oidcpy(&cb
->noid
, noid
);
937 static int read_ref_at_ent_newest(struct object_id
*ooid
, struct object_id
*noid
,
938 const char *email
, timestamp_t timestamp
,
939 int tz
, const char *message
, void *cb_data
)
941 struct read_ref_at_cb
*cb
= cb_data
;
943 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
944 oidcpy(cb
->oid
, noid
);
945 /* We just want the first entry */
949 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
950 const char *email
, timestamp_t timestamp
,
951 int tz
, const char *message
, void *cb_data
)
953 struct read_ref_at_cb
*cb
= cb_data
;
955 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
956 oidcpy(cb
->oid
, ooid
);
957 if (is_null_oid(cb
->oid
))
958 oidcpy(cb
->oid
, noid
);
959 /* We just want the first entry */
963 int read_ref_at(struct ref_store
*refs
, const char *refname
,
964 unsigned int flags
, timestamp_t at_time
, int cnt
,
965 struct object_id
*oid
, char **msg
,
966 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
968 struct read_ref_at_cb cb
;
970 memset(&cb
, 0, sizeof(cb
));
971 cb
.refname
= refname
;
972 cb
.at_time
= at_time
;
975 cb
.cutoff_time
= cutoff_time
;
976 cb
.cutoff_tz
= cutoff_tz
;
977 cb
.cutoff_cnt
= cutoff_cnt
;
981 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
985 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
988 if (flags
& GET_OID_QUIETLY
)
991 die(_("log for %s is empty"), refname
);
996 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1001 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1004 struct ref_transaction
*tr
;
1007 CALLOC_ARRAY(tr
, 1);
1008 tr
->ref_store
= refs
;
1012 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1014 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1017 void ref_transaction_free(struct ref_transaction
*transaction
)
1024 switch (transaction
->state
) {
1025 case REF_TRANSACTION_OPEN
:
1026 case REF_TRANSACTION_CLOSED
:
1029 case REF_TRANSACTION_PREPARED
:
1030 BUG("free called on a prepared reference transaction");
1033 BUG("unexpected reference transaction state");
1037 for (i
= 0; i
< transaction
->nr
; i
++) {
1038 free(transaction
->updates
[i
]->msg
);
1039 free(transaction
->updates
[i
]);
1041 free(transaction
->updates
);
1045 struct ref_update
*ref_transaction_add_update(
1046 struct ref_transaction
*transaction
,
1047 const char *refname
, unsigned int flags
,
1048 const struct object_id
*new_oid
,
1049 const struct object_id
*old_oid
,
1052 struct ref_update
*update
;
1054 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1055 BUG("update called for transaction that is not open");
1057 FLEX_ALLOC_STR(update
, refname
, refname
);
1058 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1059 transaction
->updates
[transaction
->nr
++] = update
;
1061 update
->flags
= flags
;
1063 if (flags
& REF_HAVE_NEW
)
1064 oidcpy(&update
->new_oid
, new_oid
);
1065 if (flags
& REF_HAVE_OLD
)
1066 oidcpy(&update
->old_oid
, old_oid
);
1067 update
->msg
= normalize_reflog_message(msg
);
1071 int ref_transaction_update(struct ref_transaction
*transaction
,
1072 const char *refname
,
1073 const struct object_id
*new_oid
,
1074 const struct object_id
*old_oid
,
1075 unsigned int flags
, const char *msg
,
1080 if ((new_oid
&& !is_null_oid(new_oid
)) ?
1081 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1082 !refname_is_safe(refname
)) {
1083 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1088 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1089 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1091 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1093 ref_transaction_add_update(transaction
, refname
, flags
,
1094 new_oid
, old_oid
, msg
);
1098 int ref_transaction_create(struct ref_transaction
*transaction
,
1099 const char *refname
,
1100 const struct object_id
*new_oid
,
1101 unsigned int flags
, const char *msg
,
1104 if (!new_oid
|| is_null_oid(new_oid
))
1105 BUG("create called without valid new_oid");
1106 return ref_transaction_update(transaction
, refname
, new_oid
,
1107 null_oid(), flags
, msg
, err
);
1110 int ref_transaction_delete(struct ref_transaction
*transaction
,
1111 const char *refname
,
1112 const struct object_id
*old_oid
,
1113 unsigned int flags
, const char *msg
,
1116 if (old_oid
&& is_null_oid(old_oid
))
1117 BUG("delete called with old_oid set to zeros");
1118 return ref_transaction_update(transaction
, refname
,
1119 null_oid(), old_oid
,
1123 int ref_transaction_verify(struct ref_transaction
*transaction
,
1124 const char *refname
,
1125 const struct object_id
*old_oid
,
1130 BUG("verify called with old_oid set to NULL");
1131 return ref_transaction_update(transaction
, refname
,
1136 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1137 const char *refname
, const struct object_id
*new_oid
,
1138 const struct object_id
*old_oid
, unsigned int flags
,
1139 enum action_on_err onerr
)
1141 struct ref_transaction
*t
= NULL
;
1142 struct strbuf err
= STRBUF_INIT
;
1145 t
= ref_store_transaction_begin(refs
, &err
);
1147 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1149 ref_transaction_commit(t
, &err
)) {
1151 ref_transaction_free(t
);
1154 const char *str
= _("update_ref failed for ref '%s': %s");
1157 case UPDATE_REFS_MSG_ON_ERR
:
1158 error(str
, refname
, err
.buf
);
1160 case UPDATE_REFS_DIE_ON_ERR
:
1161 die(str
, refname
, err
.buf
);
1163 case UPDATE_REFS_QUIET_ON_ERR
:
1166 strbuf_release(&err
);
1169 strbuf_release(&err
);
1171 ref_transaction_free(t
);
1175 int update_ref(const char *msg
, const char *refname
,
1176 const struct object_id
*new_oid
,
1177 const struct object_id
*old_oid
,
1178 unsigned int flags
, enum action_on_err onerr
)
1180 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1181 old_oid
, flags
, onerr
);
1184 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1185 const char *refname
, int strict
)
1188 static char **scanf_fmts
;
1189 static int nr_rules
;
1191 struct strbuf resolved_buf
= STRBUF_INIT
;
1195 * Pre-generate scanf formats from ref_rev_parse_rules[].
1196 * Generate a format suitable for scanf from a
1197 * ref_rev_parse_rules rule by interpolating "%s" at the
1198 * location of the "%.*s".
1200 size_t total_len
= 0;
1203 /* the rule list is NULL terminated, count them first */
1204 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1205 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1206 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1208 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1211 for (i
= 0; i
< nr_rules
; i
++) {
1212 assert(offset
< total_len
);
1213 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1214 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1215 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1219 /* bail out if there are no rules */
1221 return xstrdup(refname
);
1223 /* buffer for scanf result, at most refname must fit */
1224 short_name
= xstrdup(refname
);
1226 /* skip first rule, it will always match */
1227 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1229 int rules_to_fail
= i
;
1232 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1235 short_name_len
= strlen(short_name
);
1238 * in strict mode, all (except the matched one) rules
1239 * must fail to resolve to a valid non-ambiguous ref
1242 rules_to_fail
= nr_rules
;
1245 * check if the short name resolves to a valid ref,
1246 * but use only rules prior to the matched one
1248 for (j
= 0; j
< rules_to_fail
; j
++) {
1249 const char *rule
= ref_rev_parse_rules
[j
];
1251 /* skip matched rule */
1256 * the short name is ambiguous, if it resolves
1257 * (with this previous rule) to a valid ref
1258 * read_ref() returns 0 on success
1260 strbuf_reset(&resolved_buf
);
1261 strbuf_addf(&resolved_buf
, rule
,
1262 short_name_len
, short_name
);
1263 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1268 * short name is non-ambiguous if all previous rules
1269 * haven't resolved to a valid ref
1271 if (j
== rules_to_fail
) {
1272 strbuf_release(&resolved_buf
);
1277 strbuf_release(&resolved_buf
);
1279 return xstrdup(refname
);
1282 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1284 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1288 static struct string_list
*hide_refs
;
1290 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1293 if (!strcmp("transfer.hiderefs", var
) ||
1294 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1295 !strcmp(key
, "hiderefs"))) {
1300 return config_error_nonbool(var
);
1301 ref
= xstrdup(value
);
1303 while (len
&& ref
[len
- 1] == '/')
1306 CALLOC_ARRAY(hide_refs
, 1);
1307 hide_refs
->strdup_strings
= 1;
1309 string_list_append(hide_refs
, ref
);
1314 int ref_is_hidden(const char *refname
, const char *refname_full
)
1320 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1321 const char *match
= hide_refs
->items
[i
].string
;
1322 const char *subject
;
1326 if (*match
== '!') {
1331 if (*match
== '^') {
1332 subject
= refname_full
;
1338 /* refname can be NULL when namespaces are used. */
1340 skip_prefix(subject
, match
, &p
) &&
1347 const char *find_descendant_ref(const char *dirname
,
1348 const struct string_list
*extras
,
1349 const struct string_list
*skip
)
1357 * Look at the place where dirname would be inserted into
1358 * extras. If there is an entry at that position that starts
1359 * with dirname (remember, dirname includes the trailing
1360 * slash) and is not in skip, then we have a conflict.
1362 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1363 pos
< extras
->nr
; pos
++) {
1364 const char *extra_refname
= extras
->items
[pos
].string
;
1366 if (!starts_with(extra_refname
, dirname
))
1369 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1370 return extra_refname
;
1375 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1377 struct object_id oid
;
1381 if (refs_werrres_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1382 &oid
, &flag
, &ignore_errno
))
1383 return fn("HEAD", &oid
, flag
, cb_data
);
1388 int head_ref(each_ref_fn fn
, void *cb_data
)
1390 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1393 struct ref_iterator
*refs_ref_iterator_begin(
1394 struct ref_store
*refs
,
1395 const char *prefix
, int trim
,
1396 enum do_for_each_ref_flags flags
)
1398 struct ref_iterator
*iter
;
1400 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1401 static int ref_paranoia
= -1;
1403 if (ref_paranoia
< 0)
1404 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1406 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1407 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1411 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1414 * `iterator_begin()` already takes care of prefix, but we
1415 * might need to do some trimming:
1418 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1420 /* Sanity check for subclasses: */
1422 BUG("reference iterator is not ordered");
1428 * Call fn for each reference in the specified submodule for which the
1429 * refname begins with prefix. If trim is non-zero, then trim that
1430 * many characters off the beginning of each refname before passing
1431 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1432 * include broken references in the iteration. If fn ever returns a
1433 * non-zero value, stop the iteration and return that value;
1434 * otherwise, return 0.
1436 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1437 each_repo_ref_fn fn
, int trim
, int flags
,
1440 struct ref_iterator
*iter
;
1441 struct ref_store
*refs
= get_main_ref_store(r
);
1446 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1448 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1451 struct do_for_each_ref_help
{
1456 static int do_for_each_ref_helper(struct repository
*r
,
1457 const char *refname
,
1458 const struct object_id
*oid
,
1462 struct do_for_each_ref_help
*hp
= cb_data
;
1464 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1467 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1468 each_ref_fn fn
, int trim
,
1469 enum do_for_each_ref_flags flags
, void *cb_data
)
1471 struct ref_iterator
*iter
;
1472 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1477 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1479 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1480 do_for_each_ref_helper
, &hp
);
1483 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1485 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1488 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1490 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1493 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1494 each_ref_fn fn
, void *cb_data
)
1496 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1499 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1501 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1504 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1506 return do_for_each_ref(get_main_ref_store(the_repository
),
1507 prefix
, fn
, 0, 0, cb_data
);
1510 int refs_for_each_fullref_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
, 0, 0, cb_data
);
1516 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1518 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1519 strlen(git_replace_ref_base
),
1520 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1523 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1525 struct strbuf buf
= STRBUF_INIT
;
1527 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1528 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1529 buf
.buf
, fn
, 0, 0, cb_data
);
1530 strbuf_release(&buf
);
1534 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1536 return do_for_each_ref(refs
, "", fn
, 0,
1537 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1540 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1542 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1545 static int qsort_strcmp(const void *va
, const void *vb
)
1547 const char *a
= *(const char **)va
;
1548 const char *b
= *(const char **)vb
;
1550 return strcmp(a
, b
);
1553 static void find_longest_prefixes_1(struct string_list
*out
,
1554 struct strbuf
*prefix
,
1555 const char **patterns
, size_t nr
)
1559 for (i
= 0; i
< nr
; i
++) {
1560 char c
= patterns
[i
][prefix
->len
];
1561 if (!c
|| is_glob_special(c
)) {
1562 string_list_append(out
, prefix
->buf
);
1572 * Set "end" to the index of the element _after_ the last one
1575 for (end
= i
+ 1; end
< nr
; end
++) {
1576 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1580 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1581 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1582 strbuf_setlen(prefix
, prefix
->len
- 1);
1588 static void find_longest_prefixes(struct string_list
*out
,
1589 const char **patterns
)
1591 struct strvec sorted
= STRVEC_INIT
;
1592 struct strbuf prefix
= STRBUF_INIT
;
1594 strvec_pushv(&sorted
, patterns
);
1595 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1597 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1599 strvec_clear(&sorted
);
1600 strbuf_release(&prefix
);
1603 int for_each_fullref_in_prefixes(const char *namespace,
1604 const char **patterns
,
1605 each_ref_fn fn
, void *cb_data
)
1607 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1608 struct string_list_item
*prefix
;
1609 struct strbuf buf
= STRBUF_INIT
;
1610 int ret
= 0, namespace_len
;
1612 find_longest_prefixes(&prefixes
, patterns
);
1615 strbuf_addstr(&buf
, namespace);
1616 namespace_len
= buf
.len
;
1618 for_each_string_list_item(prefix
, &prefixes
) {
1619 strbuf_addstr(&buf
, prefix
->string
);
1620 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
);
1623 strbuf_setlen(&buf
, namespace_len
);
1626 string_list_clear(&prefixes
, 0);
1627 strbuf_release(&buf
);
1631 static int refs_read_special_head(struct ref_store
*ref_store
,
1632 const char *refname
, struct object_id
*oid
,
1633 struct strbuf
*referent
, unsigned int *type
,
1636 struct strbuf full_path
= STRBUF_INIT
;
1637 struct strbuf content
= STRBUF_INIT
;
1639 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1641 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1644 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1648 strbuf_release(&full_path
);
1649 strbuf_release(&content
);
1653 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1654 struct object_id
*oid
, struct strbuf
*referent
,
1655 unsigned int *type
, int *failure_errno
)
1657 assert(failure_errno
);
1658 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1659 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1660 type
, failure_errno
);
1663 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1664 type
, failure_errno
);
1667 const char *refs_werrres_ref_unsafe(struct ref_store
*refs
,
1668 const char *refname
,
1670 struct object_id
*oid
,
1671 int *flags
, int *failure_errno
)
1673 static struct strbuf sb_refname
= STRBUF_INIT
;
1674 struct object_id unused_oid
;
1678 assert(failure_errno
);
1683 flags
= &unused_flags
;
1687 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1688 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1689 !refname_is_safe(refname
)) {
1690 *failure_errno
= EINVAL
;
1695 * dwim_ref() uses REF_ISBROKEN to distinguish between
1696 * missing refs and refs that were present but invalid,
1697 * to complain about the latter to stderr.
1699 * We don't know whether the ref exists, so don't set
1702 *flags
|= REF_BAD_NAME
;
1705 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1706 unsigned int read_flags
= 0;
1708 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1709 &read_flags
, failure_errno
)) {
1710 *flags
|= read_flags
;
1712 *failure_errno
= errno
;
1714 /* In reading mode, refs must eventually resolve */
1715 if (resolve_flags
& RESOLVE_REF_READING
)
1719 * Otherwise a missing ref is OK. But the files backend
1720 * may show errors besides ENOENT if there are
1721 * similarly-named refs.
1723 if (*failure_errno
!= ENOENT
&&
1724 *failure_errno
!= EISDIR
&&
1725 *failure_errno
!= ENOTDIR
)
1729 if (*flags
& REF_BAD_NAME
)
1730 *flags
|= REF_ISBROKEN
;
1734 *flags
|= read_flags
;
1736 if (!(read_flags
& REF_ISSYMREF
)) {
1737 if (*flags
& REF_BAD_NAME
) {
1739 *flags
|= REF_ISBROKEN
;
1744 refname
= sb_refname
.buf
;
1745 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1749 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1750 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1751 !refname_is_safe(refname
)) {
1752 *failure_errno
= EINVAL
;
1756 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1760 *failure_errno
= ELOOP
;
1764 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
, const char *refname
,
1765 int resolve_flags
, struct object_id
*oid
,
1768 int failure_errno
= 0;
1770 refn
= refs_werrres_ref_unsafe(refs
, refname
, resolve_flags
,
1771 oid
, flags
, &failure_errno
);
1773 errno
= failure_errno
;
1777 /* backend functions */
1778 int refs_init_db(struct strbuf
*err
)
1780 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1782 return refs
->be
->init_db(refs
, err
);
1785 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1786 struct object_id
*oid
, int *flags
)
1790 return refs_werrres_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1791 resolve_flags
, oid
, flags
, &ignore_errno
);
1794 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1795 struct object_id
*oid
)
1797 struct ref_store
*refs
;
1801 refs
= get_submodule_ref_store(submodule
);
1806 if (!refs_werrres_ref_unsafe(refs
, refname
, 0, oid
, &flags
,
1807 &ignore_errno
) || is_null_oid(oid
))
1812 struct ref_store_hash_entry
1814 struct hashmap_entry ent
;
1816 struct ref_store
*refs
;
1818 /* NUL-terminated identifier of the ref store: */
1819 char name
[FLEX_ARRAY
];
1822 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1823 const struct hashmap_entry
*eptr
,
1824 const struct hashmap_entry
*entry_or_key
,
1825 const void *keydata
)
1827 const struct ref_store_hash_entry
*e1
, *e2
;
1830 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1831 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1832 name
= keydata
? keydata
: e2
->name
;
1834 return strcmp(e1
->name
, name
);
1837 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1838 const char *name
, struct ref_store
*refs
)
1840 struct ref_store_hash_entry
*entry
;
1842 FLEX_ALLOC_STR(entry
, name
, name
);
1843 hashmap_entry_init(&entry
->ent
, strhash(name
));
1848 /* A hashmap of ref_stores, stored by submodule name: */
1849 static struct hashmap submodule_ref_stores
;
1851 /* A hashmap of ref_stores, stored by worktree id: */
1852 static struct hashmap worktree_ref_stores
;
1855 * Look up a ref store by name. If that ref_store hasn't been
1856 * registered yet, return NULL.
1858 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1861 struct ref_store_hash_entry
*entry
;
1864 if (!map
->tablesize
)
1865 /* It's initialized on demand in register_ref_store(). */
1868 hash
= strhash(name
);
1869 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1870 struct ref_store_hash_entry
, ent
);
1871 return entry
? entry
->refs
: NULL
;
1875 * Create, record, and return a ref_store instance for the specified
1878 static struct ref_store
*ref_store_init(const char *gitdir
,
1881 const char *be_name
= "files";
1882 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1883 struct ref_store
*refs
;
1886 BUG("reference backend %s is unknown", be_name
);
1888 refs
= be
->init(gitdir
, flags
);
1892 struct ref_store
*get_main_ref_store(struct repository
*r
)
1894 if (r
->refs_private
)
1895 return r
->refs_private
;
1898 BUG("attempting to get main_ref_store outside of repository");
1900 r
->refs_private
= ref_store_init(r
->gitdir
, REF_STORE_ALL_CAPS
);
1901 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1902 return r
->refs_private
;
1906 * Associate a ref store with a name. It is a fatal error to call this
1907 * function twice for the same name.
1909 static void register_ref_store_map(struct hashmap
*map
,
1911 struct ref_store
*refs
,
1914 struct ref_store_hash_entry
*entry
;
1916 if (!map
->tablesize
)
1917 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1919 entry
= alloc_ref_store_hash_entry(name
, refs
);
1920 if (hashmap_put(map
, &entry
->ent
))
1921 BUG("%s ref_store '%s' initialized twice", type
, name
);
1924 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1926 struct strbuf submodule_sb
= STRBUF_INIT
;
1927 struct ref_store
*refs
;
1928 char *to_free
= NULL
;
1934 len
= strlen(submodule
);
1935 while (len
&& is_dir_sep(submodule
[len
- 1]))
1941 /* We need to strip off one or more trailing slashes */
1942 submodule
= to_free
= xmemdupz(submodule
, len
);
1944 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1948 strbuf_addstr(&submodule_sb
, submodule
);
1949 if (!is_nonbare_repository_dir(&submodule_sb
))
1952 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1955 /* assume that add_submodule_odb() has been called */
1956 refs
= ref_store_init(submodule_sb
.buf
,
1957 REF_STORE_READ
| REF_STORE_ODB
);
1958 register_ref_store_map(&submodule_ref_stores
, "submodule",
1962 strbuf_release(&submodule_sb
);
1968 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1970 struct ref_store
*refs
;
1974 return get_main_ref_store(the_repository
);
1976 id
= wt
->id
? wt
->id
: "/";
1977 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1982 refs
= ref_store_init(git_common_path("worktrees/%s", wt
->id
),
1983 REF_STORE_ALL_CAPS
);
1985 refs
= ref_store_init(get_git_common_dir(),
1986 REF_STORE_ALL_CAPS
);
1989 register_ref_store_map(&worktree_ref_stores
, "worktree",
1994 void base_ref_store_init(struct ref_store
*refs
,
1995 const struct ref_storage_be
*be
)
2000 /* backend functions */
2001 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
2003 return refs
->be
->pack_refs(refs
, flags
);
2006 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2008 if (current_ref_iter
&&
2009 (current_ref_iter
->oid
== base
||
2010 oideq(current_ref_iter
->oid
, base
)))
2011 return ref_iterator_peel(current_ref_iter
, peeled
);
2013 return peel_object(base
, peeled
) ? -1 : 0;
2016 int refs_create_symref(struct ref_store
*refs
,
2017 const char *ref_target
,
2018 const char *refs_heads_master
,
2024 msg
= normalize_reflog_message(logmsg
);
2025 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2031 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2034 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2035 refs_heads_master
, logmsg
);
2038 int ref_update_reject_duplicates(struct string_list
*refnames
,
2041 size_t i
, n
= refnames
->nr
;
2045 for (i
= 1; i
< n
; i
++) {
2046 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2047 refnames
->items
[i
].string
);
2051 _("multiple updates for ref '%s' not allowed"),
2052 refnames
->items
[i
].string
);
2054 } else if (cmp
> 0) {
2055 BUG("ref_update_reject_duplicates() received unsorted list");
2061 static int run_transaction_hook(struct ref_transaction
*transaction
,
2064 struct child_process proc
= CHILD_PROCESS_INIT
;
2065 struct strbuf buf
= STRBUF_INIT
;
2069 hook
= find_hook("reference-transaction");
2073 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2075 proc
.stdout_to_stderr
= 1;
2076 proc
.trace2_hook_name
= "reference-transaction";
2078 ret
= start_command(&proc
);
2082 sigchain_push(SIGPIPE
, SIG_IGN
);
2084 for (i
= 0; i
< transaction
->nr
; i
++) {
2085 struct ref_update
*update
= transaction
->updates
[i
];
2088 strbuf_addf(&buf
, "%s %s %s\n",
2089 oid_to_hex(&update
->old_oid
),
2090 oid_to_hex(&update
->new_oid
),
2093 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2101 sigchain_pop(SIGPIPE
);
2102 strbuf_release(&buf
);
2104 ret
|= finish_command(&proc
);
2108 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2111 struct ref_store
*refs
= transaction
->ref_store
;
2114 switch (transaction
->state
) {
2115 case REF_TRANSACTION_OPEN
:
2118 case REF_TRANSACTION_PREPARED
:
2119 BUG("prepare called twice on reference transaction");
2121 case REF_TRANSACTION_CLOSED
:
2122 BUG("prepare called on a closed reference transaction");
2125 BUG("unexpected reference transaction state");
2129 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
2131 _("ref updates forbidden inside quarantine environment"));
2135 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2139 ret
= run_transaction_hook(transaction
, "prepared");
2141 ref_transaction_abort(transaction
, err
);
2142 die(_("ref updates aborted by hook"));
2148 int ref_transaction_abort(struct ref_transaction
*transaction
,
2151 struct ref_store
*refs
= transaction
->ref_store
;
2154 switch (transaction
->state
) {
2155 case REF_TRANSACTION_OPEN
:
2156 /* No need to abort explicitly. */
2158 case REF_TRANSACTION_PREPARED
:
2159 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2161 case REF_TRANSACTION_CLOSED
:
2162 BUG("abort called on a closed reference transaction");
2165 BUG("unexpected reference transaction state");
2169 run_transaction_hook(transaction
, "aborted");
2171 ref_transaction_free(transaction
);
2175 int ref_transaction_commit(struct ref_transaction
*transaction
,
2178 struct ref_store
*refs
= transaction
->ref_store
;
2181 switch (transaction
->state
) {
2182 case REF_TRANSACTION_OPEN
:
2183 /* Need to prepare first. */
2184 ret
= ref_transaction_prepare(transaction
, err
);
2188 case REF_TRANSACTION_PREPARED
:
2189 /* Fall through to finish. */
2191 case REF_TRANSACTION_CLOSED
:
2192 BUG("commit called on a closed reference transaction");
2195 BUG("unexpected reference transaction state");
2199 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2201 run_transaction_hook(transaction
, "committed");
2205 int refs_verify_refname_available(struct ref_store
*refs
,
2206 const char *refname
,
2207 const struct string_list
*extras
,
2208 const struct string_list
*skip
,
2212 const char *extra_refname
;
2213 struct strbuf dirname
= STRBUF_INIT
;
2214 struct strbuf referent
= STRBUF_INIT
;
2215 struct object_id oid
;
2217 struct ref_iterator
*iter
;
2222 * For the sake of comments in this function, suppose that
2223 * refname is "refs/foo/bar".
2228 strbuf_grow(&dirname
, strlen(refname
) + 1);
2229 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2231 * Just saying "Is a directory" when we e.g. can't
2232 * lock some multi-level ref isn't very informative,
2233 * the user won't be told *what* is a directory, so
2234 * let's not use strerror() below.
2237 /* Expand dirname to the new prefix, not including the trailing slash: */
2238 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2241 * We are still at a leading dir of the refname (e.g.,
2242 * "refs/foo"; if there is a reference with that name,
2243 * it is a conflict, *unless* it is in skip.
2245 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2248 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2249 &type
, &ignore_errno
)) {
2250 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2251 dirname
.buf
, refname
);
2255 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2256 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2257 refname
, dirname
.buf
);
2263 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2264 * There is no point in searching for a reference with that
2265 * name, because a refname isn't considered to conflict with
2266 * itself. But we still need to check for references whose
2267 * names are in the "refs/foo/bar/" namespace, because they
2270 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2271 strbuf_addch(&dirname
, '/');
2273 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2274 DO_FOR_EACH_INCLUDE_BROKEN
);
2275 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2277 string_list_has_string(skip
, iter
->refname
))
2280 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2281 iter
->refname
, refname
);
2282 ref_iterator_abort(iter
);
2286 if (ok
!= ITER_DONE
)
2287 BUG("error while iterating over references");
2289 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2291 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2292 refname
, extra_refname
);
2297 strbuf_release(&referent
);
2298 strbuf_release(&dirname
);
2302 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2304 struct ref_iterator
*iter
;
2305 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2307 iter
= refs
->be
->reflog_iterator_begin(refs
);
2309 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2310 do_for_each_ref_helper
, &hp
);
2313 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2315 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2318 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2319 const char *refname
,
2320 each_reflog_ent_fn fn
,
2323 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2327 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2330 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2331 refname
, fn
, cb_data
);
2334 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2335 each_reflog_ent_fn fn
, void *cb_data
)
2337 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2340 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2343 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2347 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2349 return refs
->be
->reflog_exists(refs
, refname
);
2352 int reflog_exists(const char *refname
)
2354 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2357 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2358 int force_create
, struct strbuf
*err
)
2360 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2363 int safe_create_reflog(const char *refname
, int force_create
,
2366 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2370 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2372 return refs
->be
->delete_reflog(refs
, refname
);
2375 int delete_reflog(const char *refname
)
2377 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2380 int refs_reflog_expire(struct ref_store
*refs
,
2381 const char *refname
,
2383 reflog_expiry_prepare_fn prepare_fn
,
2384 reflog_expiry_should_prune_fn should_prune_fn
,
2385 reflog_expiry_cleanup_fn cleanup_fn
,
2386 void *policy_cb_data
)
2388 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2389 prepare_fn
, should_prune_fn
,
2390 cleanup_fn
, policy_cb_data
);
2393 int reflog_expire(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_reflog_expire(get_main_ref_store(the_repository
),
2402 prepare_fn
, should_prune_fn
,
2403 cleanup_fn
, policy_cb_data
);
2406 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2409 struct ref_store
*refs
= transaction
->ref_store
;
2411 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2414 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2415 struct string_list
*refnames
, unsigned int flags
)
2420 msg
= normalize_reflog_message(logmsg
);
2421 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2426 int delete_refs(const char *msg
, struct string_list
*refnames
,
2429 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2432 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2433 const char *newref
, const char *logmsg
)
2438 msg
= normalize_reflog_message(logmsg
);
2439 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2444 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2446 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2449 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2450 const char *newref
, const char *logmsg
)
2455 msg
= normalize_reflog_message(logmsg
);
2456 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2461 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2463 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);