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
)
272 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
274 return xstrdup_or_null(result
);
277 char *resolve_refdup(const char *refname
, int resolve_flags
,
278 struct object_id
*oid
, int *flags
)
280 return refs_resolve_refdup(get_main_ref_store(the_repository
),
281 refname
, resolve_flags
,
285 /* The argument to filter_refs */
293 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
296 struct ref_store
*refs
= get_main_ref_store(the_repository
);
298 if (refs_werrres_ref_unsafe(refs
, refname
, resolve_flags
,
299 oid
, flags
, &ignore_errno
))
304 int read_ref(const char *refname
, struct object_id
*oid
)
306 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
309 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
311 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
, NULL
, NULL
);
314 int ref_exists(const char *refname
)
316 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
319 static int filter_refs(const char *refname
, const struct object_id
*oid
,
320 int flags
, void *data
)
322 struct ref_filter
*filter
= (struct ref_filter
*)data
;
324 if (wildmatch(filter
->pattern
, refname
, 0))
327 skip_prefix(refname
, filter
->prefix
, &refname
);
328 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
331 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
333 struct object
*o
= lookup_unknown_object(the_repository
, name
);
335 if (o
->type
== OBJ_NONE
) {
336 int type
= oid_object_info(the_repository
, name
, NULL
);
337 if (type
< 0 || !object_as_type(o
, type
, 0))
341 if (o
->type
!= OBJ_TAG
)
344 o
= deref_tag_noverify(o
);
348 oidcpy(oid
, &o
->oid
);
352 struct warn_if_dangling_data
{
355 const struct string_list
*refnames
;
359 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
360 int flags
, void *cb_data
)
362 struct warn_if_dangling_data
*d
= cb_data
;
363 const char *resolves_to
;
365 if (!(flags
& REF_ISSYMREF
))
368 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
371 ? strcmp(resolves_to
, d
->refname
)
372 : !string_list_has_string(d
->refnames
, resolves_to
))) {
376 fprintf(d
->fp
, d
->msg_fmt
, refname
);
381 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
383 struct warn_if_dangling_data data
;
386 data
.refname
= refname
;
387 data
.refnames
= NULL
;
388 data
.msg_fmt
= msg_fmt
;
389 for_each_rawref(warn_if_dangling_symref
, &data
);
392 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
394 struct warn_if_dangling_data data
;
398 data
.refnames
= refnames
;
399 data
.msg_fmt
= msg_fmt
;
400 for_each_rawref(warn_if_dangling_symref
, &data
);
403 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
405 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
408 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
410 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
413 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
415 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
418 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
420 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
423 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
425 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
428 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
430 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
433 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
435 struct strbuf buf
= STRBUF_INIT
;
437 struct object_id oid
;
440 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
441 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
442 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
443 strbuf_release(&buf
);
448 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
451 struct strbuf normalized_pattern
= STRBUF_INIT
;
454 BUG("pattern must not start with '/'");
457 strbuf_addstr(&normalized_pattern
, prefix
);
459 else if (!starts_with(pattern
, "refs/"))
460 strbuf_addstr(&normalized_pattern
, "refs/");
461 strbuf_addstr(&normalized_pattern
, pattern
);
462 strbuf_strip_suffix(&normalized_pattern
, "/");
464 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
465 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
466 strbuf_release(&normalized_pattern
);
469 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
470 const char *prefix
, void *cb_data
)
472 struct strbuf real_pattern
= STRBUF_INIT
;
473 struct ref_filter filter
;
476 if (!prefix
&& !starts_with(pattern
, "refs/"))
477 strbuf_addstr(&real_pattern
, "refs/");
479 strbuf_addstr(&real_pattern
, prefix
);
480 strbuf_addstr(&real_pattern
, pattern
);
482 if (!has_glob_specials(pattern
)) {
483 /* Append implied '/' '*' if not present. */
484 strbuf_complete(&real_pattern
, '/');
485 /* No need to check for '*', there is none. */
486 strbuf_addch(&real_pattern
, '*');
489 filter
.pattern
= real_pattern
.buf
;
490 filter
.prefix
= prefix
;
492 filter
.cb_data
= cb_data
;
493 ret
= for_each_ref(filter_refs
, &filter
);
495 strbuf_release(&real_pattern
);
499 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
501 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
504 const char *prettify_refname(const char *name
)
506 if (skip_prefix(name
, "refs/heads/", &name
) ||
507 skip_prefix(name
, "refs/tags/", &name
) ||
508 skip_prefix(name
, "refs/remotes/", &name
))
513 static const char *ref_rev_parse_rules
[] = {
519 "refs/remotes/%.*s/HEAD",
523 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
526 * Is it possible that the caller meant full_name with abbrev_name?
527 * If so return a non-zero value to signal "yes"; the magnitude of
528 * the returned value gives the precedence used for disambiguation.
530 * If abbrev_name cannot mean full_name, return 0.
532 int refname_match(const char *abbrev_name
, const char *full_name
)
535 const int abbrev_name_len
= strlen(abbrev_name
);
536 const int num_rules
= NUM_REV_PARSE_RULES
;
538 for (p
= ref_rev_parse_rules
; *p
; p
++)
539 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
540 return &ref_rev_parse_rules
[num_rules
] - p
;
546 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
547 * the results to 'prefixes'
549 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
552 int len
= strlen(prefix
);
554 for (p
= ref_rev_parse_rules
; *p
; p
++)
555 strvec_pushf(prefixes
, *p
, len
, prefix
);
558 static const char default_branch_name_advice
[] = N_(
559 "Using '%s' as the name for the initial branch. This default branch name\n"
560 "is subject to change. To configure the initial branch name to use in all\n"
561 "of your new repositories, which will suppress this warning, call:\n"
563 "\tgit config --global init.defaultBranch <name>\n"
565 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
566 "'development'. The just-created branch can be renamed via this command:\n"
568 "\tgit branch -m <name>\n"
571 char *repo_default_branch_name(struct repository
*r
, int quiet
)
573 const char *config_key
= "init.defaultbranch";
574 const char *config_display_key
= "init.defaultBranch";
575 char *ret
= NULL
, *full_ref
;
576 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
580 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
581 die(_("could not retrieve `%s`"), config_display_key
);
584 ret
= xstrdup("master");
586 advise(_(default_branch_name_advice
), ret
);
589 full_ref
= xstrfmt("refs/heads/%s", ret
);
590 if (check_refname_format(full_ref
, 0))
591 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
597 const char *git_default_branch_name(int quiet
)
602 ret
= repo_default_branch_name(the_repository
, quiet
);
608 * *string and *len will only be substituted, and *string returned (for
609 * later free()ing) if the string passed in is a magic short-hand form
612 static char *substitute_branch_name(struct repository
*r
,
613 const char **string
, int *len
,
614 int nonfatal_dangling_mark
)
616 struct strbuf buf
= STRBUF_INIT
;
617 struct interpret_branch_name_options options
= {
618 .nonfatal_dangling_mark
= nonfatal_dangling_mark
620 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
624 *string
= strbuf_detach(&buf
, &size
);
626 return (char *)*string
;
632 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
633 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
635 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
636 nonfatal_dangling_mark
);
637 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
642 int expand_ref(struct repository
*repo
, const char *str
, int len
,
643 struct object_id
*oid
, char **ref
)
647 struct strbuf fullref
= STRBUF_INIT
;
650 for (p
= ref_rev_parse_rules
; *p
; p
++) {
651 struct object_id oid_from_ref
;
652 struct object_id
*this_result
;
655 this_result
= refs_found
? &oid_from_ref
: oid
;
656 strbuf_reset(&fullref
);
657 strbuf_addf(&fullref
, *p
, len
, str
);
658 r
= refs_resolve_ref_unsafe(get_main_ref_store(repo
),
659 fullref
.buf
, RESOLVE_REF_READING
,
664 if (!warn_ambiguous_refs
)
666 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
667 warning(_("ignoring dangling symref %s"), fullref
.buf
);
668 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
669 warning(_("ignoring broken ref %s"), fullref
.buf
);
672 strbuf_release(&fullref
);
676 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
677 struct object_id
*oid
, char **log
)
679 struct ref_store
*refs
= get_main_ref_store(r
);
680 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
683 struct strbuf path
= STRBUF_INIT
;
686 for (p
= ref_rev_parse_rules
; *p
; p
++) {
687 struct object_id hash
;
688 const char *ref
, *it
;
691 strbuf_addf(&path
, *p
, len
, str
);
692 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
694 oid
? &hash
: NULL
, NULL
);
697 if (refs_reflog_exists(refs
, path
.buf
))
699 else if (strcmp(ref
, path
.buf
) &&
700 refs_reflog_exists(refs
, ref
))
709 if (!warn_ambiguous_refs
)
712 strbuf_release(&path
);
717 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
719 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
722 static int is_per_worktree_ref(const char *refname
)
724 return starts_with(refname
, "refs/worktree/") ||
725 starts_with(refname
, "refs/bisect/") ||
726 starts_with(refname
, "refs/rewritten/");
729 static int is_pseudoref_syntax(const char *refname
)
733 for (c
= refname
; *c
; c
++) {
734 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
741 static int is_main_pseudoref_syntax(const char *refname
)
743 return skip_prefix(refname
, "main-worktree/", &refname
) &&
745 is_pseudoref_syntax(refname
);
748 static int is_other_pseudoref_syntax(const char *refname
)
750 if (!skip_prefix(refname
, "worktrees/", &refname
))
752 refname
= strchr(refname
, '/');
753 if (!refname
|| !refname
[1])
755 return is_pseudoref_syntax(refname
+ 1);
758 enum ref_type
ref_type(const char *refname
)
760 if (is_per_worktree_ref(refname
))
761 return REF_TYPE_PER_WORKTREE
;
762 if (is_pseudoref_syntax(refname
))
763 return REF_TYPE_PSEUDOREF
;
764 if (is_main_pseudoref_syntax(refname
))
765 return REF_TYPE_MAIN_PSEUDOREF
;
766 if (is_other_pseudoref_syntax(refname
))
767 return REF_TYPE_OTHER_PSEUDOREF
;
768 return REF_TYPE_NORMAL
;
771 long get_files_ref_lock_timeout_ms(void)
773 static int configured
= 0;
775 /* The default timeout is 100 ms: */
776 static int timeout_ms
= 100;
779 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
786 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
788 const struct object_id
*old_oid
,
791 struct ref_transaction
*transaction
;
792 struct strbuf err
= STRBUF_INIT
;
794 transaction
= ref_store_transaction_begin(refs
, &err
);
796 ref_transaction_delete(transaction
, refname
, old_oid
,
798 ref_transaction_commit(transaction
, &err
)) {
799 error("%s", err
.buf
);
800 ref_transaction_free(transaction
);
801 strbuf_release(&err
);
804 ref_transaction_free(transaction
);
805 strbuf_release(&err
);
809 int delete_ref(const char *msg
, const char *refname
,
810 const struct object_id
*old_oid
, unsigned int flags
)
812 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
816 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
821 while ((c
= *msg
++)) {
822 if (wasspace
&& isspace(c
))
824 wasspace
= isspace(c
);
832 static char *normalize_reflog_message(const char *msg
)
834 struct strbuf sb
= STRBUF_INIT
;
837 copy_reflog_msg(&sb
, msg
);
838 return strbuf_detach(&sb
, NULL
);
841 int should_autocreate_reflog(const char *refname
)
843 switch (log_all_ref_updates
) {
844 case LOG_REFS_ALWAYS
:
846 case LOG_REFS_NORMAL
:
847 return starts_with(refname
, "refs/heads/") ||
848 starts_with(refname
, "refs/remotes/") ||
849 starts_with(refname
, "refs/notes/") ||
850 !strcmp(refname
, "HEAD");
856 int is_branch(const char *refname
)
858 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
861 struct read_ref_at_cb
{
866 struct object_id
*oid
;
869 struct object_id ooid
;
870 struct object_id noid
;
874 timestamp_t
*cutoff_time
;
879 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
880 timestamp_t timestamp
, int tz
, const char *message
)
883 *cb
->msg
= xstrdup(message
);
885 *cb
->cutoff_time
= timestamp
;
889 *cb
->cutoff_cnt
= cb
->reccnt
;
892 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
893 const char *email
, timestamp_t timestamp
, int tz
,
894 const char *message
, void *cb_data
)
896 struct read_ref_at_cb
*cb
= cb_data
;
900 cb
->date
= timestamp
;
903 * It is not possible for cb->cnt == 0 on the first iteration because
904 * that special case is handled in read_ref_at().
908 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
909 if (timestamp
<= cb
->at_time
|| reached_count
) {
910 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
912 * we have not yet updated cb->[n|o]oid so they still
913 * hold the values for the previous record.
915 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
916 warning(_("log for ref %s has gap after %s"),
917 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
919 oidcpy(cb
->oid
, ooid
);
920 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
921 oidcpy(cb
->oid
, noid
);
922 else if (!oideq(noid
, cb
->oid
))
923 warning(_("log for ref %s unexpectedly ended on %s"),
924 cb
->refname
, show_date(cb
->date
, cb
->tz
,
925 DATE_MODE(RFC2822
)));
929 oidcpy(&cb
->ooid
, ooid
);
930 oidcpy(&cb
->noid
, noid
);
934 static int read_ref_at_ent_newest(struct object_id
*ooid
, struct object_id
*noid
,
935 const char *email
, timestamp_t timestamp
,
936 int tz
, const char *message
, void *cb_data
)
938 struct read_ref_at_cb
*cb
= cb_data
;
940 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
941 oidcpy(cb
->oid
, noid
);
942 /* We just want the first entry */
946 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
947 const char *email
, timestamp_t timestamp
,
948 int tz
, const char *message
, void *cb_data
)
950 struct read_ref_at_cb
*cb
= cb_data
;
952 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
953 oidcpy(cb
->oid
, ooid
);
954 if (is_null_oid(cb
->oid
))
955 oidcpy(cb
->oid
, noid
);
956 /* We just want the first entry */
960 int read_ref_at(struct ref_store
*refs
, const char *refname
,
961 unsigned int flags
, timestamp_t at_time
, int cnt
,
962 struct object_id
*oid
, char **msg
,
963 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
965 struct read_ref_at_cb cb
;
967 memset(&cb
, 0, sizeof(cb
));
968 cb
.refname
= refname
;
969 cb
.at_time
= at_time
;
972 cb
.cutoff_time
= cutoff_time
;
973 cb
.cutoff_tz
= cutoff_tz
;
974 cb
.cutoff_cnt
= cutoff_cnt
;
978 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
982 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
985 if (flags
& GET_OID_QUIETLY
)
988 die(_("log for %s is empty"), refname
);
993 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
998 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1001 struct ref_transaction
*tr
;
1004 CALLOC_ARRAY(tr
, 1);
1005 tr
->ref_store
= refs
;
1009 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1011 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1014 void ref_transaction_free(struct ref_transaction
*transaction
)
1021 switch (transaction
->state
) {
1022 case REF_TRANSACTION_OPEN
:
1023 case REF_TRANSACTION_CLOSED
:
1026 case REF_TRANSACTION_PREPARED
:
1027 BUG("free called on a prepared reference transaction");
1030 BUG("unexpected reference transaction state");
1034 for (i
= 0; i
< transaction
->nr
; i
++) {
1035 free(transaction
->updates
[i
]->msg
);
1036 free(transaction
->updates
[i
]);
1038 free(transaction
->updates
);
1042 struct ref_update
*ref_transaction_add_update(
1043 struct ref_transaction
*transaction
,
1044 const char *refname
, unsigned int flags
,
1045 const struct object_id
*new_oid
,
1046 const struct object_id
*old_oid
,
1049 struct ref_update
*update
;
1051 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1052 BUG("update called for transaction that is not open");
1054 FLEX_ALLOC_STR(update
, refname
, refname
);
1055 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1056 transaction
->updates
[transaction
->nr
++] = update
;
1058 update
->flags
= flags
;
1060 if (flags
& REF_HAVE_NEW
)
1061 oidcpy(&update
->new_oid
, new_oid
);
1062 if (flags
& REF_HAVE_OLD
)
1063 oidcpy(&update
->old_oid
, old_oid
);
1064 update
->msg
= normalize_reflog_message(msg
);
1068 int ref_transaction_update(struct ref_transaction
*transaction
,
1069 const char *refname
,
1070 const struct object_id
*new_oid
,
1071 const struct object_id
*old_oid
,
1072 unsigned int flags
, const char *msg
,
1077 if ((new_oid
&& !is_null_oid(new_oid
)) ?
1078 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1079 !refname_is_safe(refname
)) {
1080 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1085 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1086 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1088 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1090 ref_transaction_add_update(transaction
, refname
, flags
,
1091 new_oid
, old_oid
, msg
);
1095 int ref_transaction_create(struct ref_transaction
*transaction
,
1096 const char *refname
,
1097 const struct object_id
*new_oid
,
1098 unsigned int flags
, const char *msg
,
1101 if (!new_oid
|| is_null_oid(new_oid
))
1102 BUG("create called without valid new_oid");
1103 return ref_transaction_update(transaction
, refname
, new_oid
,
1104 null_oid(), flags
, msg
, err
);
1107 int ref_transaction_delete(struct ref_transaction
*transaction
,
1108 const char *refname
,
1109 const struct object_id
*old_oid
,
1110 unsigned int flags
, const char *msg
,
1113 if (old_oid
&& is_null_oid(old_oid
))
1114 BUG("delete called with old_oid set to zeros");
1115 return ref_transaction_update(transaction
, refname
,
1116 null_oid(), old_oid
,
1120 int ref_transaction_verify(struct ref_transaction
*transaction
,
1121 const char *refname
,
1122 const struct object_id
*old_oid
,
1127 BUG("verify called with old_oid set to NULL");
1128 return ref_transaction_update(transaction
, refname
,
1133 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1134 const char *refname
, const struct object_id
*new_oid
,
1135 const struct object_id
*old_oid
, unsigned int flags
,
1136 enum action_on_err onerr
)
1138 struct ref_transaction
*t
= NULL
;
1139 struct strbuf err
= STRBUF_INIT
;
1142 t
= ref_store_transaction_begin(refs
, &err
);
1144 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1146 ref_transaction_commit(t
, &err
)) {
1148 ref_transaction_free(t
);
1151 const char *str
= _("update_ref failed for ref '%s': %s");
1154 case UPDATE_REFS_MSG_ON_ERR
:
1155 error(str
, refname
, err
.buf
);
1157 case UPDATE_REFS_DIE_ON_ERR
:
1158 die(str
, refname
, err
.buf
);
1160 case UPDATE_REFS_QUIET_ON_ERR
:
1163 strbuf_release(&err
);
1166 strbuf_release(&err
);
1168 ref_transaction_free(t
);
1172 int update_ref(const char *msg
, const char *refname
,
1173 const struct object_id
*new_oid
,
1174 const struct object_id
*old_oid
,
1175 unsigned int flags
, enum action_on_err onerr
)
1177 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1178 old_oid
, flags
, onerr
);
1181 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1182 const char *refname
, int strict
)
1185 static char **scanf_fmts
;
1186 static int nr_rules
;
1188 struct strbuf resolved_buf
= STRBUF_INIT
;
1192 * Pre-generate scanf formats from ref_rev_parse_rules[].
1193 * Generate a format suitable for scanf from a
1194 * ref_rev_parse_rules rule by interpolating "%s" at the
1195 * location of the "%.*s".
1197 size_t total_len
= 0;
1200 /* the rule list is NULL terminated, count them first */
1201 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1202 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1203 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1205 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1208 for (i
= 0; i
< nr_rules
; i
++) {
1209 assert(offset
< total_len
);
1210 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1211 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1212 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1216 /* bail out if there are no rules */
1218 return xstrdup(refname
);
1220 /* buffer for scanf result, at most refname must fit */
1221 short_name
= xstrdup(refname
);
1223 /* skip first rule, it will always match */
1224 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1226 int rules_to_fail
= i
;
1229 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1232 short_name_len
= strlen(short_name
);
1235 * in strict mode, all (except the matched one) rules
1236 * must fail to resolve to a valid non-ambiguous ref
1239 rules_to_fail
= nr_rules
;
1242 * check if the short name resolves to a valid ref,
1243 * but use only rules prior to the matched one
1245 for (j
= 0; j
< rules_to_fail
; j
++) {
1246 const char *rule
= ref_rev_parse_rules
[j
];
1248 /* skip matched rule */
1253 * the short name is ambiguous, if it resolves
1254 * (with this previous rule) to a valid ref
1255 * read_ref() returns 0 on success
1257 strbuf_reset(&resolved_buf
);
1258 strbuf_addf(&resolved_buf
, rule
,
1259 short_name_len
, short_name
);
1260 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1265 * short name is non-ambiguous if all previous rules
1266 * haven't resolved to a valid ref
1268 if (j
== rules_to_fail
) {
1269 strbuf_release(&resolved_buf
);
1274 strbuf_release(&resolved_buf
);
1276 return xstrdup(refname
);
1279 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1281 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1285 static struct string_list
*hide_refs
;
1287 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1290 if (!strcmp("transfer.hiderefs", var
) ||
1291 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1292 !strcmp(key
, "hiderefs"))) {
1297 return config_error_nonbool(var
);
1298 ref
= xstrdup(value
);
1300 while (len
&& ref
[len
- 1] == '/')
1303 CALLOC_ARRAY(hide_refs
, 1);
1304 hide_refs
->strdup_strings
= 1;
1306 string_list_append(hide_refs
, ref
);
1311 int ref_is_hidden(const char *refname
, const char *refname_full
)
1317 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1318 const char *match
= hide_refs
->items
[i
].string
;
1319 const char *subject
;
1323 if (*match
== '!') {
1328 if (*match
== '^') {
1329 subject
= refname_full
;
1335 /* refname can be NULL when namespaces are used. */
1337 skip_prefix(subject
, match
, &p
) &&
1344 const char *find_descendant_ref(const char *dirname
,
1345 const struct string_list
*extras
,
1346 const struct string_list
*skip
)
1354 * Look at the place where dirname would be inserted into
1355 * extras. If there is an entry at that position that starts
1356 * with dirname (remember, dirname includes the trailing
1357 * slash) and is not in skip, then we have a conflict.
1359 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1360 pos
< extras
->nr
; pos
++) {
1361 const char *extra_refname
= extras
->items
[pos
].string
;
1363 if (!starts_with(extra_refname
, dirname
))
1366 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1367 return extra_refname
;
1372 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1374 struct object_id oid
;
1378 if (refs_werrres_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1379 &oid
, &flag
, &ignore_errno
))
1380 return fn("HEAD", &oid
, flag
, cb_data
);
1385 int head_ref(each_ref_fn fn
, void *cb_data
)
1387 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1390 struct ref_iterator
*refs_ref_iterator_begin(
1391 struct ref_store
*refs
,
1392 const char *prefix
, int trim
,
1393 enum do_for_each_ref_flags flags
)
1395 struct ref_iterator
*iter
;
1397 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1398 static int ref_paranoia
= -1;
1400 if (ref_paranoia
< 0)
1401 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1403 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1404 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1408 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1411 * `iterator_begin()` already takes care of prefix, but we
1412 * might need to do some trimming:
1415 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1417 /* Sanity check for subclasses: */
1419 BUG("reference iterator is not ordered");
1425 * Call fn for each reference in the specified submodule for which the
1426 * refname begins with prefix. If trim is non-zero, then trim that
1427 * many characters off the beginning of each refname before passing
1428 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1429 * include broken references in the iteration. If fn ever returns a
1430 * non-zero value, stop the iteration and return that value;
1431 * otherwise, return 0.
1433 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1434 each_repo_ref_fn fn
, int trim
, int flags
,
1437 struct ref_iterator
*iter
;
1438 struct ref_store
*refs
= get_main_ref_store(r
);
1443 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1445 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1448 struct do_for_each_ref_help
{
1453 static int do_for_each_ref_helper(struct repository
*r
,
1454 const char *refname
,
1455 const struct object_id
*oid
,
1459 struct do_for_each_ref_help
*hp
= cb_data
;
1461 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1464 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1465 each_ref_fn fn
, int trim
,
1466 enum do_for_each_ref_flags flags
, void *cb_data
)
1468 struct ref_iterator
*iter
;
1469 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1474 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1476 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1477 do_for_each_ref_helper
, &hp
);
1480 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1482 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1485 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1487 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1490 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1491 each_ref_fn fn
, void *cb_data
)
1493 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1496 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1498 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1501 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1503 return do_for_each_ref(get_main_ref_store(the_repository
),
1504 prefix
, fn
, 0, 0, cb_data
);
1507 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1508 each_ref_fn fn
, void *cb_data
)
1510 return do_for_each_ref(refs
, prefix
, fn
, 0, 0, cb_data
);
1513 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1515 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1516 strlen(git_replace_ref_base
),
1517 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1520 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1522 struct strbuf buf
= STRBUF_INIT
;
1524 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1525 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1526 buf
.buf
, fn
, 0, 0, cb_data
);
1527 strbuf_release(&buf
);
1531 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1533 return do_for_each_ref(refs
, "", fn
, 0,
1534 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1537 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1539 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1542 static int qsort_strcmp(const void *va
, const void *vb
)
1544 const char *a
= *(const char **)va
;
1545 const char *b
= *(const char **)vb
;
1547 return strcmp(a
, b
);
1550 static void find_longest_prefixes_1(struct string_list
*out
,
1551 struct strbuf
*prefix
,
1552 const char **patterns
, size_t nr
)
1556 for (i
= 0; i
< nr
; i
++) {
1557 char c
= patterns
[i
][prefix
->len
];
1558 if (!c
|| is_glob_special(c
)) {
1559 string_list_append(out
, prefix
->buf
);
1569 * Set "end" to the index of the element _after_ the last one
1572 for (end
= i
+ 1; end
< nr
; end
++) {
1573 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1577 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1578 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1579 strbuf_setlen(prefix
, prefix
->len
- 1);
1585 static void find_longest_prefixes(struct string_list
*out
,
1586 const char **patterns
)
1588 struct strvec sorted
= STRVEC_INIT
;
1589 struct strbuf prefix
= STRBUF_INIT
;
1591 strvec_pushv(&sorted
, patterns
);
1592 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1594 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1596 strvec_clear(&sorted
);
1597 strbuf_release(&prefix
);
1600 int for_each_fullref_in_prefixes(const char *namespace,
1601 const char **patterns
,
1602 each_ref_fn fn
, void *cb_data
)
1604 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1605 struct string_list_item
*prefix
;
1606 struct strbuf buf
= STRBUF_INIT
;
1607 int ret
= 0, namespace_len
;
1609 find_longest_prefixes(&prefixes
, patterns
);
1612 strbuf_addstr(&buf
, namespace);
1613 namespace_len
= buf
.len
;
1615 for_each_string_list_item(prefix
, &prefixes
) {
1616 strbuf_addstr(&buf
, prefix
->string
);
1617 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
);
1620 strbuf_setlen(&buf
, namespace_len
);
1623 string_list_clear(&prefixes
, 0);
1624 strbuf_release(&buf
);
1628 static int refs_read_special_head(struct ref_store
*ref_store
,
1629 const char *refname
, struct object_id
*oid
,
1630 struct strbuf
*referent
, unsigned int *type
,
1633 struct strbuf full_path
= STRBUF_INIT
;
1634 struct strbuf content
= STRBUF_INIT
;
1636 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1638 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1641 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1645 strbuf_release(&full_path
);
1646 strbuf_release(&content
);
1650 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1651 struct object_id
*oid
, struct strbuf
*referent
,
1652 unsigned int *type
, int *failure_errno
)
1654 assert(failure_errno
);
1655 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1656 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1657 type
, failure_errno
);
1660 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1661 type
, failure_errno
);
1664 const char *refs_werrres_ref_unsafe(struct ref_store
*refs
,
1665 const char *refname
,
1667 struct object_id
*oid
,
1668 int *flags
, int *failure_errno
)
1670 static struct strbuf sb_refname
= STRBUF_INIT
;
1671 struct object_id unused_oid
;
1675 assert(failure_errno
);
1680 flags
= &unused_flags
;
1684 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1685 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1686 !refname_is_safe(refname
)) {
1687 *failure_errno
= EINVAL
;
1692 * dwim_ref() uses REF_ISBROKEN to distinguish between
1693 * missing refs and refs that were present but invalid,
1694 * to complain about the latter to stderr.
1696 * We don't know whether the ref exists, so don't set
1699 *flags
|= REF_BAD_NAME
;
1702 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1703 unsigned int read_flags
= 0;
1705 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1706 &read_flags
, failure_errno
)) {
1707 *flags
|= read_flags
;
1709 *failure_errno
= errno
;
1711 /* In reading mode, refs must eventually resolve */
1712 if (resolve_flags
& RESOLVE_REF_READING
)
1716 * Otherwise a missing ref is OK. But the files backend
1717 * may show errors besides ENOENT if there are
1718 * similarly-named refs.
1720 if (*failure_errno
!= ENOENT
&&
1721 *failure_errno
!= EISDIR
&&
1722 *failure_errno
!= ENOTDIR
)
1726 if (*flags
& REF_BAD_NAME
)
1727 *flags
|= REF_ISBROKEN
;
1731 *flags
|= read_flags
;
1733 if (!(read_flags
& REF_ISSYMREF
)) {
1734 if (*flags
& REF_BAD_NAME
) {
1736 *flags
|= REF_ISBROKEN
;
1741 refname
= sb_refname
.buf
;
1742 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1746 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1747 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1748 !refname_is_safe(refname
)) {
1749 *failure_errno
= EINVAL
;
1753 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1757 *failure_errno
= ELOOP
;
1761 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
, const char *refname
,
1762 int resolve_flags
, struct object_id
*oid
,
1765 int failure_errno
= 0;
1767 refn
= refs_werrres_ref_unsafe(refs
, refname
, resolve_flags
,
1768 oid
, flags
, &failure_errno
);
1770 errno
= failure_errno
;
1774 /* backend functions */
1775 int refs_init_db(struct strbuf
*err
)
1777 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1779 return refs
->be
->init_db(refs
, err
);
1782 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1783 struct object_id
*oid
, int *flags
)
1785 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1786 resolve_flags
, oid
, flags
);
1789 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1790 struct object_id
*oid
)
1792 struct ref_store
*refs
;
1796 refs
= get_submodule_ref_store(submodule
);
1801 if (!refs_werrres_ref_unsafe(refs
, refname
, 0, oid
, &flags
,
1802 &ignore_errno
) || is_null_oid(oid
))
1807 struct ref_store_hash_entry
1809 struct hashmap_entry ent
;
1811 struct ref_store
*refs
;
1813 /* NUL-terminated identifier of the ref store: */
1814 char name
[FLEX_ARRAY
];
1817 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1818 const struct hashmap_entry
*eptr
,
1819 const struct hashmap_entry
*entry_or_key
,
1820 const void *keydata
)
1822 const struct ref_store_hash_entry
*e1
, *e2
;
1825 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1826 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1827 name
= keydata
? keydata
: e2
->name
;
1829 return strcmp(e1
->name
, name
);
1832 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1833 const char *name
, struct ref_store
*refs
)
1835 struct ref_store_hash_entry
*entry
;
1837 FLEX_ALLOC_STR(entry
, name
, name
);
1838 hashmap_entry_init(&entry
->ent
, strhash(name
));
1843 /* A hashmap of ref_stores, stored by submodule name: */
1844 static struct hashmap submodule_ref_stores
;
1846 /* A hashmap of ref_stores, stored by worktree id: */
1847 static struct hashmap worktree_ref_stores
;
1850 * Look up a ref store by name. If that ref_store hasn't been
1851 * registered yet, return NULL.
1853 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1856 struct ref_store_hash_entry
*entry
;
1859 if (!map
->tablesize
)
1860 /* It's initialized on demand in register_ref_store(). */
1863 hash
= strhash(name
);
1864 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1865 struct ref_store_hash_entry
, ent
);
1866 return entry
? entry
->refs
: NULL
;
1870 * Create, record, and return a ref_store instance for the specified
1873 static struct ref_store
*ref_store_init(const char *gitdir
,
1876 const char *be_name
= "files";
1877 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1878 struct ref_store
*refs
;
1881 BUG("reference backend %s is unknown", be_name
);
1883 refs
= be
->init(gitdir
, flags
);
1887 struct ref_store
*get_main_ref_store(struct repository
*r
)
1889 if (r
->refs_private
)
1890 return r
->refs_private
;
1893 BUG("attempting to get main_ref_store outside of repository");
1895 r
->refs_private
= ref_store_init(r
->gitdir
, REF_STORE_ALL_CAPS
);
1896 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1897 return r
->refs_private
;
1901 * Associate a ref store with a name. It is a fatal error to call this
1902 * function twice for the same name.
1904 static void register_ref_store_map(struct hashmap
*map
,
1906 struct ref_store
*refs
,
1909 struct ref_store_hash_entry
*entry
;
1911 if (!map
->tablesize
)
1912 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1914 entry
= alloc_ref_store_hash_entry(name
, refs
);
1915 if (hashmap_put(map
, &entry
->ent
))
1916 BUG("%s ref_store '%s' initialized twice", type
, name
);
1919 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1921 struct strbuf submodule_sb
= STRBUF_INIT
;
1922 struct ref_store
*refs
;
1923 char *to_free
= NULL
;
1929 len
= strlen(submodule
);
1930 while (len
&& is_dir_sep(submodule
[len
- 1]))
1936 /* We need to strip off one or more trailing slashes */
1937 submodule
= to_free
= xmemdupz(submodule
, len
);
1939 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1943 strbuf_addstr(&submodule_sb
, submodule
);
1944 if (!is_nonbare_repository_dir(&submodule_sb
))
1947 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1950 /* assume that add_submodule_odb() has been called */
1951 refs
= ref_store_init(submodule_sb
.buf
,
1952 REF_STORE_READ
| REF_STORE_ODB
);
1953 register_ref_store_map(&submodule_ref_stores
, "submodule",
1957 strbuf_release(&submodule_sb
);
1963 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1965 struct ref_store
*refs
;
1969 return get_main_ref_store(the_repository
);
1971 id
= wt
->id
? wt
->id
: "/";
1972 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1977 refs
= ref_store_init(git_common_path("worktrees/%s", wt
->id
),
1978 REF_STORE_ALL_CAPS
);
1980 refs
= ref_store_init(get_git_common_dir(),
1981 REF_STORE_ALL_CAPS
);
1984 register_ref_store_map(&worktree_ref_stores
, "worktree",
1989 void base_ref_store_init(struct ref_store
*refs
,
1990 const struct ref_storage_be
*be
)
1995 /* backend functions */
1996 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
1998 return refs
->be
->pack_refs(refs
, flags
);
2001 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2003 if (current_ref_iter
&&
2004 (current_ref_iter
->oid
== base
||
2005 oideq(current_ref_iter
->oid
, base
)))
2006 return ref_iterator_peel(current_ref_iter
, peeled
);
2008 return peel_object(base
, peeled
) ? -1 : 0;
2011 int refs_create_symref(struct ref_store
*refs
,
2012 const char *ref_target
,
2013 const char *refs_heads_master
,
2019 msg
= normalize_reflog_message(logmsg
);
2020 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2026 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2029 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2030 refs_heads_master
, logmsg
);
2033 int ref_update_reject_duplicates(struct string_list
*refnames
,
2036 size_t i
, n
= refnames
->nr
;
2040 for (i
= 1; i
< n
; i
++) {
2041 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2042 refnames
->items
[i
].string
);
2046 _("multiple updates for ref '%s' not allowed"),
2047 refnames
->items
[i
].string
);
2049 } else if (cmp
> 0) {
2050 BUG("ref_update_reject_duplicates() received unsorted list");
2056 static int run_transaction_hook(struct ref_transaction
*transaction
,
2059 struct child_process proc
= CHILD_PROCESS_INIT
;
2060 struct strbuf buf
= STRBUF_INIT
;
2064 hook
= find_hook("reference-transaction");
2068 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2070 proc
.stdout_to_stderr
= 1;
2071 proc
.trace2_hook_name
= "reference-transaction";
2073 ret
= start_command(&proc
);
2077 sigchain_push(SIGPIPE
, SIG_IGN
);
2079 for (i
= 0; i
< transaction
->nr
; i
++) {
2080 struct ref_update
*update
= transaction
->updates
[i
];
2083 strbuf_addf(&buf
, "%s %s %s\n",
2084 oid_to_hex(&update
->old_oid
),
2085 oid_to_hex(&update
->new_oid
),
2088 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2096 sigchain_pop(SIGPIPE
);
2097 strbuf_release(&buf
);
2099 ret
|= finish_command(&proc
);
2103 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2106 struct ref_store
*refs
= transaction
->ref_store
;
2109 switch (transaction
->state
) {
2110 case REF_TRANSACTION_OPEN
:
2113 case REF_TRANSACTION_PREPARED
:
2114 BUG("prepare called twice on reference transaction");
2116 case REF_TRANSACTION_CLOSED
:
2117 BUG("prepare called on a closed reference transaction");
2120 BUG("unexpected reference transaction state");
2124 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
2126 _("ref updates forbidden inside quarantine environment"));
2130 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2134 ret
= run_transaction_hook(transaction
, "prepared");
2136 ref_transaction_abort(transaction
, err
);
2137 die(_("ref updates aborted by hook"));
2143 int ref_transaction_abort(struct ref_transaction
*transaction
,
2146 struct ref_store
*refs
= transaction
->ref_store
;
2149 switch (transaction
->state
) {
2150 case REF_TRANSACTION_OPEN
:
2151 /* No need to abort explicitly. */
2153 case REF_TRANSACTION_PREPARED
:
2154 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2156 case REF_TRANSACTION_CLOSED
:
2157 BUG("abort called on a closed reference transaction");
2160 BUG("unexpected reference transaction state");
2164 run_transaction_hook(transaction
, "aborted");
2166 ref_transaction_free(transaction
);
2170 int ref_transaction_commit(struct ref_transaction
*transaction
,
2173 struct ref_store
*refs
= transaction
->ref_store
;
2176 switch (transaction
->state
) {
2177 case REF_TRANSACTION_OPEN
:
2178 /* Need to prepare first. */
2179 ret
= ref_transaction_prepare(transaction
, err
);
2183 case REF_TRANSACTION_PREPARED
:
2184 /* Fall through to finish. */
2186 case REF_TRANSACTION_CLOSED
:
2187 BUG("commit called on a closed reference transaction");
2190 BUG("unexpected reference transaction state");
2194 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2196 run_transaction_hook(transaction
, "committed");
2200 int refs_verify_refname_available(struct ref_store
*refs
,
2201 const char *refname
,
2202 const struct string_list
*extras
,
2203 const struct string_list
*skip
,
2207 const char *extra_refname
;
2208 struct strbuf dirname
= STRBUF_INIT
;
2209 struct strbuf referent
= STRBUF_INIT
;
2210 struct object_id oid
;
2212 struct ref_iterator
*iter
;
2217 * For the sake of comments in this function, suppose that
2218 * refname is "refs/foo/bar".
2223 strbuf_grow(&dirname
, strlen(refname
) + 1);
2224 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2226 * Just saying "Is a directory" when we e.g. can't
2227 * lock some multi-level ref isn't very informative,
2228 * the user won't be told *what* is a directory, so
2229 * let's not use strerror() below.
2232 /* Expand dirname to the new prefix, not including the trailing slash: */
2233 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2236 * We are still at a leading dir of the refname (e.g.,
2237 * "refs/foo"; if there is a reference with that name,
2238 * it is a conflict, *unless* it is in skip.
2240 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2243 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2244 &type
, &ignore_errno
)) {
2245 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2246 dirname
.buf
, refname
);
2250 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2251 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2252 refname
, dirname
.buf
);
2258 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2259 * There is no point in searching for a reference with that
2260 * name, because a refname isn't considered to conflict with
2261 * itself. But we still need to check for references whose
2262 * names are in the "refs/foo/bar/" namespace, because they
2265 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2266 strbuf_addch(&dirname
, '/');
2268 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2269 DO_FOR_EACH_INCLUDE_BROKEN
);
2270 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2272 string_list_has_string(skip
, iter
->refname
))
2275 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2276 iter
->refname
, refname
);
2277 ref_iterator_abort(iter
);
2281 if (ok
!= ITER_DONE
)
2282 BUG("error while iterating over references");
2284 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2286 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2287 refname
, extra_refname
);
2292 strbuf_release(&referent
);
2293 strbuf_release(&dirname
);
2297 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2299 struct ref_iterator
*iter
;
2300 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2302 iter
= refs
->be
->reflog_iterator_begin(refs
);
2304 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2305 do_for_each_ref_helper
, &hp
);
2308 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2310 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2313 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2314 const char *refname
,
2315 each_reflog_ent_fn fn
,
2318 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2322 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2325 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2326 refname
, fn
, cb_data
);
2329 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2330 each_reflog_ent_fn fn
, void *cb_data
)
2332 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2335 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2338 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2342 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2344 return refs
->be
->reflog_exists(refs
, refname
);
2347 int reflog_exists(const char *refname
)
2349 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2352 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2353 int force_create
, struct strbuf
*err
)
2355 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2358 int safe_create_reflog(const char *refname
, int force_create
,
2361 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2365 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2367 return refs
->be
->delete_reflog(refs
, refname
);
2370 int delete_reflog(const char *refname
)
2372 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2375 int refs_reflog_expire(struct ref_store
*refs
,
2376 const char *refname
,
2378 reflog_expiry_prepare_fn prepare_fn
,
2379 reflog_expiry_should_prune_fn should_prune_fn
,
2380 reflog_expiry_cleanup_fn cleanup_fn
,
2381 void *policy_cb_data
)
2383 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2384 prepare_fn
, should_prune_fn
,
2385 cleanup_fn
, policy_cb_data
);
2388 int reflog_expire(const char *refname
,
2390 reflog_expiry_prepare_fn prepare_fn
,
2391 reflog_expiry_should_prune_fn should_prune_fn
,
2392 reflog_expiry_cleanup_fn cleanup_fn
,
2393 void *policy_cb_data
)
2395 return refs_reflog_expire(get_main_ref_store(the_repository
),
2397 prepare_fn
, should_prune_fn
,
2398 cleanup_fn
, policy_cb_data
);
2401 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2404 struct ref_store
*refs
= transaction
->ref_store
;
2406 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2409 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2410 struct string_list
*refnames
, unsigned int flags
)
2415 msg
= normalize_reflog_message(logmsg
);
2416 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2421 int delete_refs(const char *msg
, struct string_list
*refnames
,
2424 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2427 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2428 const char *newref
, const char *logmsg
)
2433 msg
= normalize_reflog_message(logmsg
);
2434 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2439 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2441 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2444 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2445 const char *newref
, const char *logmsg
)
2450 msg
= normalize_reflog_message(logmsg
);
2451 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2456 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2458 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);