2 * The backend-independent part of the reference module.
11 #include "refs/refs-internal.h"
12 #include "run-command.h"
14 #include "object-store.h"
17 #include "submodule.h"
20 #include "repository.h"
24 * List of all available backends
26 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
28 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
30 struct ref_storage_be
*be
;
31 for (be
= refs_backends
; be
; be
= be
->next
)
32 if (!strcmp(be
->name
, name
))
38 * How to handle various characters in refnames:
39 * 0: An acceptable character for refs
41 * 2: ., look for a preceding . to reject .. in refs
42 * 3: {, look for a preceding @ to reject @{ in refs
43 * 4: A bad character: ASCII control characters, and
44 * ":", "?", "[", "\", "^", "~", SP, or TAB
45 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
47 static unsigned char refname_disposition
[256] = {
48 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
49 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
50 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
51 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
59 * Try to read one refname component from the front of refname.
60 * Return the length of the component found, or -1 if the component is
61 * not legal. It is legal if it is something reasonable to have under
62 * ".git/refs/"; We do not like it if:
64 * - it begins with ".", or
65 * - it has double dots "..", or
66 * - it has ASCII control characters, or
67 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
68 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
69 * - it ends with a "/", or
70 * - it ends with ".lock", or
71 * - it contains a "@{" portion
73 * When sanitized is not NULL, instead of rejecting the input refname
74 * as an error, try to come up with a usable replacement for the input
77 static int check_refname_component(const char *refname
, int *flags
,
78 struct strbuf
*sanitized
)
82 size_t component_start
= 0; /* garbage - not a reasonable initial value */
85 component_start
= sanitized
->len
;
87 for (cp
= refname
; ; cp
++) {
89 unsigned char disp
= refname_disposition
[ch
];
91 if (sanitized
&& disp
!= 1)
92 strbuf_addch(sanitized
, ch
);
98 if (last
== '.') { /* Refname contains "..". */
100 /* collapse ".." to single "." */
101 strbuf_setlen(sanitized
, sanitized
->len
- 1);
107 if (last
== '@') { /* Refname contains "@{". */
109 sanitized
->buf
[sanitized
->len
-1] = '-';
117 sanitized
->buf
[sanitized
->len
-1] = '-';
122 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
123 /* refspec can't be a pattern */
125 sanitized
->buf
[sanitized
->len
-1] = '-';
131 * Unset the pattern flag so that we only accept
132 * a single asterisk for one side of refspec.
134 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
141 return 0; /* Component has zero length. */
143 if (refname
[0] == '.') { /* Component starts with '.'. */
145 sanitized
->buf
[component_start
] = '-';
149 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
150 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
153 /* Refname ends with ".lock". */
154 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
155 /* try again in case we have .lock.lock */
161 static int check_or_sanitize_refname(const char *refname
, int flags
,
162 struct strbuf
*sanitized
)
164 int component_len
, component_count
= 0;
166 if (!strcmp(refname
, "@")) {
167 /* Refname is a single character '@'. */
169 strbuf_addch(sanitized
, '-');
175 if (sanitized
&& sanitized
->len
)
176 strbuf_complete(sanitized
, '/');
178 /* We are at the start of a path component. */
179 component_len
= check_refname_component(refname
, &flags
,
181 if (sanitized
&& component_len
== 0)
182 ; /* OK, omit empty component */
183 else if (component_len
<= 0)
187 if (refname
[component_len
] == '\0')
189 /* Skip to next component. */
190 refname
+= component_len
+ 1;
193 if (refname
[component_len
- 1] == '.') {
194 /* Refname ends with '.'. */
196 ; /* omit ending dot */
200 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
201 return -1; /* Refname has only one component. */
205 int check_refname_format(const char *refname
, int flags
)
207 return check_or_sanitize_refname(refname
, flags
, NULL
);
210 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
212 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
213 BUG("sanitizing refname '%s' check returned error", refname
);
216 int refname_is_safe(const char *refname
)
220 if (skip_prefix(refname
, "refs/", &rest
)) {
223 size_t restlen
= strlen(rest
);
225 /* rest must not be empty, or start or end with "/" */
226 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
230 * Does the refname try to escape refs/?
231 * For example: refs/foo/../bar is safe but refs/foo/../../bar
234 buf
= xmallocz(restlen
);
235 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
241 if (!isupper(*refname
) && *refname
!= '_')
249 * Return true if refname, which has the specified oid and flags, can
250 * be resolved to an object in the database. If the referred-to object
251 * does not exist, emit a warning and return false.
253 int ref_resolves_to_object(const char *refname
,
254 struct repository
*repo
,
255 const struct object_id
*oid
,
258 if (flags
& REF_ISBROKEN
)
260 if (!repo_has_object_file(repo
, oid
)) {
261 error(_("%s does not point to a valid object!"), refname
);
267 char *refs_resolve_refdup(struct ref_store
*refs
,
268 const char *refname
, int resolve_flags
,
269 struct object_id
*oid
, int *flags
)
273 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
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
)
296 struct ref_store
*refs
= get_main_ref_store(the_repository
);
298 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
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
,
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
;
655 struct ref_store
*refs
= get_main_ref_store(repo
);
657 this_result
= refs_found
? &oid_from_ref
: oid
;
658 strbuf_reset(&fullref
);
659 strbuf_addf(&fullref
, *p
, len
, str
);
660 r
= refs_resolve_ref_unsafe(refs
, fullref
.buf
,
666 if (!warn_ambiguous_refs
)
668 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
669 warning(_("ignoring dangling symref %s"), fullref
.buf
);
670 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
671 warning(_("ignoring broken ref %s"), fullref
.buf
);
674 strbuf_release(&fullref
);
678 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
679 struct object_id
*oid
, char **log
)
681 struct ref_store
*refs
= get_main_ref_store(r
);
682 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
685 struct strbuf path
= STRBUF_INIT
;
688 for (p
= ref_rev_parse_rules
; *p
; p
++) {
689 struct object_id hash
;
690 const char *ref
, *it
;
693 strbuf_addf(&path
, *p
, len
, str
);
694 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
696 oid
? &hash
: NULL
, NULL
);
699 if (refs_reflog_exists(refs
, path
.buf
))
701 else if (strcmp(ref
, path
.buf
) &&
702 refs_reflog_exists(refs
, ref
))
711 if (!warn_ambiguous_refs
)
714 strbuf_release(&path
);
719 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
721 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
724 static int is_per_worktree_ref(const char *refname
)
726 return starts_with(refname
, "refs/worktree/") ||
727 starts_with(refname
, "refs/bisect/") ||
728 starts_with(refname
, "refs/rewritten/");
731 static int is_pseudoref_syntax(const char *refname
)
735 for (c
= refname
; *c
; c
++) {
736 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
743 static int is_main_pseudoref_syntax(const char *refname
)
745 return skip_prefix(refname
, "main-worktree/", &refname
) &&
747 is_pseudoref_syntax(refname
);
750 static int is_other_pseudoref_syntax(const char *refname
)
752 if (!skip_prefix(refname
, "worktrees/", &refname
))
754 refname
= strchr(refname
, '/');
755 if (!refname
|| !refname
[1])
757 return is_pseudoref_syntax(refname
+ 1);
760 enum ref_type
ref_type(const char *refname
)
762 if (is_per_worktree_ref(refname
))
763 return REF_TYPE_PER_WORKTREE
;
764 if (is_pseudoref_syntax(refname
))
765 return REF_TYPE_PSEUDOREF
;
766 if (is_main_pseudoref_syntax(refname
))
767 return REF_TYPE_MAIN_PSEUDOREF
;
768 if (is_other_pseudoref_syntax(refname
))
769 return REF_TYPE_OTHER_PSEUDOREF
;
770 return REF_TYPE_NORMAL
;
773 long get_files_ref_lock_timeout_ms(void)
775 static int configured
= 0;
777 /* The default timeout is 100 ms: */
778 static int timeout_ms
= 100;
781 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
788 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
790 const struct object_id
*old_oid
,
793 struct ref_transaction
*transaction
;
794 struct strbuf err
= STRBUF_INIT
;
796 transaction
= ref_store_transaction_begin(refs
, 0, &err
);
798 ref_transaction_delete(transaction
, refname
, old_oid
,
800 ref_transaction_commit(transaction
, &err
)) {
801 error("%s", err
.buf
);
802 ref_transaction_free(transaction
);
803 strbuf_release(&err
);
806 ref_transaction_free(transaction
);
807 strbuf_release(&err
);
811 int delete_ref(const char *msg
, const char *refname
,
812 const struct object_id
*old_oid
, unsigned int flags
)
814 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
818 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
823 while ((c
= *msg
++)) {
824 if (wasspace
&& isspace(c
))
826 wasspace
= isspace(c
);
834 static char *normalize_reflog_message(const char *msg
)
836 struct strbuf sb
= STRBUF_INIT
;
839 copy_reflog_msg(&sb
, msg
);
840 return strbuf_detach(&sb
, NULL
);
843 int should_autocreate_reflog(const char *refname
)
845 switch (log_all_ref_updates
) {
846 case LOG_REFS_ALWAYS
:
848 case LOG_REFS_NORMAL
:
849 return starts_with(refname
, "refs/heads/") ||
850 starts_with(refname
, "refs/remotes/") ||
851 starts_with(refname
, "refs/notes/") ||
852 !strcmp(refname
, "HEAD");
858 int is_branch(const char *refname
)
860 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
863 struct read_ref_at_cb
{
868 struct object_id
*oid
;
871 struct object_id ooid
;
872 struct object_id noid
;
876 timestamp_t
*cutoff_time
;
881 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
882 timestamp_t timestamp
, int tz
, const char *message
)
885 *cb
->msg
= xstrdup(message
);
887 *cb
->cutoff_time
= timestamp
;
891 *cb
->cutoff_cnt
= cb
->reccnt
;
894 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
895 const char *email
, timestamp_t timestamp
, int tz
,
896 const char *message
, void *cb_data
)
898 struct read_ref_at_cb
*cb
= cb_data
;
902 cb
->date
= timestamp
;
905 * It is not possible for cb->cnt == 0 on the first iteration because
906 * that special case is handled in read_ref_at().
910 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
911 if (timestamp
<= cb
->at_time
|| reached_count
) {
912 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
914 * we have not yet updated cb->[n|o]oid so they still
915 * hold the values for the previous record.
917 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
918 warning(_("log for ref %s has gap after %s"),
919 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
921 oidcpy(cb
->oid
, ooid
);
922 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
923 oidcpy(cb
->oid
, noid
);
924 else if (!oideq(noid
, cb
->oid
))
925 warning(_("log for ref %s unexpectedly ended on %s"),
926 cb
->refname
, show_date(cb
->date
, cb
->tz
,
927 DATE_MODE(RFC2822
)));
931 oidcpy(&cb
->ooid
, ooid
);
932 oidcpy(&cb
->noid
, noid
);
936 static int read_ref_at_ent_newest(struct object_id
*ooid
, struct object_id
*noid
,
937 const char *email
, timestamp_t timestamp
,
938 int tz
, const char *message
, void *cb_data
)
940 struct read_ref_at_cb
*cb
= cb_data
;
942 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
943 oidcpy(cb
->oid
, noid
);
944 /* We just want the first entry */
948 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
949 const char *email
, timestamp_t timestamp
,
950 int tz
, const char *message
, void *cb_data
)
952 struct read_ref_at_cb
*cb
= cb_data
;
954 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
955 oidcpy(cb
->oid
, ooid
);
956 if (is_null_oid(cb
->oid
))
957 oidcpy(cb
->oid
, noid
);
958 /* We just want the first entry */
962 int read_ref_at(struct ref_store
*refs
, const char *refname
,
963 unsigned int flags
, timestamp_t at_time
, int cnt
,
964 struct object_id
*oid
, char **msg
,
965 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
967 struct read_ref_at_cb cb
;
969 memset(&cb
, 0, sizeof(cb
));
970 cb
.refname
= refname
;
971 cb
.at_time
= at_time
;
974 cb
.cutoff_time
= cutoff_time
;
975 cb
.cutoff_tz
= cutoff_tz
;
976 cb
.cutoff_cnt
= cutoff_cnt
;
980 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
984 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
987 if (flags
& GET_OID_QUIETLY
)
990 die(_("log for %s is empty"), refname
);
995 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1000 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1004 struct ref_transaction
*tr
;
1007 CALLOC_ARRAY(tr
, 1);
1008 tr
->ref_store
= refs
;
1013 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1015 return ref_store_transaction_begin(get_main_ref_store(the_repository
), 0, err
);
1018 void ref_transaction_free(struct ref_transaction
*transaction
)
1025 switch (transaction
->state
) {
1026 case REF_TRANSACTION_OPEN
:
1027 case REF_TRANSACTION_CLOSED
:
1030 case REF_TRANSACTION_PREPARED
:
1031 BUG("free called on a prepared reference transaction");
1034 BUG("unexpected reference transaction state");
1038 for (i
= 0; i
< transaction
->nr
; i
++) {
1039 free(transaction
->updates
[i
]->msg
);
1040 free(transaction
->updates
[i
]);
1042 free(transaction
->updates
);
1046 struct ref_update
*ref_transaction_add_update(
1047 struct ref_transaction
*transaction
,
1048 const char *refname
, unsigned int flags
,
1049 const struct object_id
*new_oid
,
1050 const struct object_id
*old_oid
,
1053 struct ref_update
*update
;
1055 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1056 BUG("update called for transaction that is not open");
1058 FLEX_ALLOC_STR(update
, refname
, refname
);
1059 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1060 transaction
->updates
[transaction
->nr
++] = update
;
1062 update
->flags
= flags
;
1064 if (flags
& REF_HAVE_NEW
)
1065 oidcpy(&update
->new_oid
, new_oid
);
1066 if (flags
& REF_HAVE_OLD
)
1067 oidcpy(&update
->old_oid
, old_oid
);
1068 update
->msg
= normalize_reflog_message(msg
);
1072 int ref_transaction_update(struct ref_transaction
*transaction
,
1073 const char *refname
,
1074 const struct object_id
*new_oid
,
1075 const struct object_id
*old_oid
,
1076 unsigned int flags
, const char *msg
,
1081 if (!(flags
& REF_SKIP_REFNAME_VERIFICATION
) &&
1082 ((new_oid
&& !is_null_oid(new_oid
)) ?
1083 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1084 !refname_is_safe(refname
))) {
1085 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1090 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1091 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1094 * Clear flags outside the allowed set; this should be a noop because
1095 * of the BUG() check above, but it works around a -Wnonnull warning
1096 * with some versions of "gcc -O3".
1098 flags
&= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
;
1100 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1102 ref_transaction_add_update(transaction
, refname
, flags
,
1103 new_oid
, old_oid
, msg
);
1107 int ref_transaction_create(struct ref_transaction
*transaction
,
1108 const char *refname
,
1109 const struct object_id
*new_oid
,
1110 unsigned int flags
, const char *msg
,
1113 if (!new_oid
|| is_null_oid(new_oid
))
1114 BUG("create called without valid new_oid");
1115 return ref_transaction_update(transaction
, refname
, new_oid
,
1116 null_oid(), flags
, msg
, err
);
1119 int ref_transaction_delete(struct ref_transaction
*transaction
,
1120 const char *refname
,
1121 const struct object_id
*old_oid
,
1122 unsigned int flags
, const char *msg
,
1125 if (old_oid
&& is_null_oid(old_oid
))
1126 BUG("delete called with old_oid set to zeros");
1127 return ref_transaction_update(transaction
, refname
,
1128 null_oid(), old_oid
,
1132 int ref_transaction_verify(struct ref_transaction
*transaction
,
1133 const char *refname
,
1134 const struct object_id
*old_oid
,
1139 BUG("verify called with old_oid set to NULL");
1140 return ref_transaction_update(transaction
, refname
,
1145 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1146 const char *refname
, const struct object_id
*new_oid
,
1147 const struct object_id
*old_oid
, unsigned int flags
,
1148 enum action_on_err onerr
)
1150 struct ref_transaction
*t
= NULL
;
1151 struct strbuf err
= STRBUF_INIT
;
1154 t
= ref_store_transaction_begin(refs
, 0, &err
);
1156 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1158 ref_transaction_commit(t
, &err
)) {
1160 ref_transaction_free(t
);
1163 const char *str
= _("update_ref failed for ref '%s': %s");
1166 case UPDATE_REFS_MSG_ON_ERR
:
1167 error(str
, refname
, err
.buf
);
1169 case UPDATE_REFS_DIE_ON_ERR
:
1170 die(str
, refname
, err
.buf
);
1172 case UPDATE_REFS_QUIET_ON_ERR
:
1175 strbuf_release(&err
);
1178 strbuf_release(&err
);
1180 ref_transaction_free(t
);
1184 int update_ref(const char *msg
, const char *refname
,
1185 const struct object_id
*new_oid
,
1186 const struct object_id
*old_oid
,
1187 unsigned int flags
, enum action_on_err onerr
)
1189 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1190 old_oid
, flags
, onerr
);
1193 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1194 const char *refname
, int strict
)
1197 static char **scanf_fmts
;
1198 static int nr_rules
;
1200 struct strbuf resolved_buf
= STRBUF_INIT
;
1204 * Pre-generate scanf formats from ref_rev_parse_rules[].
1205 * Generate a format suitable for scanf from a
1206 * ref_rev_parse_rules rule by interpolating "%s" at the
1207 * location of the "%.*s".
1209 size_t total_len
= 0;
1212 /* the rule list is NULL terminated, count them first */
1213 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1214 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1215 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1217 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1220 for (i
= 0; i
< nr_rules
; i
++) {
1221 assert(offset
< total_len
);
1222 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1223 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1224 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1228 /* bail out if there are no rules */
1230 return xstrdup(refname
);
1232 /* buffer for scanf result, at most refname must fit */
1233 short_name
= xstrdup(refname
);
1235 /* skip first rule, it will always match */
1236 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1238 int rules_to_fail
= i
;
1241 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1244 short_name_len
= strlen(short_name
);
1247 * in strict mode, all (except the matched one) rules
1248 * must fail to resolve to a valid non-ambiguous ref
1251 rules_to_fail
= nr_rules
;
1254 * check if the short name resolves to a valid ref,
1255 * but use only rules prior to the matched one
1257 for (j
= 0; j
< rules_to_fail
; j
++) {
1258 const char *rule
= ref_rev_parse_rules
[j
];
1260 /* skip matched rule */
1265 * the short name is ambiguous, if it resolves
1266 * (with this previous rule) to a valid ref
1267 * read_ref() returns 0 on success
1269 strbuf_reset(&resolved_buf
);
1270 strbuf_addf(&resolved_buf
, rule
,
1271 short_name_len
, short_name
);
1272 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1277 * short name is non-ambiguous if all previous rules
1278 * haven't resolved to a valid ref
1280 if (j
== rules_to_fail
) {
1281 strbuf_release(&resolved_buf
);
1286 strbuf_release(&resolved_buf
);
1288 return xstrdup(refname
);
1291 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1293 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1297 static struct string_list
*hide_refs
;
1299 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1302 if (!strcmp("transfer.hiderefs", var
) ||
1303 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1304 !strcmp(key
, "hiderefs"))) {
1309 return config_error_nonbool(var
);
1310 ref
= xstrdup(value
);
1312 while (len
&& ref
[len
- 1] == '/')
1315 CALLOC_ARRAY(hide_refs
, 1);
1316 hide_refs
->strdup_strings
= 1;
1318 string_list_append(hide_refs
, ref
);
1323 int ref_is_hidden(const char *refname
, const char *refname_full
)
1329 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1330 const char *match
= hide_refs
->items
[i
].string
;
1331 const char *subject
;
1335 if (*match
== '!') {
1340 if (*match
== '^') {
1341 subject
= refname_full
;
1347 /* refname can be NULL when namespaces are used. */
1349 skip_prefix(subject
, match
, &p
) &&
1356 const char *find_descendant_ref(const char *dirname
,
1357 const struct string_list
*extras
,
1358 const struct string_list
*skip
)
1366 * Look at the place where dirname would be inserted into
1367 * extras. If there is an entry at that position that starts
1368 * with dirname (remember, dirname includes the trailing
1369 * slash) and is not in skip, then we have a conflict.
1371 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1372 pos
< extras
->nr
; pos
++) {
1373 const char *extra_refname
= extras
->items
[pos
].string
;
1375 if (!starts_with(extra_refname
, dirname
))
1378 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1379 return extra_refname
;
1384 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1386 struct object_id oid
;
1389 if (refs_resolve_ref_unsafe(refs
, "HEAD", RESOLVE_REF_READING
,
1391 return fn("HEAD", &oid
, flag
, cb_data
);
1396 int head_ref(each_ref_fn fn
, void *cb_data
)
1398 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1401 struct ref_iterator
*refs_ref_iterator_begin(
1402 struct ref_store
*refs
,
1403 const char *prefix
, int trim
,
1404 enum do_for_each_ref_flags flags
)
1406 struct ref_iterator
*iter
;
1408 if (!(flags
& DO_FOR_EACH_INCLUDE_BROKEN
)) {
1409 static int ref_paranoia
= -1;
1411 if (ref_paranoia
< 0)
1412 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 1);
1414 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1415 flags
|= DO_FOR_EACH_OMIT_DANGLING_SYMREFS
;
1419 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1422 * `iterator_begin()` already takes care of prefix, but we
1423 * might need to do some trimming:
1426 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1428 /* Sanity check for subclasses: */
1430 BUG("reference iterator is not ordered");
1436 * Call fn for each reference in the specified submodule for which the
1437 * refname begins with prefix. If trim is non-zero, then trim that
1438 * many characters off the beginning of each refname before passing
1439 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1440 * include broken references in the iteration. If fn ever returns a
1441 * non-zero value, stop the iteration and return that value;
1442 * otherwise, return 0.
1444 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1445 each_repo_ref_fn fn
, int trim
, int flags
,
1448 struct ref_iterator
*iter
;
1449 struct ref_store
*refs
= get_main_ref_store(r
);
1454 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1456 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1459 struct do_for_each_ref_help
{
1464 static int do_for_each_ref_helper(struct repository
*r
,
1465 const char *refname
,
1466 const struct object_id
*oid
,
1470 struct do_for_each_ref_help
*hp
= cb_data
;
1472 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1475 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1476 each_ref_fn fn
, int trim
,
1477 enum do_for_each_ref_flags flags
, void *cb_data
)
1479 struct ref_iterator
*iter
;
1480 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1485 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1487 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1488 do_for_each_ref_helper
, &hp
);
1491 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1493 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1496 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1498 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1501 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1502 each_ref_fn fn
, void *cb_data
)
1504 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1507 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1509 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1512 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1514 return do_for_each_ref(get_main_ref_store(the_repository
),
1515 prefix
, fn
, 0, 0, cb_data
);
1518 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1519 each_ref_fn fn
, void *cb_data
)
1521 return do_for_each_ref(refs
, prefix
, fn
, 0, 0, cb_data
);
1524 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1526 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1527 strlen(git_replace_ref_base
),
1528 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1531 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1533 struct strbuf buf
= STRBUF_INIT
;
1535 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1536 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1537 buf
.buf
, fn
, 0, 0, cb_data
);
1538 strbuf_release(&buf
);
1542 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1544 return do_for_each_ref(refs
, "", fn
, 0,
1545 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1548 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1550 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1553 static int qsort_strcmp(const void *va
, const void *vb
)
1555 const char *a
= *(const char **)va
;
1556 const char *b
= *(const char **)vb
;
1558 return strcmp(a
, b
);
1561 static void find_longest_prefixes_1(struct string_list
*out
,
1562 struct strbuf
*prefix
,
1563 const char **patterns
, size_t nr
)
1567 for (i
= 0; i
< nr
; i
++) {
1568 char c
= patterns
[i
][prefix
->len
];
1569 if (!c
|| is_glob_special(c
)) {
1570 string_list_append(out
, prefix
->buf
);
1580 * Set "end" to the index of the element _after_ the last one
1583 for (end
= i
+ 1; end
< nr
; end
++) {
1584 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1588 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1589 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1590 strbuf_setlen(prefix
, prefix
->len
- 1);
1596 static void find_longest_prefixes(struct string_list
*out
,
1597 const char **patterns
)
1599 struct strvec sorted
= STRVEC_INIT
;
1600 struct strbuf prefix
= STRBUF_INIT
;
1602 strvec_pushv(&sorted
, patterns
);
1603 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1605 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1607 strvec_clear(&sorted
);
1608 strbuf_release(&prefix
);
1611 int for_each_fullref_in_prefixes(const char *namespace,
1612 const char **patterns
,
1613 each_ref_fn fn
, void *cb_data
)
1615 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1616 struct string_list_item
*prefix
;
1617 struct strbuf buf
= STRBUF_INIT
;
1618 int ret
= 0, namespace_len
;
1620 find_longest_prefixes(&prefixes
, patterns
);
1623 strbuf_addstr(&buf
, namespace);
1624 namespace_len
= buf
.len
;
1626 for_each_string_list_item(prefix
, &prefixes
) {
1627 strbuf_addstr(&buf
, prefix
->string
);
1628 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
);
1631 strbuf_setlen(&buf
, namespace_len
);
1634 string_list_clear(&prefixes
, 0);
1635 strbuf_release(&buf
);
1639 static int refs_read_special_head(struct ref_store
*ref_store
,
1640 const char *refname
, struct object_id
*oid
,
1641 struct strbuf
*referent
, unsigned int *type
,
1644 struct strbuf full_path
= STRBUF_INIT
;
1645 struct strbuf content
= STRBUF_INIT
;
1647 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1649 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1652 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
,
1656 strbuf_release(&full_path
);
1657 strbuf_release(&content
);
1661 int refs_read_raw_ref(struct ref_store
*ref_store
, const char *refname
,
1662 struct object_id
*oid
, struct strbuf
*referent
,
1663 unsigned int *type
, int *failure_errno
)
1665 assert(failure_errno
);
1666 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1667 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1668 type
, failure_errno
);
1671 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1672 type
, failure_errno
);
1675 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1676 const char *refname
,
1678 struct object_id
*oid
,
1681 static struct strbuf sb_refname
= STRBUF_INIT
;
1682 struct object_id unused_oid
;
1689 flags
= &unused_flags
;
1693 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1694 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1695 !refname_is_safe(refname
))
1699 * dwim_ref() uses REF_ISBROKEN to distinguish between
1700 * missing refs and refs that were present but invalid,
1701 * to complain about the latter to stderr.
1703 * We don't know whether the ref exists, so don't set
1706 *flags
|= REF_BAD_NAME
;
1709 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1710 unsigned int read_flags
= 0;
1713 if (refs_read_raw_ref(refs
, refname
, oid
, &sb_refname
,
1714 &read_flags
, &failure_errno
)) {
1715 *flags
|= read_flags
;
1717 /* In reading mode, refs must eventually resolve */
1718 if (resolve_flags
& RESOLVE_REF_READING
)
1722 * Otherwise a missing ref is OK. But the files backend
1723 * may show errors besides ENOENT if there are
1724 * similarly-named refs.
1726 if (failure_errno
!= ENOENT
&&
1727 failure_errno
!= EISDIR
&&
1728 failure_errno
!= ENOTDIR
)
1732 if (*flags
& REF_BAD_NAME
)
1733 *flags
|= REF_ISBROKEN
;
1737 *flags
|= read_flags
;
1739 if (!(read_flags
& REF_ISSYMREF
)) {
1740 if (*flags
& REF_BAD_NAME
) {
1742 *flags
|= REF_ISBROKEN
;
1747 refname
= sb_refname
.buf
;
1748 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1752 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1753 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1754 !refname_is_safe(refname
))
1757 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1764 /* backend functions */
1765 int refs_init_db(struct strbuf
*err
)
1767 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1769 return refs
->be
->init_db(refs
, err
);
1772 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1773 struct object_id
*oid
, int *flags
)
1775 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1776 resolve_flags
, oid
, flags
);
1779 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1780 struct object_id
*oid
)
1782 struct ref_store
*refs
;
1785 refs
= get_submodule_ref_store(submodule
);
1790 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1796 struct ref_store_hash_entry
1798 struct hashmap_entry ent
;
1800 struct ref_store
*refs
;
1802 /* NUL-terminated identifier of the ref store: */
1803 char name
[FLEX_ARRAY
];
1806 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1807 const struct hashmap_entry
*eptr
,
1808 const struct hashmap_entry
*entry_or_key
,
1809 const void *keydata
)
1811 const struct ref_store_hash_entry
*e1
, *e2
;
1814 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1815 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1816 name
= keydata
? keydata
: e2
->name
;
1818 return strcmp(e1
->name
, name
);
1821 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1822 const char *name
, struct ref_store
*refs
)
1824 struct ref_store_hash_entry
*entry
;
1826 FLEX_ALLOC_STR(entry
, name
, name
);
1827 hashmap_entry_init(&entry
->ent
, strhash(name
));
1832 /* A hashmap of ref_stores, stored by submodule name: */
1833 static struct hashmap submodule_ref_stores
;
1835 /* A hashmap of ref_stores, stored by worktree id: */
1836 static struct hashmap worktree_ref_stores
;
1839 * Look up a ref store by name. If that ref_store hasn't been
1840 * registered yet, return NULL.
1842 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1845 struct ref_store_hash_entry
*entry
;
1848 if (!map
->tablesize
)
1849 /* It's initialized on demand in register_ref_store(). */
1852 hash
= strhash(name
);
1853 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1854 struct ref_store_hash_entry
, ent
);
1855 return entry
? entry
->refs
: NULL
;
1859 * Create, record, and return a ref_store instance for the specified
1862 static struct ref_store
*ref_store_init(struct repository
*repo
,
1866 const char *be_name
= "files";
1867 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1868 struct ref_store
*refs
;
1871 BUG("reference backend %s is unknown", be_name
);
1873 refs
= be
->init(repo
, gitdir
, flags
);
1877 struct ref_store
*get_main_ref_store(struct repository
*r
)
1879 if (r
->refs_private
)
1880 return r
->refs_private
;
1883 BUG("attempting to get main_ref_store outside of repository");
1885 r
->refs_private
= ref_store_init(r
, r
->gitdir
, REF_STORE_ALL_CAPS
);
1886 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1887 return r
->refs_private
;
1891 * Associate a ref store with a name. It is a fatal error to call this
1892 * function twice for the same name.
1894 static void register_ref_store_map(struct hashmap
*map
,
1896 struct ref_store
*refs
,
1899 struct ref_store_hash_entry
*entry
;
1901 if (!map
->tablesize
)
1902 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1904 entry
= alloc_ref_store_hash_entry(name
, refs
);
1905 if (hashmap_put(map
, &entry
->ent
))
1906 BUG("%s ref_store '%s' initialized twice", type
, name
);
1909 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1911 struct strbuf submodule_sb
= STRBUF_INIT
;
1912 struct ref_store
*refs
;
1913 char *to_free
= NULL
;
1915 struct repository
*subrepo
;
1920 len
= strlen(submodule
);
1921 while (len
&& is_dir_sep(submodule
[len
- 1]))
1927 /* We need to strip off one or more trailing slashes */
1928 submodule
= to_free
= xmemdupz(submodule
, len
);
1930 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1934 strbuf_addstr(&submodule_sb
, submodule
);
1935 if (!is_nonbare_repository_dir(&submodule_sb
))
1938 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1941 subrepo
= xmalloc(sizeof(*subrepo
));
1943 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
1944 * superprojects other than the_repository. This probably should be
1945 * done by making it take a struct repository * parameter instead of a
1948 if (repo_submodule_init(subrepo
, the_repository
, submodule
,
1953 refs
= ref_store_init(subrepo
, submodule_sb
.buf
,
1954 REF_STORE_READ
| REF_STORE_ODB
);
1955 register_ref_store_map(&submodule_ref_stores
, "submodule",
1959 strbuf_release(&submodule_sb
);
1965 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1967 struct ref_store
*refs
;
1971 return get_main_ref_store(the_repository
);
1973 id
= wt
->id
? wt
->id
: "/";
1974 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1979 refs
= ref_store_init(the_repository
,
1980 git_common_path("worktrees/%s", wt
->id
),
1981 REF_STORE_ALL_CAPS
);
1983 refs
= ref_store_init(the_repository
,
1984 get_git_common_dir(),
1985 REF_STORE_ALL_CAPS
);
1988 register_ref_store_map(&worktree_ref_stores
, "worktree",
1993 void base_ref_store_init(struct ref_store
*refs
, struct repository
*repo
,
1994 const char *path
, const struct ref_storage_be
*be
)
1998 refs
->gitdir
= xstrdup(path
);
2001 /* backend functions */
2002 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
2004 return refs
->be
->pack_refs(refs
, flags
);
2007 int peel_iterated_oid(const struct object_id
*base
, struct object_id
*peeled
)
2009 if (current_ref_iter
&&
2010 (current_ref_iter
->oid
== base
||
2011 oideq(current_ref_iter
->oid
, base
)))
2012 return ref_iterator_peel(current_ref_iter
, peeled
);
2014 return peel_object(base
, peeled
) ? -1 : 0;
2017 int refs_create_symref(struct ref_store
*refs
,
2018 const char *ref_target
,
2019 const char *refs_heads_master
,
2025 msg
= normalize_reflog_message(logmsg
);
2026 retval
= refs
->be
->create_symref(refs
, ref_target
, refs_heads_master
,
2032 int create_symref(const char *ref_target
, const char *refs_heads_master
,
2035 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
2036 refs_heads_master
, logmsg
);
2039 int ref_update_reject_duplicates(struct string_list
*refnames
,
2042 size_t i
, n
= refnames
->nr
;
2046 for (i
= 1; i
< n
; i
++) {
2047 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
2048 refnames
->items
[i
].string
);
2052 _("multiple updates for ref '%s' not allowed"),
2053 refnames
->items
[i
].string
);
2055 } else if (cmp
> 0) {
2056 BUG("ref_update_reject_duplicates() received unsorted list");
2062 static int run_transaction_hook(struct ref_transaction
*transaction
,
2065 struct child_process proc
= CHILD_PROCESS_INIT
;
2066 struct strbuf buf
= STRBUF_INIT
;
2070 if (transaction
->flags
& REF_TRANSACTION_SKIP_HOOK
)
2073 hook
= find_hook("reference-transaction");
2077 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2079 proc
.stdout_to_stderr
= 1;
2080 proc
.trace2_hook_name
= "reference-transaction";
2082 ret
= start_command(&proc
);
2086 sigchain_push(SIGPIPE
, SIG_IGN
);
2088 for (i
= 0; i
< transaction
->nr
; i
++) {
2089 struct ref_update
*update
= transaction
->updates
[i
];
2092 strbuf_addf(&buf
, "%s %s %s\n",
2093 oid_to_hex(&update
->old_oid
),
2094 oid_to_hex(&update
->new_oid
),
2097 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2098 if (errno
!= EPIPE
) {
2099 /* Don't leak errno outside this API */
2108 sigchain_pop(SIGPIPE
);
2109 strbuf_release(&buf
);
2111 ret
|= finish_command(&proc
);
2115 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2118 struct ref_store
*refs
= transaction
->ref_store
;
2121 switch (transaction
->state
) {
2122 case REF_TRANSACTION_OPEN
:
2125 case REF_TRANSACTION_PREPARED
:
2126 BUG("prepare called twice on reference transaction");
2128 case REF_TRANSACTION_CLOSED
:
2129 BUG("prepare called on a closed reference transaction");
2132 BUG("unexpected reference transaction state");
2136 if (refs
->repo
->objects
->odb
->disable_ref_updates
) {
2138 _("ref updates forbidden inside quarantine environment"));
2142 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2146 ret
= run_transaction_hook(transaction
, "prepared");
2148 ref_transaction_abort(transaction
, err
);
2149 die(_("ref updates aborted by hook"));
2155 int ref_transaction_abort(struct ref_transaction
*transaction
,
2158 struct ref_store
*refs
= transaction
->ref_store
;
2161 switch (transaction
->state
) {
2162 case REF_TRANSACTION_OPEN
:
2163 /* No need to abort explicitly. */
2165 case REF_TRANSACTION_PREPARED
:
2166 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2168 case REF_TRANSACTION_CLOSED
:
2169 BUG("abort called on a closed reference transaction");
2172 BUG("unexpected reference transaction state");
2176 run_transaction_hook(transaction
, "aborted");
2178 ref_transaction_free(transaction
);
2182 int ref_transaction_commit(struct ref_transaction
*transaction
,
2185 struct ref_store
*refs
= transaction
->ref_store
;
2188 switch (transaction
->state
) {
2189 case REF_TRANSACTION_OPEN
:
2190 /* Need to prepare first. */
2191 ret
= ref_transaction_prepare(transaction
, err
);
2195 case REF_TRANSACTION_PREPARED
:
2196 /* Fall through to finish. */
2198 case REF_TRANSACTION_CLOSED
:
2199 BUG("commit called on a closed reference transaction");
2202 BUG("unexpected reference transaction state");
2206 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2208 run_transaction_hook(transaction
, "committed");
2212 int refs_verify_refname_available(struct ref_store
*refs
,
2213 const char *refname
,
2214 const struct string_list
*extras
,
2215 const struct string_list
*skip
,
2219 const char *extra_refname
;
2220 struct strbuf dirname
= STRBUF_INIT
;
2221 struct strbuf referent
= STRBUF_INIT
;
2222 struct object_id oid
;
2224 struct ref_iterator
*iter
;
2229 * For the sake of comments in this function, suppose that
2230 * refname is "refs/foo/bar".
2235 strbuf_grow(&dirname
, strlen(refname
) + 1);
2236 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2238 * Just saying "Is a directory" when we e.g. can't
2239 * lock some multi-level ref isn't very informative,
2240 * the user won't be told *what* is a directory, so
2241 * let's not use strerror() below.
2244 /* Expand dirname to the new prefix, not including the trailing slash: */
2245 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2248 * We are still at a leading dir of the refname (e.g.,
2249 * "refs/foo"; if there is a reference with that name,
2250 * it is a conflict, *unless* it is in skip.
2252 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2255 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
,
2256 &type
, &ignore_errno
)) {
2257 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2258 dirname
.buf
, refname
);
2262 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2263 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2264 refname
, dirname
.buf
);
2270 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2271 * There is no point in searching for a reference with that
2272 * name, because a refname isn't considered to conflict with
2273 * itself. But we still need to check for references whose
2274 * names are in the "refs/foo/bar/" namespace, because they
2277 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2278 strbuf_addch(&dirname
, '/');
2280 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2281 DO_FOR_EACH_INCLUDE_BROKEN
);
2282 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2284 string_list_has_string(skip
, iter
->refname
))
2287 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2288 iter
->refname
, refname
);
2289 ref_iterator_abort(iter
);
2293 if (ok
!= ITER_DONE
)
2294 BUG("error while iterating over references");
2296 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2298 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2299 refname
, extra_refname
);
2304 strbuf_release(&referent
);
2305 strbuf_release(&dirname
);
2309 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2311 struct ref_iterator
*iter
;
2312 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2314 iter
= refs
->be
->reflog_iterator_begin(refs
);
2316 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2317 do_for_each_ref_helper
, &hp
);
2320 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2322 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2325 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2326 const char *refname
,
2327 each_reflog_ent_fn fn
,
2330 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2334 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2337 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2338 refname
, fn
, cb_data
);
2341 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2342 each_reflog_ent_fn fn
, void *cb_data
)
2344 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2347 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2350 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2354 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2356 return refs
->be
->reflog_exists(refs
, refname
);
2359 int reflog_exists(const char *refname
)
2361 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2364 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2367 return refs
->be
->create_reflog(refs
, refname
, err
);
2370 int safe_create_reflog(const char *refname
, struct strbuf
*err
)
2372 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2376 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2378 return refs
->be
->delete_reflog(refs
, refname
);
2381 int delete_reflog(const char *refname
)
2383 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2386 int refs_reflog_expire(struct ref_store
*refs
,
2387 const char *refname
,
2389 reflog_expiry_prepare_fn prepare_fn
,
2390 reflog_expiry_should_prune_fn should_prune_fn
,
2391 reflog_expiry_cleanup_fn cleanup_fn
,
2392 void *policy_cb_data
)
2394 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2395 prepare_fn
, should_prune_fn
,
2396 cleanup_fn
, policy_cb_data
);
2399 int reflog_expire(const char *refname
,
2401 reflog_expiry_prepare_fn prepare_fn
,
2402 reflog_expiry_should_prune_fn should_prune_fn
,
2403 reflog_expiry_cleanup_fn cleanup_fn
,
2404 void *policy_cb_data
)
2406 return refs_reflog_expire(get_main_ref_store(the_repository
),
2408 prepare_fn
, should_prune_fn
,
2409 cleanup_fn
, policy_cb_data
);
2412 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2415 struct ref_store
*refs
= transaction
->ref_store
;
2417 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2420 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2421 struct string_list
*refnames
, unsigned int flags
)
2426 msg
= normalize_reflog_message(logmsg
);
2427 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2432 int delete_refs(const char *msg
, struct string_list
*refnames
,
2435 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2438 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2439 const char *newref
, const char *logmsg
)
2444 msg
= normalize_reflog_message(logmsg
);
2445 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2450 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2452 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2455 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2456 const char *newref
, const char *logmsg
)
2461 msg
= normalize_reflog_message(logmsg
);
2462 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2467 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2469 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);