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
)
312 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
, NULL
, NULL
);
315 int ref_exists(const char *refname
)
317 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
320 static int filter_refs(const char *refname
, const struct object_id
*oid
,
321 int flags
, void *data
)
323 struct ref_filter
*filter
= (struct ref_filter
*)data
;
325 if (wildmatch(filter
->pattern
, refname
, 0))
328 skip_prefix(refname
, filter
->prefix
, &refname
);
329 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
332 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
334 struct object
*o
= lookup_unknown_object(the_repository
, name
);
336 if (o
->type
== OBJ_NONE
) {
337 int type
= oid_object_info(the_repository
, name
, NULL
);
338 if (type
< 0 || !object_as_type(o
, type
, 0))
342 if (o
->type
!= OBJ_TAG
)
345 o
= deref_tag_noverify(o
);
349 oidcpy(oid
, &o
->oid
);
353 struct warn_if_dangling_data
{
356 const struct string_list
*refnames
;
360 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
361 int flags
, void *cb_data
)
363 struct warn_if_dangling_data
*d
= cb_data
;
364 const char *resolves_to
;
366 if (!(flags
& REF_ISSYMREF
))
369 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
372 ? strcmp(resolves_to
, d
->refname
)
373 : !string_list_has_string(d
->refnames
, resolves_to
))) {
377 fprintf(d
->fp
, d
->msg_fmt
, refname
);
382 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
384 struct warn_if_dangling_data data
;
387 data
.refname
= refname
;
388 data
.refnames
= NULL
;
389 data
.msg_fmt
= msg_fmt
;
390 for_each_rawref(warn_if_dangling_symref
, &data
);
393 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
395 struct warn_if_dangling_data data
;
399 data
.refnames
= refnames
;
400 data
.msg_fmt
= msg_fmt
;
401 for_each_rawref(warn_if_dangling_symref
, &data
);
404 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
406 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
409 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
411 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
414 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
416 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
419 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
421 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
424 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
426 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
429 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
431 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
434 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
436 struct strbuf buf
= STRBUF_INIT
;
438 struct object_id oid
;
441 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
442 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
443 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
444 strbuf_release(&buf
);
449 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
452 struct strbuf normalized_pattern
= STRBUF_INIT
;
455 BUG("pattern must not start with '/'");
458 strbuf_addstr(&normalized_pattern
, prefix
);
460 else if (!starts_with(pattern
, "refs/"))
461 strbuf_addstr(&normalized_pattern
, "refs/");
462 strbuf_addstr(&normalized_pattern
, pattern
);
463 strbuf_strip_suffix(&normalized_pattern
, "/");
465 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
466 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
467 strbuf_release(&normalized_pattern
);
470 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
471 const char *prefix
, void *cb_data
)
473 struct strbuf real_pattern
= STRBUF_INIT
;
474 struct ref_filter filter
;
477 if (!prefix
&& !starts_with(pattern
, "refs/"))
478 strbuf_addstr(&real_pattern
, "refs/");
480 strbuf_addstr(&real_pattern
, prefix
);
481 strbuf_addstr(&real_pattern
, pattern
);
483 if (!has_glob_specials(pattern
)) {
484 /* Append implied '/' '*' if not present. */
485 strbuf_complete(&real_pattern
, '/');
486 /* No need to check for '*', there is none. */
487 strbuf_addch(&real_pattern
, '*');
490 filter
.pattern
= real_pattern
.buf
;
491 filter
.prefix
= prefix
;
493 filter
.cb_data
= cb_data
;
494 ret
= for_each_ref(filter_refs
, &filter
);
496 strbuf_release(&real_pattern
);
500 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
502 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
505 const char *prettify_refname(const char *name
)
507 if (skip_prefix(name
, "refs/heads/", &name
) ||
508 skip_prefix(name
, "refs/tags/", &name
) ||
509 skip_prefix(name
, "refs/remotes/", &name
))
514 static const char *ref_rev_parse_rules
[] = {
520 "refs/remotes/%.*s/HEAD",
524 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
527 * Is it possible that the caller meant full_name with abbrev_name?
528 * If so return a non-zero value to signal "yes"; the magnitude of
529 * the returned value gives the precedence used for disambiguation.
531 * If abbrev_name cannot mean full_name, return 0.
533 int refname_match(const char *abbrev_name
, const char *full_name
)
536 const int abbrev_name_len
= strlen(abbrev_name
);
537 const int num_rules
= NUM_REV_PARSE_RULES
;
539 for (p
= ref_rev_parse_rules
; *p
; p
++)
540 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
541 return &ref_rev_parse_rules
[num_rules
] - p
;
547 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
548 * the results to 'prefixes'
550 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
553 int len
= strlen(prefix
);
555 for (p
= ref_rev_parse_rules
; *p
; p
++)
556 strvec_pushf(prefixes
, *p
, len
, prefix
);
559 static const char default_branch_name_advice
[] = N_(
560 "Using '%s' as the name for the initial branch. This default branch name\n"
561 "is subject to change. To configure the initial branch name to use in all\n"
562 "of your new repositories, which will suppress this warning, call:\n"
564 "\tgit config --global init.defaultBranch <name>\n"
566 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
567 "'development'. The just-created branch can be renamed via this command:\n"
569 "\tgit branch -m <name>\n"
572 char *repo_default_branch_name(struct repository
*r
, int quiet
)
574 const char *config_key
= "init.defaultbranch";
575 const char *config_display_key
= "init.defaultBranch";
576 char *ret
= NULL
, *full_ref
;
577 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
581 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
582 die(_("could not retrieve `%s`"), config_display_key
);
585 ret
= xstrdup("master");
587 advise(_(default_branch_name_advice
), ret
);
590 full_ref
= xstrfmt("refs/heads/%s", ret
);
591 if (check_refname_format(full_ref
, 0))
592 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
598 const char *git_default_branch_name(int quiet
)
603 ret
= repo_default_branch_name(the_repository
, quiet
);
609 * *string and *len will only be substituted, and *string returned (for
610 * later free()ing) if the string passed in is a magic short-hand form
613 static char *substitute_branch_name(struct repository
*r
,
614 const char **string
, int *len
,
615 int nonfatal_dangling_mark
)
617 struct strbuf buf
= STRBUF_INIT
;
618 struct interpret_branch_name_options options
= {
619 .nonfatal_dangling_mark
= nonfatal_dangling_mark
621 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
625 *string
= strbuf_detach(&buf
, &size
);
627 return (char *)*string
;
633 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
634 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
636 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
637 nonfatal_dangling_mark
);
638 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
643 int expand_ref(struct repository
*repo
, const char *str
, int len
,
644 struct object_id
*oid
, char **ref
)
648 struct strbuf fullref
= STRBUF_INIT
;
651 for (p
= ref_rev_parse_rules
; *p
; p
++) {
652 struct object_id oid_from_ref
;
653 struct object_id
*this_result
;
656 this_result
= refs_found
? &oid_from_ref
: oid
;
657 strbuf_reset(&fullref
);
658 strbuf_addf(&fullref
, *p
, len
, str
);
659 r
= refs_resolve_ref_unsafe(get_main_ref_store(repo
),
660 fullref
.buf
, RESOLVE_REF_READING
,
665 if (!warn_ambiguous_refs
)
667 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
668 warning(_("ignoring dangling symref %s"), fullref
.buf
);
669 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
670 warning(_("ignoring broken ref %s"), fullref
.buf
);
673 strbuf_release(&fullref
);
677 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
678 struct object_id
*oid
, char **log
)
680 struct ref_store
*refs
= get_main_ref_store(r
);
681 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
684 struct strbuf path
= STRBUF_INIT
;
687 for (p
= ref_rev_parse_rules
; *p
; p
++) {
688 struct object_id hash
;
689 const char *ref
, *it
;
692 strbuf_addf(&path
, *p
, len
, str
);
693 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
695 oid
? &hash
: NULL
, NULL
);
698 if (refs_reflog_exists(refs
, path
.buf
))
700 else if (strcmp(ref
, path
.buf
) &&
701 refs_reflog_exists(refs
, ref
))
710 if (!warn_ambiguous_refs
)
713 strbuf_release(&path
);
718 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
720 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
723 static int is_per_worktree_ref(const char *refname
)
725 return starts_with(refname
, "refs/worktree/") ||
726 starts_with(refname
, "refs/bisect/") ||
727 starts_with(refname
, "refs/rewritten/");
730 static int is_pseudoref_syntax(const char *refname
)
734 for (c
= refname
; *c
; c
++) {
735 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
742 static int is_main_pseudoref_syntax(const char *refname
)
744 return skip_prefix(refname
, "main-worktree/", &refname
) &&
746 is_pseudoref_syntax(refname
);
749 static int is_other_pseudoref_syntax(const char *refname
)
751 if (!skip_prefix(refname
, "worktrees/", &refname
))
753 refname
= strchr(refname
, '/');
754 if (!refname
|| !refname
[1])
756 return is_pseudoref_syntax(refname
+ 1);
759 enum ref_type
ref_type(const char *refname
)
761 if (is_per_worktree_ref(refname
))
762 return REF_TYPE_PER_WORKTREE
;
763 if (is_pseudoref_syntax(refname
))
764 return REF_TYPE_PSEUDOREF
;
765 if (is_main_pseudoref_syntax(refname
))
766 return REF_TYPE_MAIN_PSEUDOREF
;
767 if (is_other_pseudoref_syntax(refname
))
768 return REF_TYPE_OTHER_PSEUDOREF
;
769 return REF_TYPE_NORMAL
;
772 long get_files_ref_lock_timeout_ms(void)
774 static int configured
= 0;
776 /* The default timeout is 100 ms: */
777 static int timeout_ms
= 100;
780 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
787 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
789 const struct object_id
*old_oid
,
792 struct ref_transaction
*transaction
;
793 struct strbuf err
= STRBUF_INIT
;
795 transaction
= ref_store_transaction_begin(refs
, &err
);
797 ref_transaction_delete(transaction
, refname
, old_oid
,
799 ref_transaction_commit(transaction
, &err
)) {
800 error("%s", err
.buf
);
801 ref_transaction_free(transaction
);
802 strbuf_release(&err
);
805 ref_transaction_free(transaction
);
806 strbuf_release(&err
);
810 int delete_ref(const char *msg
, const char *refname
,
811 const struct object_id
*old_oid
, unsigned int flags
)
813 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
817 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
822 while ((c
= *msg
++)) {
823 if (wasspace
&& isspace(c
))
825 wasspace
= isspace(c
);
833 static char *normalize_reflog_message(const char *msg
)
835 struct strbuf sb
= STRBUF_INIT
;
838 copy_reflog_msg(&sb
, msg
);
839 return strbuf_detach(&sb
, NULL
);
842 int should_autocreate_reflog(const char *refname
)
844 switch (log_all_ref_updates
) {
845 case LOG_REFS_ALWAYS
:
847 case LOG_REFS_NORMAL
:
848 return starts_with(refname
, "refs/heads/") ||
849 starts_with(refname
, "refs/remotes/") ||
850 starts_with(refname
, "refs/notes/") ||
851 !strcmp(refname
, "HEAD");
857 int is_branch(const char *refname
)
859 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
862 struct read_ref_at_cb
{
867 struct object_id
*oid
;
870 struct object_id ooid
;
871 struct object_id noid
;
875 timestamp_t
*cutoff_time
;
880 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
881 timestamp_t timestamp
, int tz
, const char *message
)
884 *cb
->msg
= xstrdup(message
);
886 *cb
->cutoff_time
= timestamp
;
890 *cb
->cutoff_cnt
= cb
->reccnt
;
893 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
894 const char *email
, timestamp_t timestamp
, int tz
,
895 const char *message
, void *cb_data
)
897 struct read_ref_at_cb
*cb
= cb_data
;
901 cb
->date
= timestamp
;
904 * It is not possible for cb->cnt == 0 on the first iteration because
905 * that special case is handled in read_ref_at().
909 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
910 if (timestamp
<= cb
->at_time
|| reached_count
) {
911 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
913 * we have not yet updated cb->[n|o]oid so they still
914 * hold the values for the previous record.
916 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
917 warning(_("log for ref %s has gap after %s"),
918 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
920 oidcpy(cb
->oid
, ooid
);
921 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
922 oidcpy(cb
->oid
, noid
);
923 else if (!oideq(noid
, cb
->oid
))
924 warning(_("log for ref %s unexpectedly ended on %s"),
925 cb
->refname
, show_date(cb
->date
, cb
->tz
,
926 DATE_MODE(RFC2822
)));
930 oidcpy(&cb
->ooid
, ooid
);
931 oidcpy(&cb
->noid
, noid
);
935 static int read_ref_at_ent_newest(struct object_id
*ooid
, struct object_id
*noid
,
936 const char *email
, timestamp_t timestamp
,
937 int tz
, const char *message
, void *cb_data
)
939 struct read_ref_at_cb
*cb
= cb_data
;
941 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
942 oidcpy(cb
->oid
, noid
);
943 /* We just want the first entry */
947 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
948 const char *email
, timestamp_t timestamp
,
949 int tz
, const char *message
, void *cb_data
)
951 struct read_ref_at_cb
*cb
= cb_data
;
953 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
954 oidcpy(cb
->oid
, ooid
);
955 if (is_null_oid(cb
->oid
))
956 oidcpy(cb
->oid
, noid
);
957 /* We just want the first entry */
961 int read_ref_at(struct ref_store
*refs
, const char *refname
,
962 unsigned int flags
, timestamp_t at_time
, int cnt
,
963 struct object_id
*oid
, char **msg
,
964 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
966 struct read_ref_at_cb cb
;
968 memset(&cb
, 0, sizeof(cb
));
969 cb
.refname
= refname
;
970 cb
.at_time
= at_time
;
973 cb
.cutoff_time
= cutoff_time
;
974 cb
.cutoff_tz
= cutoff_tz
;
975 cb
.cutoff_cnt
= cutoff_cnt
;
979 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
983 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
986 if (flags
& GET_OID_QUIETLY
)
989 die(_("log for %s is empty"), refname
);
994 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
999 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1002 struct ref_transaction
*tr
;
1005 CALLOC_ARRAY(tr
, 1);
1006 tr
->ref_store
= refs
;
1010 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1012 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1015 void ref_transaction_free(struct ref_transaction
*transaction
)
1022 switch (transaction
->state
) {
1023 case REF_TRANSACTION_OPEN
:
1024 case REF_TRANSACTION_CLOSED
:
1027 case REF_TRANSACTION_PREPARED
:
1028 BUG("free called on a prepared reference transaction");
1031 BUG("unexpected reference transaction state");
1035 for (i
= 0; i
< transaction
->nr
; i
++) {
1036 free(transaction
->updates
[i
]->msg
);
1037 free(transaction
->updates
[i
]);
1039 free(transaction
->updates
);
1043 struct ref_update
*ref_transaction_add_update(
1044 struct ref_transaction
*transaction
,
1045 const char *refname
, unsigned int flags
,
1046 const struct object_id
*new_oid
,
1047 const struct object_id
*old_oid
,
1050 struct ref_update
*update
;
1052 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1053 BUG("update called for transaction that is not open");
1055 FLEX_ALLOC_STR(update
, refname
, refname
);
1056 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1057 transaction
->updates
[transaction
->nr
++] = update
;
1059 update
->flags
= flags
;
1061 if (flags
& REF_HAVE_NEW
)
1062 oidcpy(&update
->new_oid
, new_oid
);
1063 if (flags
& REF_HAVE_OLD
)
1064 oidcpy(&update
->old_oid
, old_oid
);
1065 update
->msg
= normalize_reflog_message(msg
);
1069 int ref_transaction_update(struct ref_transaction
*transaction
,
1070 const char *refname
,
1071 const struct object_id
*new_oid
,
1072 const struct object_id
*old_oid
,
1073 unsigned int flags
, const char *msg
,
1078 if ((new_oid
&& !is_null_oid(new_oid
)) ?
1079 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1080 !refname_is_safe(refname
)) {
1081 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1086 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1087 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1089 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1091 ref_transaction_add_update(transaction
, refname
, flags
,
1092 new_oid
, old_oid
, msg
);
1096 int ref_transaction_create(struct ref_transaction
*transaction
,
1097 const char *refname
,
1098 const struct object_id
*new_oid
,
1099 unsigned int flags
, const char *msg
,
1102 if (!new_oid
|| is_null_oid(new_oid
))
1103 BUG("create called without valid new_oid");
1104 return ref_transaction_update(transaction
, refname
, new_oid
,
1105 null_oid(), flags
, msg
, err
);
1108 int ref_transaction_delete(struct ref_transaction
*transaction
,
1109 const char *refname
,
1110 const struct object_id
*old_oid
,
1111 unsigned int flags
, const char *msg
,
1114 if (old_oid
&& is_null_oid(old_oid
))
1115 BUG("delete called with old_oid set to zeros");
1116 return ref_transaction_update(transaction
, refname
,
1117 null_oid(), old_oid
,
1121 int ref_transaction_verify(struct ref_transaction
*transaction
,
1122 const char *refname
,
1123 const struct object_id
*old_oid
,
1128 BUG("verify called with old_oid set to NULL");
1129 return ref_transaction_update(transaction
, refname
,
1134 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1135 const char *refname
, const struct object_id
*new_oid
,
1136 const struct object_id
*old_oid
, unsigned int flags
,
1137 enum action_on_err onerr
)
1139 struct ref_transaction
*t
= NULL
;
1140 struct strbuf err
= STRBUF_INIT
;
1143 t
= ref_store_transaction_begin(refs
, &err
);
1145 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1147 ref_transaction_commit(t
, &err
)) {
1149 ref_transaction_free(t
);
1152 const char *str
= _("update_ref failed for ref '%s': %s");
1155 case UPDATE_REFS_MSG_ON_ERR
:
1156 error(str
, refname
, err
.buf
);
1158 case UPDATE_REFS_DIE_ON_ERR
:
1159 die(str
, refname
, err
.buf
);
1161 case UPDATE_REFS_QUIET_ON_ERR
:
1164 strbuf_release(&err
);
1167 strbuf_release(&err
);
1169 ref_transaction_free(t
);
1173 int update_ref(const char *msg
, const char *refname
,
1174 const struct object_id
*new_oid
,
1175 const struct object_id
*old_oid
,
1176 unsigned int flags
, enum action_on_err onerr
)
1178 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1179 old_oid
, flags
, onerr
);
1182 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1183 const char *refname
, int strict
)
1186 static char **scanf_fmts
;
1187 static int nr_rules
;
1189 struct strbuf resolved_buf
= STRBUF_INIT
;
1193 * Pre-generate scanf formats from ref_rev_parse_rules[].
1194 * Generate a format suitable for scanf from a
1195 * ref_rev_parse_rules rule by interpolating "%s" at the
1196 * location of the "%.*s".
1198 size_t total_len
= 0;
1201 /* the rule list is NULL terminated, count them first */
1202 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1203 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1204 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1206 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1209 for (i
= 0; i
< nr_rules
; i
++) {
1210 assert(offset
< total_len
);
1211 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1212 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1213 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1217 /* bail out if there are no rules */
1219 return xstrdup(refname
);
1221 /* buffer for scanf result, at most refname must fit */
1222 short_name
= xstrdup(refname
);
1224 /* skip first rule, it will always match */
1225 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1227 int rules_to_fail
= i
;
1230 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1233 short_name_len
= strlen(short_name
);
1236 * in strict mode, all (except the matched one) rules
1237 * must fail to resolve to a valid non-ambiguous ref
1240 rules_to_fail
= nr_rules
;
1243 * check if the short name resolves to a valid ref,
1244 * but use only rules prior to the matched one
1246 for (j
= 0; j
< rules_to_fail
; j
++) {
1247 const char *rule
= ref_rev_parse_rules
[j
];
1249 /* skip matched rule */
1254 * the short name is ambiguous, if it resolves
1255 * (with this previous rule) to a valid ref
1256 * read_ref() returns 0 on success
1258 strbuf_reset(&resolved_buf
);
1259 strbuf_addf(&resolved_buf
, rule
,
1260 short_name_len
, short_name
);
1261 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1266 * short name is non-ambiguous if all previous rules
1267 * haven't resolved to a valid ref
1269 if (j
== rules_to_fail
) {
1270 strbuf_release(&resolved_buf
);
1275 strbuf_release(&resolved_buf
);
1277 return xstrdup(refname
);
1280 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1282 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1286 static struct string_list
*hide_refs
;
1288 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1291 if (!strcmp("transfer.hiderefs", var
) ||
1292 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1293 !strcmp(key
, "hiderefs"))) {
1298 return config_error_nonbool(var
);
1299 ref
= xstrdup(value
);
1301 while (len
&& ref
[len
- 1] == '/')
1304 CALLOC_ARRAY(hide_refs
, 1);
1305 hide_refs
->strdup_strings
= 1;
1307 string_list_append(hide_refs
, ref
);
1312 int ref_is_hidden(const char *refname
, const char *refname_full
)
1318 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1319 const char *match
= hide_refs
->items
[i
].string
;
1320 const char *subject
;
1324 if (*match
== '!') {
1329 if (*match
== '^') {
1330 subject
= refname_full
;
1336 /* refname can be NULL when namespaces are used. */
1338 skip_prefix(subject
, match
, &p
) &&
1345 const char *find_descendant_ref(const char *dirname
,
1346 const struct string_list
*extras
,
1347 const struct string_list
*skip
)
1355 * Look at the place where dirname would be inserted into
1356 * extras. If there is an entry at that position that starts
1357 * with dirname (remember, dirname includes the trailing
1358 * slash) and is not in skip, then we have a conflict.
1360 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1361 pos
< extras
->nr
; pos
++) {
1362 const char *extra_refname
= extras
->items
[pos
].string
;
1364 if (!starts_with(extra_refname
, dirname
))
1367 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1368 return extra_refname
;
1373 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1375 struct object_id oid
;
1379 if (refs_werrres_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1380 &oid
, &flag
, &ignore_errno
))
1381 return fn("HEAD", &oid
, flag
, cb_data
);
1386 int head_ref(each_ref_fn fn
, void *cb_data
)
1388 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1391 struct ref_iterator
*refs_ref_iterator_begin(
1392 struct ref_store
*refs
,
1393 const char *prefix
, int trim
,
1394 enum do_for_each_ref_flags flags
)
1396 struct ref_iterator
*iter
;
1398 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1399 static int ref_paranoia
= -1;
1401 if (ref_paranoia
< 0)
1402 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1404 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1405 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1409 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1412 * `iterator_begin()` already takes care of prefix, but we
1413 * might need to do some trimming:
1416 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1418 /* Sanity check for subclasses: */
1420 BUG("reference iterator is not ordered");
1426 * Call fn for each reference in the specified submodule for which the
1427 * refname begins with prefix. If trim is non-zero, then trim that
1428 * many characters off the beginning of each refname before passing
1429 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1430 * include broken references in the iteration. If fn ever returns a
1431 * non-zero value, stop the iteration and return that value;
1432 * otherwise, return 0.
1434 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1435 each_repo_ref_fn fn
, int trim
, int flags
,
1438 struct ref_iterator
*iter
;
1439 struct ref_store
*refs
= get_main_ref_store(r
);
1444 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1446 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1449 struct do_for_each_ref_help
{
1454 static int do_for_each_ref_helper(struct repository
*r
,
1455 const char *refname
,
1456 const struct object_id
*oid
,
1460 struct do_for_each_ref_help
*hp
= cb_data
;
1462 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1465 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1466 each_ref_fn fn
, int trim
,
1467 enum do_for_each_ref_flags flags
, void *cb_data
)
1469 struct ref_iterator
*iter
;
1470 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1475 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1477 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1478 do_for_each_ref_helper
, &hp
);
1481 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1483 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1486 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1488 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1491 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1492 each_ref_fn fn
, void *cb_data
)
1494 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1497 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1499 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1502 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1504 return do_for_each_ref(get_main_ref_store(the_repository
),
1505 prefix
, fn
, 0, 0, cb_data
);
1508 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1509 each_ref_fn fn
, void *cb_data
)
1511 return do_for_each_ref(refs
, prefix
, fn
, 0, 0, cb_data
);
1514 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1516 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1517 strlen(git_replace_ref_base
),
1518 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1521 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1523 struct strbuf buf
= STRBUF_INIT
;
1525 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1526 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1527 buf
.buf
, fn
, 0, 0, cb_data
);
1528 strbuf_release(&buf
);
1532 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1534 return do_for_each_ref(refs
, "", fn
, 0,
1535 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1538 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1540 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1543 static int qsort_strcmp(const void *va
, const void *vb
)
1545 const char *a
= *(const char **)va
;
1546 const char *b
= *(const char **)vb
;
1548 return strcmp(a
, b
);
1551 static void find_longest_prefixes_1(struct string_list
*out
,
1552 struct strbuf
*prefix
,
1553 const char **patterns
, size_t nr
)
1557 for (i
= 0; i
< nr
; i
++) {
1558 char c
= patterns
[i
][prefix
->len
];
1559 if (!c
|| is_glob_special(c
)) {
1560 string_list_append(out
, prefix
->buf
);
1570 * Set "end" to the index of the element _after_ the last one
1573 for (end
= i
+ 1; end
< nr
; end
++) {
1574 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1578 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1579 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1580 strbuf_setlen(prefix
, prefix
->len
- 1);
1586 static void find_longest_prefixes(struct string_list
*out
,
1587 const char **patterns
)
1589 struct strvec sorted
= STRVEC_INIT
;
1590 struct strbuf prefix
= STRBUF_INIT
;
1592 strvec_pushv(&sorted
, patterns
);
1593 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1595 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1597 strvec_clear(&sorted
);
1598 strbuf_release(&prefix
);
1601 int for_each_fullref_in_prefixes(const char *namespace,
1602 const char **patterns
,
1603 each_ref_fn fn
, void *cb_data
)
1605 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1606 struct string_list_item
*prefix
;
1607 struct strbuf buf
= STRBUF_INIT
;
1608 int ret
= 0, namespace_len
;
1610 find_longest_prefixes(&prefixes
, patterns
);
1613 strbuf_addstr(&buf
, namespace);
1614 namespace_len
= buf
.len
;
1616 for_each_string_list_item(prefix
, &prefixes
) {
1617 strbuf_addstr(&buf
, prefix
->string
);
1618 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
);
1621 strbuf_setlen(&buf
, namespace_len
);
1624 string_list_clear(&prefixes
, 0);
1625 strbuf_release(&buf
);
1629 static int refs_read_special_head(struct ref_store
*ref_store
,
1630 const char *refname
, struct object_id
*oid
,
1631 struct strbuf
*referent
, unsigned int *type
,
1634 struct strbuf full_path
= STRBUF_INIT
;
1635 struct strbuf content
= STRBUF_INIT
;
1637 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1639 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1642 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1646 strbuf_release(&full_path
);
1647 strbuf_release(&content
);
1651 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1652 struct object_id
*oid
, struct strbuf
*referent
,
1653 unsigned int *type
, int *failure_errno
)
1655 assert(failure_errno
);
1656 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1657 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1658 type
, failure_errno
);
1661 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1662 type
, failure_errno
);
1665 const char *refs_werrres_ref_unsafe(struct ref_store
*refs
,
1666 const char *refname
,
1668 struct object_id
*oid
,
1669 int *flags
, int *failure_errno
)
1671 static struct strbuf sb_refname
= STRBUF_INIT
;
1672 struct object_id unused_oid
;
1676 assert(failure_errno
);
1681 flags
= &unused_flags
;
1685 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1686 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1687 !refname_is_safe(refname
)) {
1688 *failure_errno
= EINVAL
;
1693 * dwim_ref() uses REF_ISBROKEN to distinguish between
1694 * missing refs and refs that were present but invalid,
1695 * to complain about the latter to stderr.
1697 * We don't know whether the ref exists, so don't set
1700 *flags
|= REF_BAD_NAME
;
1703 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1704 unsigned int read_flags
= 0;
1706 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1707 &read_flags
, failure_errno
)) {
1708 *flags
|= read_flags
;
1710 *failure_errno
= errno
;
1712 /* In reading mode, refs must eventually resolve */
1713 if (resolve_flags
& RESOLVE_REF_READING
)
1717 * Otherwise a missing ref is OK. But the files backend
1718 * may show errors besides ENOENT if there are
1719 * similarly-named refs.
1721 if (*failure_errno
!= ENOENT
&&
1722 *failure_errno
!= EISDIR
&&
1723 *failure_errno
!= ENOTDIR
)
1727 if (*flags
& REF_BAD_NAME
)
1728 *flags
|= REF_ISBROKEN
;
1732 *flags
|= read_flags
;
1734 if (!(read_flags
& REF_ISSYMREF
)) {
1735 if (*flags
& REF_BAD_NAME
) {
1737 *flags
|= REF_ISBROKEN
;
1742 refname
= sb_refname
.buf
;
1743 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1747 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1748 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1749 !refname_is_safe(refname
)) {
1750 *failure_errno
= EINVAL
;
1754 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1758 *failure_errno
= ELOOP
;
1762 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
, const char *refname
,
1763 int resolve_flags
, struct object_id
*oid
,
1766 int failure_errno
= 0;
1768 refn
= refs_werrres_ref_unsafe(refs
, refname
, resolve_flags
,
1769 oid
, flags
, &failure_errno
);
1771 errno
= failure_errno
;
1775 /* backend functions */
1776 int refs_init_db(struct strbuf
*err
)
1778 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1780 return refs
->be
->init_db(refs
, err
);
1783 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1784 struct object_id
*oid
, int *flags
)
1786 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1787 resolve_flags
, oid
, flags
);
1790 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1791 struct object_id
*oid
)
1793 struct ref_store
*refs
;
1797 refs
= get_submodule_ref_store(submodule
);
1802 if (!refs_werrres_ref_unsafe(refs
, refname
, 0, oid
, &flags
,
1803 &ignore_errno
) || is_null_oid(oid
))
1808 struct ref_store_hash_entry
1810 struct hashmap_entry ent
;
1812 struct ref_store
*refs
;
1814 /* NUL-terminated identifier of the ref store: */
1815 char name
[FLEX_ARRAY
];
1818 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1819 const struct hashmap_entry
*eptr
,
1820 const struct hashmap_entry
*entry_or_key
,
1821 const void *keydata
)
1823 const struct ref_store_hash_entry
*e1
, *e2
;
1826 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1827 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1828 name
= keydata
? keydata
: e2
->name
;
1830 return strcmp(e1
->name
, name
);
1833 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1834 const char *name
, struct ref_store
*refs
)
1836 struct ref_store_hash_entry
*entry
;
1838 FLEX_ALLOC_STR(entry
, name
, name
);
1839 hashmap_entry_init(&entry
->ent
, strhash(name
));
1844 /* A hashmap of ref_stores, stored by submodule name: */
1845 static struct hashmap submodule_ref_stores
;
1847 /* A hashmap of ref_stores, stored by worktree id: */
1848 static struct hashmap worktree_ref_stores
;
1851 * Look up a ref store by name. If that ref_store hasn't been
1852 * registered yet, return NULL.
1854 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1857 struct ref_store_hash_entry
*entry
;
1860 if (!map
->tablesize
)
1861 /* It's initialized on demand in register_ref_store(). */
1864 hash
= strhash(name
);
1865 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1866 struct ref_store_hash_entry
, ent
);
1867 return entry
? entry
->refs
: NULL
;
1871 * Create, record, and return a ref_store instance for the specified
1874 static struct ref_store
*ref_store_init(const char *gitdir
,
1877 const char *be_name
= "files";
1878 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1879 struct ref_store
*refs
;
1882 BUG("reference backend %s is unknown", be_name
);
1884 refs
= be
->init(gitdir
, flags
);
1888 struct ref_store
*get_main_ref_store(struct repository
*r
)
1890 if (r
->refs_private
)
1891 return r
->refs_private
;
1894 BUG("attempting to get main_ref_store outside of repository");
1896 r
->refs_private
= ref_store_init(r
->gitdir
, REF_STORE_ALL_CAPS
);
1897 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1898 return r
->refs_private
;
1902 * Associate a ref store with a name. It is a fatal error to call this
1903 * function twice for the same name.
1905 static void register_ref_store_map(struct hashmap
*map
,
1907 struct ref_store
*refs
,
1910 struct ref_store_hash_entry
*entry
;
1912 if (!map
->tablesize
)
1913 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1915 entry
= alloc_ref_store_hash_entry(name
, refs
);
1916 if (hashmap_put(map
, &entry
->ent
))
1917 BUG("%s ref_store '%s' initialized twice", type
, name
);
1920 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1922 struct strbuf submodule_sb
= STRBUF_INIT
;
1923 struct ref_store
*refs
;
1924 char *to_free
= NULL
;
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 /* assume that add_submodule_odb() has been called */
1952 refs
= ref_store_init(submodule_sb
.buf
,
1953 REF_STORE_READ
| REF_STORE_ODB
);
1954 register_ref_store_map(&submodule_ref_stores
, "submodule",
1958 strbuf_release(&submodule_sb
);
1964 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1966 struct ref_store
*refs
;
1970 return get_main_ref_store(the_repository
);
1972 id
= wt
->id
? wt
->id
: "/";
1973 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1978 refs
= ref_store_init(git_common_path("worktrees/%s", wt
->id
),
1979 REF_STORE_ALL_CAPS
);
1981 refs
= ref_store_init(get_git_common_dir(),
1982 REF_STORE_ALL_CAPS
);
1985 register_ref_store_map(&worktree_ref_stores
, "worktree",
1990 void base_ref_store_init(struct ref_store
*refs
,
1991 const struct ref_storage_be
*be
)
1996 /* backend functions */
1997 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
1999 return refs
->be
->pack_refs(refs
, flags
);
2002 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2004 if (current_ref_iter
&&
2005 (current_ref_iter
->oid
== base
||
2006 oideq(current_ref_iter
->oid
, base
)))
2007 return ref_iterator_peel(current_ref_iter
, peeled
);
2009 return peel_object(base
, peeled
) ? -1 : 0;
2012 int refs_create_symref(struct ref_store
*refs
,
2013 const char *ref_target
,
2014 const char *refs_heads_master
,
2020 msg
= normalize_reflog_message(logmsg
);
2021 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2027 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2030 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2031 refs_heads_master
, logmsg
);
2034 int ref_update_reject_duplicates(struct string_list
*refnames
,
2037 size_t i
, n
= refnames
->nr
;
2041 for (i
= 1; i
< n
; i
++) {
2042 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2043 refnames
->items
[i
].string
);
2047 _("multiple updates for ref '%s' not allowed"),
2048 refnames
->items
[i
].string
);
2050 } else if (cmp
> 0) {
2051 BUG("ref_update_reject_duplicates() received unsorted list");
2057 static int run_transaction_hook(struct ref_transaction
*transaction
,
2060 struct child_process proc
= CHILD_PROCESS_INIT
;
2061 struct strbuf buf
= STRBUF_INIT
;
2065 hook
= find_hook("reference-transaction");
2069 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2071 proc
.stdout_to_stderr
= 1;
2072 proc
.trace2_hook_name
= "reference-transaction";
2074 ret
= start_command(&proc
);
2078 sigchain_push(SIGPIPE
, SIG_IGN
);
2080 for (i
= 0; i
< transaction
->nr
; i
++) {
2081 struct ref_update
*update
= transaction
->updates
[i
];
2084 strbuf_addf(&buf
, "%s %s %s\n",
2085 oid_to_hex(&update
->old_oid
),
2086 oid_to_hex(&update
->new_oid
),
2089 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2097 sigchain_pop(SIGPIPE
);
2098 strbuf_release(&buf
);
2100 ret
|= finish_command(&proc
);
2104 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2107 struct ref_store
*refs
= transaction
->ref_store
;
2110 switch (transaction
->state
) {
2111 case REF_TRANSACTION_OPEN
:
2114 case REF_TRANSACTION_PREPARED
:
2115 BUG("prepare called twice on reference transaction");
2117 case REF_TRANSACTION_CLOSED
:
2118 BUG("prepare called on a closed reference transaction");
2121 BUG("unexpected reference transaction state");
2125 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
2127 _("ref updates forbidden inside quarantine environment"));
2131 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2135 ret
= run_transaction_hook(transaction
, "prepared");
2137 ref_transaction_abort(transaction
, err
);
2138 die(_("ref updates aborted by hook"));
2144 int ref_transaction_abort(struct ref_transaction
*transaction
,
2147 struct ref_store
*refs
= transaction
->ref_store
;
2150 switch (transaction
->state
) {
2151 case REF_TRANSACTION_OPEN
:
2152 /* No need to abort explicitly. */
2154 case REF_TRANSACTION_PREPARED
:
2155 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2157 case REF_TRANSACTION_CLOSED
:
2158 BUG("abort called on a closed reference transaction");
2161 BUG("unexpected reference transaction state");
2165 run_transaction_hook(transaction
, "aborted");
2167 ref_transaction_free(transaction
);
2171 int ref_transaction_commit(struct ref_transaction
*transaction
,
2174 struct ref_store
*refs
= transaction
->ref_store
;
2177 switch (transaction
->state
) {
2178 case REF_TRANSACTION_OPEN
:
2179 /* Need to prepare first. */
2180 ret
= ref_transaction_prepare(transaction
, err
);
2184 case REF_TRANSACTION_PREPARED
:
2185 /* Fall through to finish. */
2187 case REF_TRANSACTION_CLOSED
:
2188 BUG("commit called on a closed reference transaction");
2191 BUG("unexpected reference transaction state");
2195 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2197 run_transaction_hook(transaction
, "committed");
2201 int refs_verify_refname_available(struct ref_store
*refs
,
2202 const char *refname
,
2203 const struct string_list
*extras
,
2204 const struct string_list
*skip
,
2208 const char *extra_refname
;
2209 struct strbuf dirname
= STRBUF_INIT
;
2210 struct strbuf referent
= STRBUF_INIT
;
2211 struct object_id oid
;
2213 struct ref_iterator
*iter
;
2218 * For the sake of comments in this function, suppose that
2219 * refname is "refs/foo/bar".
2224 strbuf_grow(&dirname
, strlen(refname
) + 1);
2225 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2227 * Just saying "Is a directory" when we e.g. can't
2228 * lock some multi-level ref isn't very informative,
2229 * the user won't be told *what* is a directory, so
2230 * let's not use strerror() below.
2233 /* Expand dirname to the new prefix, not including the trailing slash: */
2234 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2237 * We are still at a leading dir of the refname (e.g.,
2238 * "refs/foo"; if there is a reference with that name,
2239 * it is a conflict, *unless* it is in skip.
2241 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2244 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2245 &type
, &ignore_errno
)) {
2246 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2247 dirname
.buf
, refname
);
2251 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2252 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2253 refname
, dirname
.buf
);
2259 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2260 * There is no point in searching for a reference with that
2261 * name, because a refname isn't considered to conflict with
2262 * itself. But we still need to check for references whose
2263 * names are in the "refs/foo/bar/" namespace, because they
2266 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2267 strbuf_addch(&dirname
, '/');
2269 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2270 DO_FOR_EACH_INCLUDE_BROKEN
);
2271 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2273 string_list_has_string(skip
, iter
->refname
))
2276 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2277 iter
->refname
, refname
);
2278 ref_iterator_abort(iter
);
2282 if (ok
!= ITER_DONE
)
2283 BUG("error while iterating over references");
2285 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2287 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2288 refname
, extra_refname
);
2293 strbuf_release(&referent
);
2294 strbuf_release(&dirname
);
2298 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2300 struct ref_iterator
*iter
;
2301 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2303 iter
= refs
->be
->reflog_iterator_begin(refs
);
2305 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2306 do_for_each_ref_helper
, &hp
);
2309 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2311 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2314 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2315 const char *refname
,
2316 each_reflog_ent_fn fn
,
2319 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2323 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2326 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2327 refname
, fn
, cb_data
);
2330 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2331 each_reflog_ent_fn fn
, void *cb_data
)
2333 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2336 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2339 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2343 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2345 return refs
->be
->reflog_exists(refs
, refname
);
2348 int reflog_exists(const char *refname
)
2350 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2353 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2354 int force_create
, struct strbuf
*err
)
2356 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2359 int safe_create_reflog(const char *refname
, int force_create
,
2362 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2366 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2368 return refs
->be
->delete_reflog(refs
, refname
);
2371 int delete_reflog(const char *refname
)
2373 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2376 int refs_reflog_expire(struct ref_store
*refs
,
2377 const char *refname
,
2379 reflog_expiry_prepare_fn prepare_fn
,
2380 reflog_expiry_should_prune_fn should_prune_fn
,
2381 reflog_expiry_cleanup_fn cleanup_fn
,
2382 void *policy_cb_data
)
2384 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2385 prepare_fn
, should_prune_fn
,
2386 cleanup_fn
, policy_cb_data
);
2389 int reflog_expire(const char *refname
,
2391 reflog_expiry_prepare_fn prepare_fn
,
2392 reflog_expiry_should_prune_fn should_prune_fn
,
2393 reflog_expiry_cleanup_fn cleanup_fn
,
2394 void *policy_cb_data
)
2396 return refs_reflog_expire(get_main_ref_store(the_repository
),
2398 prepare_fn
, should_prune_fn
,
2399 cleanup_fn
, policy_cb_data
);
2402 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2405 struct ref_store
*refs
= transaction
->ref_store
;
2407 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2410 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2411 struct string_list
*refnames
, unsigned int flags
)
2416 msg
= normalize_reflog_message(logmsg
);
2417 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2422 int delete_refs(const char *msg
, struct string_list
*refnames
,
2425 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2428 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2429 const char *newref
, const char *logmsg
)
2434 msg
= normalize_reflog_message(logmsg
);
2435 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2440 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2442 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2445 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2446 const char *newref
, const char *logmsg
)
2451 msg
= normalize_reflog_message(logmsg
);
2452 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2457 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2459 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);