2 * The backend-independent part of the reference module.
11 #include "refs/refs-internal.h"
12 #include "object-store.h"
15 #include "submodule.h"
17 #include "argv-array.h"
18 #include "repository.h"
21 * List of all available backends
23 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
25 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
27 struct ref_storage_be
*be
;
28 for (be
= refs_backends
; be
; be
= be
->next
)
29 if (!strcmp(be
->name
, name
))
34 int ref_storage_backend_exists(const char *name
)
36 return find_ref_storage_backend(name
) != NULL
;
40 * How to handle various characters in refnames:
41 * 0: An acceptable character for refs
43 * 2: ., look for a preceding . to reject .. in refs
44 * 3: {, look for a preceding @ to reject @{ in refs
45 * 4: A bad character: ASCII control characters, and
46 * ":", "?", "[", "\", "^", "~", SP, or TAB
47 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
49 static unsigned char refname_disposition
[256] = {
50 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
51 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
52 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
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, 4, 4, 0, 4, 0,
56 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
57 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
61 * Try to read one refname component from the front of refname.
62 * Return the length of the component found, or -1 if the component is
63 * not legal. It is legal if it is something reasonable to have under
64 * ".git/refs/"; We do not like it if:
66 * - any path component of it begins with ".", or
67 * - it has double dots "..", or
68 * - it has ASCII control characters, or
69 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
70 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
71 * - it ends with a "/", or
72 * - it ends with ".lock", or
73 * - it contains a "@{" portion
75 static int check_refname_component(const char *refname
, int *flags
)
80 for (cp
= refname
; ; cp
++) {
82 unsigned char disp
= refname_disposition
[ch
];
88 return -1; /* Refname contains "..". */
92 return -1; /* Refname contains "@{". */
97 if (!(*flags
& REFNAME_REFSPEC_PATTERN
))
98 return -1; /* refspec can't be a pattern */
101 * Unset the pattern flag so that we only accept
102 * a single asterisk for one side of refspec.
104 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
111 return 0; /* Component has zero length. */
112 if (refname
[0] == '.')
113 return -1; /* Component starts with '.'. */
114 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
115 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
))
116 return -1; /* Refname ends with ".lock". */
120 int check_refname_format(const char *refname
, int flags
)
122 int component_len
, component_count
= 0;
124 if (!strcmp(refname
, "@"))
125 /* Refname is a single character '@'. */
129 /* We are at the start of a path component. */
130 component_len
= check_refname_component(refname
, &flags
);
131 if (component_len
<= 0)
135 if (refname
[component_len
] == '\0')
137 /* Skip to next component. */
138 refname
+= component_len
+ 1;
141 if (refname
[component_len
- 1] == '.')
142 return -1; /* Refname ends with '.'. */
143 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
144 return -1; /* Refname has only one component. */
148 int refname_is_safe(const char *refname
)
152 if (skip_prefix(refname
, "refs/", &rest
)) {
155 size_t restlen
= strlen(rest
);
157 /* rest must not be empty, or start or end with "/" */
158 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
162 * Does the refname try to escape refs/?
163 * For example: refs/foo/../bar is safe but refs/foo/../../bar
166 buf
= xmallocz(restlen
);
167 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
173 if (!isupper(*refname
) && *refname
!= '_')
181 * Return true if refname, which has the specified oid and flags, can
182 * be resolved to an object in the database. If the referred-to object
183 * does not exist, emit a warning and return false.
185 int ref_resolves_to_object(const char *refname
,
186 const struct object_id
*oid
,
189 if (flags
& REF_ISBROKEN
)
191 if (!has_sha1_file(oid
->hash
)) {
192 error(_("%s does not point to a valid object!"), refname
);
198 char *refs_resolve_refdup(struct ref_store
*refs
,
199 const char *refname
, int resolve_flags
,
200 struct object_id
*oid
, int *flags
)
204 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
206 return xstrdup_or_null(result
);
209 char *resolve_refdup(const char *refname
, int resolve_flags
,
210 struct object_id
*oid
, int *flags
)
212 return refs_resolve_refdup(get_main_ref_store(the_repository
),
213 refname
, resolve_flags
,
217 /* The argument to filter_refs */
224 int refs_read_ref_full(struct ref_store
*refs
, const char *refname
,
225 int resolve_flags
, struct object_id
*oid
, int *flags
)
227 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
, oid
, flags
))
232 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
234 return refs_read_ref_full(get_main_ref_store(the_repository
), refname
,
235 resolve_flags
, oid
, flags
);
238 int read_ref(const char *refname
, struct object_id
*oid
)
240 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
243 int ref_exists(const char *refname
)
245 return !!resolve_ref_unsafe(refname
, RESOLVE_REF_READING
, NULL
, NULL
);
248 static int match_ref_pattern(const char *refname
,
249 const struct string_list_item
*item
)
252 if (item
->util
== NULL
) {
253 if (!wildmatch(item
->string
, refname
, 0))
257 if (skip_prefix(refname
, item
->string
, &rest
) &&
258 (!*rest
|| *rest
== '/'))
264 int ref_filter_match(const char *refname
,
265 const struct string_list
*include_patterns
,
266 const struct string_list
*exclude_patterns
)
268 struct string_list_item
*item
;
270 if (exclude_patterns
&& exclude_patterns
->nr
) {
271 for_each_string_list_item(item
, exclude_patterns
) {
272 if (match_ref_pattern(refname
, item
))
277 if (include_patterns
&& include_patterns
->nr
) {
279 for_each_string_list_item(item
, include_patterns
) {
280 if (match_ref_pattern(refname
, item
)) {
292 static int filter_refs(const char *refname
, const struct object_id
*oid
,
293 int flags
, void *data
)
295 struct ref_filter
*filter
= (struct ref_filter
*)data
;
297 if (wildmatch(filter
->pattern
, refname
, 0))
299 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
302 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
304 struct object
*o
= lookup_unknown_object(name
->hash
);
306 if (o
->type
== OBJ_NONE
) {
307 int type
= oid_object_info(the_repository
, name
, NULL
);
308 if (type
< 0 || !object_as_type(the_repository
, o
, type
, 0))
312 if (o
->type
!= OBJ_TAG
)
315 o
= deref_tag_noverify(o
);
319 oidcpy(oid
, &o
->oid
);
323 struct warn_if_dangling_data
{
326 const struct string_list
*refnames
;
330 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
331 int flags
, void *cb_data
)
333 struct warn_if_dangling_data
*d
= cb_data
;
334 const char *resolves_to
;
336 if (!(flags
& REF_ISSYMREF
))
339 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
342 ? strcmp(resolves_to
, d
->refname
)
343 : !string_list_has_string(d
->refnames
, resolves_to
))) {
347 fprintf(d
->fp
, d
->msg_fmt
, refname
);
352 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
354 struct warn_if_dangling_data data
;
357 data
.refname
= refname
;
358 data
.refnames
= NULL
;
359 data
.msg_fmt
= msg_fmt
;
360 for_each_rawref(warn_if_dangling_symref
, &data
);
363 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
365 struct warn_if_dangling_data data
;
369 data
.refnames
= refnames
;
370 data
.msg_fmt
= msg_fmt
;
371 for_each_rawref(warn_if_dangling_symref
, &data
);
374 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
376 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
379 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
381 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
384 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
386 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
389 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
391 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
394 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
396 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
399 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
401 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
404 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
406 struct strbuf buf
= STRBUF_INIT
;
408 struct object_id oid
;
411 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
412 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
413 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
414 strbuf_release(&buf
);
419 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
422 struct strbuf normalized_pattern
= STRBUF_INIT
;
425 BUG("pattern must not start with '/'");
428 strbuf_addstr(&normalized_pattern
, prefix
);
430 else if (!starts_with(pattern
, "refs/"))
431 strbuf_addstr(&normalized_pattern
, "refs/");
432 strbuf_addstr(&normalized_pattern
, pattern
);
433 strbuf_strip_suffix(&normalized_pattern
, "/");
435 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
436 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
437 strbuf_release(&normalized_pattern
);
440 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
441 const char *prefix
, void *cb_data
)
443 struct strbuf real_pattern
= STRBUF_INIT
;
444 struct ref_filter filter
;
447 if (!prefix
&& !starts_with(pattern
, "refs/"))
448 strbuf_addstr(&real_pattern
, "refs/");
450 strbuf_addstr(&real_pattern
, prefix
);
451 strbuf_addstr(&real_pattern
, pattern
);
453 if (!has_glob_specials(pattern
)) {
454 /* Append implied '/' '*' if not present. */
455 strbuf_complete(&real_pattern
, '/');
456 /* No need to check for '*', there is none. */
457 strbuf_addch(&real_pattern
, '*');
460 filter
.pattern
= real_pattern
.buf
;
462 filter
.cb_data
= cb_data
;
463 ret
= for_each_ref(filter_refs
, &filter
);
465 strbuf_release(&real_pattern
);
469 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
471 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
474 const char *prettify_refname(const char *name
)
476 if (skip_prefix(name
, "refs/heads/", &name
) ||
477 skip_prefix(name
, "refs/tags/", &name
) ||
478 skip_prefix(name
, "refs/remotes/", &name
))
483 static const char *ref_rev_parse_rules
[] = {
489 "refs/remotes/%.*s/HEAD",
493 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
496 * Is it possible that the caller meant full_name with abbrev_name?
497 * If so return a non-zero value to signal "yes"; the magnitude of
498 * the returned value gives the precedence used for disambiguation.
500 * If abbrev_name cannot mean full_name, return 0.
502 int refname_match(const char *abbrev_name
, const char *full_name
)
505 const int abbrev_name_len
= strlen(abbrev_name
);
506 const int num_rules
= NUM_REV_PARSE_RULES
;
508 for (p
= ref_rev_parse_rules
; *p
; p
++)
509 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
510 return &ref_rev_parse_rules
[num_rules
] - p
;
516 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
517 * the results to 'prefixes'
519 void expand_ref_prefix(struct argv_array
*prefixes
, const char *prefix
)
522 int len
= strlen(prefix
);
524 for (p
= ref_rev_parse_rules
; *p
; p
++)
525 argv_array_pushf(prefixes
, *p
, len
, prefix
);
529 * *string and *len will only be substituted, and *string returned (for
530 * later free()ing) if the string passed in is a magic short-hand form
533 static char *substitute_branch_name(const char **string
, int *len
)
535 struct strbuf buf
= STRBUF_INIT
;
536 int ret
= interpret_branch_name(*string
, *len
, &buf
, 0);
540 *string
= strbuf_detach(&buf
, &size
);
542 return (char *)*string
;
548 int dwim_ref(const char *str
, int len
, struct object_id
*oid
, char **ref
)
550 char *last_branch
= substitute_branch_name(&str
, &len
);
551 int refs_found
= expand_ref(str
, len
, oid
, ref
);
556 int expand_ref(const char *str
, int len
, struct object_id
*oid
, char **ref
)
560 struct strbuf fullref
= STRBUF_INIT
;
563 for (p
= ref_rev_parse_rules
; *p
; p
++) {
564 struct object_id oid_from_ref
;
565 struct object_id
*this_result
;
568 this_result
= refs_found
? &oid_from_ref
: oid
;
569 strbuf_reset(&fullref
);
570 strbuf_addf(&fullref
, *p
, len
, str
);
571 r
= resolve_ref_unsafe(fullref
.buf
, RESOLVE_REF_READING
,
576 if (!warn_ambiguous_refs
)
578 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
579 warning(_("ignoring dangling symref %s"), fullref
.buf
);
580 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
581 warning(_("ignoring broken ref %s"), fullref
.buf
);
584 strbuf_release(&fullref
);
588 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
590 char *last_branch
= substitute_branch_name(&str
, &len
);
593 struct strbuf path
= STRBUF_INIT
;
596 for (p
= ref_rev_parse_rules
; *p
; p
++) {
597 struct object_id hash
;
598 const char *ref
, *it
;
601 strbuf_addf(&path
, *p
, len
, str
);
602 ref
= resolve_ref_unsafe(path
.buf
, RESOLVE_REF_READING
,
606 if (reflog_exists(path
.buf
))
608 else if (strcmp(ref
, path
.buf
) && reflog_exists(ref
))
616 if (!warn_ambiguous_refs
)
619 strbuf_release(&path
);
624 static int is_per_worktree_ref(const char *refname
)
626 return !strcmp(refname
, "HEAD") ||
627 starts_with(refname
, "refs/worktree/") ||
628 starts_with(refname
, "refs/bisect/") ||
629 starts_with(refname
, "refs/rewritten/");
632 static int is_pseudoref_syntax(const char *refname
)
636 for (c
= refname
; *c
; c
++) {
637 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
644 static int is_main_pseudoref_syntax(const char *refname
)
646 return skip_prefix(refname
, "main-worktree/", &refname
) &&
648 is_pseudoref_syntax(refname
);
651 static int is_other_pseudoref_syntax(const char *refname
)
653 if (!skip_prefix(refname
, "worktrees/", &refname
))
655 refname
= strchr(refname
, '/');
656 if (!refname
|| !refname
[1])
658 return is_pseudoref_syntax(refname
+ 1);
661 enum ref_type
ref_type(const char *refname
)
663 if (is_per_worktree_ref(refname
))
664 return REF_TYPE_PER_WORKTREE
;
665 if (is_pseudoref_syntax(refname
))
666 return REF_TYPE_PSEUDOREF
;
667 if (is_main_pseudoref_syntax(refname
))
668 return REF_TYPE_MAIN_PSEUDOREF
;
669 if (is_other_pseudoref_syntax(refname
))
670 return REF_TYPE_OTHER_PSEUDOREF
;
671 return REF_TYPE_NORMAL
;
674 long get_files_ref_lock_timeout_ms(void)
676 static int configured
= 0;
678 /* The default timeout is 100 ms: */
679 static int timeout_ms
= 100;
682 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
689 static int write_pseudoref(const char *pseudoref
, const struct object_id
*oid
,
690 const struct object_id
*old_oid
, struct strbuf
*err
)
692 const char *filename
;
694 struct lock_file lock
= LOCK_INIT
;
695 struct strbuf buf
= STRBUF_INIT
;
701 strbuf_addf(&buf
, "%s\n", oid_to_hex(oid
));
703 filename
= git_path("%s", pseudoref
);
704 fd
= hold_lock_file_for_update_timeout(&lock
, filename
, 0,
705 get_files_ref_lock_timeout_ms());
707 strbuf_addf(err
, _("could not open '%s' for writing: %s"),
708 filename
, strerror(errno
));
713 struct object_id actual_old_oid
;
715 if (read_ref(pseudoref
, &actual_old_oid
)) {
716 if (!is_null_oid(old_oid
)) {
717 strbuf_addf(err
, _("could not read ref '%s'"),
719 rollback_lock_file(&lock
);
722 } else if (is_null_oid(old_oid
)) {
723 strbuf_addf(err
, _("ref '%s' already exists"),
725 rollback_lock_file(&lock
);
727 } else if (!oideq(&actual_old_oid
, old_oid
)) {
728 strbuf_addf(err
, _("unexpected object ID when writing '%s'"),
730 rollback_lock_file(&lock
);
735 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
736 strbuf_addf(err
, _("could not write to '%s'"), filename
);
737 rollback_lock_file(&lock
);
741 commit_lock_file(&lock
);
744 strbuf_release(&buf
);
748 static int delete_pseudoref(const char *pseudoref
, const struct object_id
*old_oid
)
750 const char *filename
;
752 filename
= git_path("%s", pseudoref
);
754 if (old_oid
&& !is_null_oid(old_oid
)) {
755 struct lock_file lock
= LOCK_INIT
;
757 struct object_id actual_old_oid
;
759 fd
= hold_lock_file_for_update_timeout(
761 get_files_ref_lock_timeout_ms());
763 error_errno(_("could not open '%s' for writing"),
767 if (read_ref(pseudoref
, &actual_old_oid
))
768 die(_("could not read ref '%s'"), pseudoref
);
769 if (!oideq(&actual_old_oid
, old_oid
)) {
770 error(_("unexpected object ID when deleting '%s'"),
772 rollback_lock_file(&lock
);
777 rollback_lock_file(&lock
);
785 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
787 const struct object_id
*old_oid
,
790 struct ref_transaction
*transaction
;
791 struct strbuf err
= STRBUF_INIT
;
793 if (ref_type(refname
) == REF_TYPE_PSEUDOREF
) {
794 assert(refs
== get_main_ref_store(the_repository
));
795 return delete_pseudoref(refname
, old_oid
);
798 transaction
= ref_store_transaction_begin(refs
, &err
);
800 ref_transaction_delete(transaction
, refname
, old_oid
,
802 ref_transaction_commit(transaction
, &err
)) {
803 error("%s", err
.buf
);
804 ref_transaction_free(transaction
);
805 strbuf_release(&err
);
808 ref_transaction_free(transaction
);
809 strbuf_release(&err
);
813 int delete_ref(const char *msg
, const char *refname
,
814 const struct object_id
*old_oid
, unsigned int flags
)
816 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
820 void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
825 strbuf_addch(sb
, '\t');
826 while ((c
= *msg
++)) {
827 if (wasspace
&& isspace(c
))
829 wasspace
= isspace(c
);
837 int should_autocreate_reflog(const char *refname
)
839 switch (log_all_ref_updates
) {
840 case LOG_REFS_ALWAYS
:
842 case LOG_REFS_NORMAL
:
843 return starts_with(refname
, "refs/heads/") ||
844 starts_with(refname
, "refs/remotes/") ||
845 starts_with(refname
, "refs/notes/") ||
846 !strcmp(refname
, "HEAD");
852 int is_branch(const char *refname
)
854 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
857 struct read_ref_at_cb
{
862 struct object_id
*oid
;
865 struct object_id ooid
;
866 struct object_id noid
;
870 timestamp_t
*cutoff_time
;
875 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
876 const char *email
, timestamp_t timestamp
, int tz
,
877 const char *message
, void *cb_data
)
879 struct read_ref_at_cb
*cb
= cb_data
;
883 cb
->date
= timestamp
;
885 if (timestamp
<= cb
->at_time
|| cb
->cnt
== 0) {
887 *cb
->msg
= xstrdup(message
);
889 *cb
->cutoff_time
= timestamp
;
893 *cb
->cutoff_cnt
= cb
->reccnt
- 1;
895 * we have not yet updated cb->[n|o]oid so they still
896 * hold the values for the previous record.
898 if (!is_null_oid(&cb
->ooid
)) {
899 oidcpy(cb
->oid
, noid
);
900 if (!oideq(&cb
->ooid
, noid
))
901 warning(_("log for ref %s has gap after %s"),
902 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
904 else if (cb
->date
== cb
->at_time
)
905 oidcpy(cb
->oid
, noid
);
906 else if (!oideq(noid
, cb
->oid
))
907 warning(_("log for ref %s unexpectedly ended on %s"),
908 cb
->refname
, show_date(cb
->date
, cb
->tz
,
909 DATE_MODE(RFC2822
)));
910 oidcpy(&cb
->ooid
, ooid
);
911 oidcpy(&cb
->noid
, noid
);
915 oidcpy(&cb
->ooid
, ooid
);
916 oidcpy(&cb
->noid
, noid
);
922 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
923 const char *email
, timestamp_t timestamp
,
924 int tz
, const char *message
, void *cb_data
)
926 struct read_ref_at_cb
*cb
= cb_data
;
929 *cb
->msg
= xstrdup(message
);
931 *cb
->cutoff_time
= timestamp
;
935 *cb
->cutoff_cnt
= cb
->reccnt
;
936 oidcpy(cb
->oid
, ooid
);
937 if (is_null_oid(cb
->oid
))
938 oidcpy(cb
->oid
, noid
);
939 /* We just want the first entry */
943 int read_ref_at(const char *refname
, unsigned int flags
, timestamp_t at_time
, int cnt
,
944 struct object_id
*oid
, char **msg
,
945 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
947 struct read_ref_at_cb cb
;
949 memset(&cb
, 0, sizeof(cb
));
950 cb
.refname
= refname
;
951 cb
.at_time
= at_time
;
954 cb
.cutoff_time
= cutoff_time
;
955 cb
.cutoff_tz
= cutoff_tz
;
956 cb
.cutoff_cnt
= cutoff_cnt
;
959 for_each_reflog_ent_reverse(refname
, read_ref_at_ent
, &cb
);
962 if (flags
& GET_OID_QUIETLY
)
965 die(_("log for %s is empty"), refname
);
970 for_each_reflog_ent(refname
, read_ref_at_ent_oldest
, &cb
);
975 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
978 struct ref_transaction
*tr
;
981 tr
= xcalloc(1, sizeof(struct ref_transaction
));
982 tr
->ref_store
= refs
;
986 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
988 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
991 void ref_transaction_free(struct ref_transaction
*transaction
)
998 switch (transaction
->state
) {
999 case REF_TRANSACTION_OPEN
:
1000 case REF_TRANSACTION_CLOSED
:
1003 case REF_TRANSACTION_PREPARED
:
1004 BUG("free called on a prepared reference transaction");
1007 BUG("unexpected reference transaction state");
1011 for (i
= 0; i
< transaction
->nr
; i
++) {
1012 free(transaction
->updates
[i
]->msg
);
1013 free(transaction
->updates
[i
]);
1015 free(transaction
->updates
);
1019 struct ref_update
*ref_transaction_add_update(
1020 struct ref_transaction
*transaction
,
1021 const char *refname
, unsigned int flags
,
1022 const struct object_id
*new_oid
,
1023 const struct object_id
*old_oid
,
1026 struct ref_update
*update
;
1028 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1029 BUG("update called for transaction that is not open");
1031 FLEX_ALLOC_STR(update
, refname
, refname
);
1032 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1033 transaction
->updates
[transaction
->nr
++] = update
;
1035 update
->flags
= flags
;
1037 if (flags
& REF_HAVE_NEW
)
1038 oidcpy(&update
->new_oid
, new_oid
);
1039 if (flags
& REF_HAVE_OLD
)
1040 oidcpy(&update
->old_oid
, old_oid
);
1041 update
->msg
= xstrdup_or_null(msg
);
1045 int ref_transaction_update(struct ref_transaction
*transaction
,
1046 const char *refname
,
1047 const struct object_id
*new_oid
,
1048 const struct object_id
*old_oid
,
1049 unsigned int flags
, const char *msg
,
1054 if ((new_oid
&& !is_null_oid(new_oid
)) ?
1055 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1056 !refname_is_safe(refname
)) {
1057 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1062 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1063 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1065 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1067 ref_transaction_add_update(transaction
, refname
, flags
,
1068 new_oid
, old_oid
, msg
);
1072 int ref_transaction_create(struct ref_transaction
*transaction
,
1073 const char *refname
,
1074 const struct object_id
*new_oid
,
1075 unsigned int flags
, const char *msg
,
1078 if (!new_oid
|| is_null_oid(new_oid
))
1079 BUG("create called without valid new_oid");
1080 return ref_transaction_update(transaction
, refname
, new_oid
,
1081 &null_oid
, flags
, msg
, err
);
1084 int ref_transaction_delete(struct ref_transaction
*transaction
,
1085 const char *refname
,
1086 const struct object_id
*old_oid
,
1087 unsigned int flags
, const char *msg
,
1090 if (old_oid
&& is_null_oid(old_oid
))
1091 BUG("delete called with old_oid set to zeros");
1092 return ref_transaction_update(transaction
, refname
,
1097 int ref_transaction_verify(struct ref_transaction
*transaction
,
1098 const char *refname
,
1099 const struct object_id
*old_oid
,
1104 BUG("verify called with old_oid set to NULL");
1105 return ref_transaction_update(transaction
, refname
,
1110 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1111 const char *refname
, const struct object_id
*new_oid
,
1112 const struct object_id
*old_oid
, unsigned int flags
,
1113 enum action_on_err onerr
)
1115 struct ref_transaction
*t
= NULL
;
1116 struct strbuf err
= STRBUF_INIT
;
1119 if (ref_type(refname
) == REF_TYPE_PSEUDOREF
) {
1120 assert(refs
== get_main_ref_store(the_repository
));
1121 ret
= write_pseudoref(refname
, new_oid
, old_oid
, &err
);
1123 t
= ref_store_transaction_begin(refs
, &err
);
1125 ref_transaction_update(t
, refname
, new_oid
, old_oid
,
1126 flags
, msg
, &err
) ||
1127 ref_transaction_commit(t
, &err
)) {
1129 ref_transaction_free(t
);
1133 const char *str
= _("update_ref failed for ref '%s': %s");
1136 case UPDATE_REFS_MSG_ON_ERR
:
1137 error(str
, refname
, err
.buf
);
1139 case UPDATE_REFS_DIE_ON_ERR
:
1140 die(str
, refname
, err
.buf
);
1142 case UPDATE_REFS_QUIET_ON_ERR
:
1145 strbuf_release(&err
);
1148 strbuf_release(&err
);
1150 ref_transaction_free(t
);
1154 int update_ref(const char *msg
, const char *refname
,
1155 const struct object_id
*new_oid
,
1156 const struct object_id
*old_oid
,
1157 unsigned int flags
, enum action_on_err onerr
)
1159 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1160 old_oid
, flags
, onerr
);
1163 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1166 static char **scanf_fmts
;
1167 static int nr_rules
;
1169 struct strbuf resolved_buf
= STRBUF_INIT
;
1173 * Pre-generate scanf formats from ref_rev_parse_rules[].
1174 * Generate a format suitable for scanf from a
1175 * ref_rev_parse_rules rule by interpolating "%s" at the
1176 * location of the "%.*s".
1178 size_t total_len
= 0;
1181 /* the rule list is NULL terminated, count them first */
1182 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1183 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1184 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1186 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1189 for (i
= 0; i
< nr_rules
; i
++) {
1190 assert(offset
< total_len
);
1191 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1192 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1193 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1197 /* bail out if there are no rules */
1199 return xstrdup(refname
);
1201 /* buffer for scanf result, at most refname must fit */
1202 short_name
= xstrdup(refname
);
1204 /* skip first rule, it will always match */
1205 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1207 int rules_to_fail
= i
;
1210 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1213 short_name_len
= strlen(short_name
);
1216 * in strict mode, all (except the matched one) rules
1217 * must fail to resolve to a valid non-ambiguous ref
1220 rules_to_fail
= nr_rules
;
1223 * check if the short name resolves to a valid ref,
1224 * but use only rules prior to the matched one
1226 for (j
= 0; j
< rules_to_fail
; j
++) {
1227 const char *rule
= ref_rev_parse_rules
[j
];
1229 /* skip matched rule */
1234 * the short name is ambiguous, if it resolves
1235 * (with this previous rule) to a valid ref
1236 * read_ref() returns 0 on success
1238 strbuf_reset(&resolved_buf
);
1239 strbuf_addf(&resolved_buf
, rule
,
1240 short_name_len
, short_name
);
1241 if (ref_exists(resolved_buf
.buf
))
1246 * short name is non-ambiguous if all previous rules
1247 * haven't resolved to a valid ref
1249 if (j
== rules_to_fail
) {
1250 strbuf_release(&resolved_buf
);
1255 strbuf_release(&resolved_buf
);
1257 return xstrdup(refname
);
1260 static struct string_list
*hide_refs
;
1262 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1265 if (!strcmp("transfer.hiderefs", var
) ||
1266 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1267 !strcmp(key
, "hiderefs"))) {
1272 return config_error_nonbool(var
);
1273 ref
= xstrdup(value
);
1275 while (len
&& ref
[len
- 1] == '/')
1278 hide_refs
= xcalloc(1, sizeof(*hide_refs
));
1279 hide_refs
->strdup_strings
= 1;
1281 string_list_append(hide_refs
, ref
);
1286 int ref_is_hidden(const char *refname
, const char *refname_full
)
1292 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1293 const char *match
= hide_refs
->items
[i
].string
;
1294 const char *subject
;
1298 if (*match
== '!') {
1303 if (*match
== '^') {
1304 subject
= refname_full
;
1310 /* refname can be NULL when namespaces are used. */
1312 skip_prefix(subject
, match
, &p
) &&
1319 const char *find_descendant_ref(const char *dirname
,
1320 const struct string_list
*extras
,
1321 const struct string_list
*skip
)
1329 * Look at the place where dirname would be inserted into
1330 * extras. If there is an entry at that position that starts
1331 * with dirname (remember, dirname includes the trailing
1332 * slash) and is not in skip, then we have a conflict.
1334 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1335 pos
< extras
->nr
; pos
++) {
1336 const char *extra_refname
= extras
->items
[pos
].string
;
1338 if (!starts_with(extra_refname
, dirname
))
1341 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1342 return extra_refname
;
1347 int refs_rename_ref_available(struct ref_store
*refs
,
1348 const char *old_refname
,
1349 const char *new_refname
)
1351 struct string_list skip
= STRING_LIST_INIT_NODUP
;
1352 struct strbuf err
= STRBUF_INIT
;
1355 string_list_insert(&skip
, old_refname
);
1356 ok
= !refs_verify_refname_available(refs
, new_refname
,
1359 error("%s", err
.buf
);
1361 string_list_clear(&skip
, 0);
1362 strbuf_release(&err
);
1366 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1368 struct object_id oid
;
1371 if (!refs_read_ref_full(refs
, "HEAD", RESOLVE_REF_READING
,
1373 return fn("HEAD", &oid
, flag
, cb_data
);
1378 int head_ref(each_ref_fn fn
, void *cb_data
)
1380 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1383 struct ref_iterator
*refs_ref_iterator_begin(
1384 struct ref_store
*refs
,
1385 const char *prefix
, int trim
, int flags
)
1387 struct ref_iterator
*iter
;
1389 if (ref_paranoia
< 0)
1390 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 0);
1392 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1394 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1397 * `iterator_begin()` already takes care of prefix, but we
1398 * might need to do some trimming:
1401 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1403 /* Sanity check for subclasses: */
1405 BUG("reference iterator is not ordered");
1411 * Call fn for each reference in the specified submodule for which the
1412 * refname begins with prefix. If trim is non-zero, then trim that
1413 * many characters off the beginning of each refname before passing
1414 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1415 * include broken references in the iteration. If fn ever returns a
1416 * non-zero value, stop the iteration and return that value;
1417 * otherwise, return 0.
1419 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1420 each_repo_ref_fn fn
, int trim
, int flags
,
1423 struct ref_iterator
*iter
;
1424 struct ref_store
*refs
= get_main_ref_store(r
);
1429 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1431 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1434 struct do_for_each_ref_help
{
1439 static int do_for_each_ref_helper(struct repository
*r
,
1440 const char *refname
,
1441 const struct object_id
*oid
,
1445 struct do_for_each_ref_help
*hp
= cb_data
;
1447 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1450 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1451 each_ref_fn fn
, int trim
, int flags
, void *cb_data
)
1453 struct ref_iterator
*iter
;
1454 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1459 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1461 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1462 do_for_each_ref_helper
, &hp
);
1465 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1467 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1470 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1472 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1475 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1476 each_ref_fn fn
, void *cb_data
)
1478 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1481 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1483 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1486 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
, unsigned int broken
)
1488 unsigned int flag
= 0;
1491 flag
= DO_FOR_EACH_INCLUDE_BROKEN
;
1492 return do_for_each_ref(get_main_ref_store(the_repository
),
1493 prefix
, fn
, 0, flag
, cb_data
);
1496 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1497 each_ref_fn fn
, void *cb_data
,
1498 unsigned int broken
)
1500 unsigned int flag
= 0;
1503 flag
= DO_FOR_EACH_INCLUDE_BROKEN
;
1504 return do_for_each_ref(refs
, prefix
, fn
, 0, flag
, cb_data
);
1507 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1509 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1510 strlen(git_replace_ref_base
),
1511 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1514 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1516 struct strbuf buf
= STRBUF_INIT
;
1518 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1519 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1520 buf
.buf
, fn
, 0, 0, cb_data
);
1521 strbuf_release(&buf
);
1525 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1527 return do_for_each_ref(refs
, "", fn
, 0,
1528 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1531 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1533 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1536 int refs_read_raw_ref(struct ref_store
*ref_store
,
1537 const char *refname
, struct object_id
*oid
,
1538 struct strbuf
*referent
, unsigned int *type
)
1540 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
, type
);
1543 /* This function needs to return a meaningful errno on failure */
1544 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1545 const char *refname
,
1547 struct object_id
*oid
, int *flags
)
1549 static struct strbuf sb_refname
= STRBUF_INIT
;
1550 struct object_id unused_oid
;
1557 flags
= &unused_flags
;
1561 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1562 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1563 !refname_is_safe(refname
)) {
1569 * dwim_ref() uses REF_ISBROKEN to distinguish between
1570 * missing refs and refs that were present but invalid,
1571 * to complain about the latter to stderr.
1573 * We don't know whether the ref exists, so don't set
1576 *flags
|= REF_BAD_NAME
;
1579 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1580 unsigned int read_flags
= 0;
1582 if (refs_read_raw_ref(refs
, refname
,
1583 oid
, &sb_refname
, &read_flags
)) {
1584 *flags
|= read_flags
;
1586 /* In reading mode, refs must eventually resolve */
1587 if (resolve_flags
& RESOLVE_REF_READING
)
1591 * Otherwise a missing ref is OK. But the files backend
1592 * may show errors besides ENOENT if there are
1593 * similarly-named refs.
1595 if (errno
!= ENOENT
&&
1601 if (*flags
& REF_BAD_NAME
)
1602 *flags
|= REF_ISBROKEN
;
1606 *flags
|= read_flags
;
1608 if (!(read_flags
& REF_ISSYMREF
)) {
1609 if (*flags
& REF_BAD_NAME
) {
1611 *flags
|= REF_ISBROKEN
;
1616 refname
= sb_refname
.buf
;
1617 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1621 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1622 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1623 !refname_is_safe(refname
)) {
1628 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1636 /* backend functions */
1637 int refs_init_db(struct strbuf
*err
)
1639 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1641 return refs
->be
->init_db(refs
, err
);
1644 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1645 struct object_id
*oid
, int *flags
)
1647 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1648 resolve_flags
, oid
, flags
);
1651 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1652 struct object_id
*oid
)
1654 struct ref_store
*refs
;
1657 refs
= get_submodule_ref_store(submodule
);
1662 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1668 struct ref_store_hash_entry
1670 struct hashmap_entry ent
; /* must be the first member! */
1672 struct ref_store
*refs
;
1674 /* NUL-terminated identifier of the ref store: */
1675 char name
[FLEX_ARRAY
];
1678 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1679 const void *entry
, const void *entry_or_key
,
1680 const void *keydata
)
1682 const struct ref_store_hash_entry
*e1
= entry
, *e2
= entry_or_key
;
1683 const char *name
= keydata
? keydata
: e2
->name
;
1685 return strcmp(e1
->name
, name
);
1688 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1689 const char *name
, struct ref_store
*refs
)
1691 struct ref_store_hash_entry
*entry
;
1693 FLEX_ALLOC_STR(entry
, name
, name
);
1694 hashmap_entry_init(entry
, strhash(name
));
1699 /* A hashmap of ref_stores, stored by submodule name: */
1700 static struct hashmap submodule_ref_stores
;
1702 /* A hashmap of ref_stores, stored by worktree id: */
1703 static struct hashmap worktree_ref_stores
;
1706 * Look up a ref store by name. If that ref_store hasn't been
1707 * registered yet, return NULL.
1709 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1712 struct ref_store_hash_entry
*entry
;
1714 if (!map
->tablesize
)
1715 /* It's initialized on demand in register_ref_store(). */
1718 entry
= hashmap_get_from_hash(map
, strhash(name
), name
);
1719 return entry
? entry
->refs
: NULL
;
1723 * Create, record, and return a ref_store instance for the specified
1726 static struct ref_store
*ref_store_init(const char *gitdir
,
1729 const char *be_name
= "files";
1730 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1731 struct ref_store
*refs
;
1734 BUG("reference backend %s is unknown", be_name
);
1736 refs
= be
->init(gitdir
, flags
);
1740 struct ref_store
*get_main_ref_store(struct repository
*r
)
1746 BUG("attempting to get main_ref_store outside of repository");
1748 r
->refs
= ref_store_init(r
->gitdir
, REF_STORE_ALL_CAPS
);
1753 * Associate a ref store with a name. It is a fatal error to call this
1754 * function twice for the same name.
1756 static void register_ref_store_map(struct hashmap
*map
,
1758 struct ref_store
*refs
,
1761 if (!map
->tablesize
)
1762 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1764 if (hashmap_put(map
, alloc_ref_store_hash_entry(name
, refs
)))
1765 BUG("%s ref_store '%s' initialized twice", type
, name
);
1768 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1770 struct strbuf submodule_sb
= STRBUF_INIT
;
1771 struct ref_store
*refs
;
1772 char *to_free
= NULL
;
1778 len
= strlen(submodule
);
1779 while (len
&& is_dir_sep(submodule
[len
- 1]))
1785 /* We need to strip off one or more trailing slashes */
1786 submodule
= to_free
= xmemdupz(submodule
, len
);
1788 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1792 strbuf_addstr(&submodule_sb
, submodule
);
1793 if (!is_nonbare_repository_dir(&submodule_sb
))
1796 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1799 /* assume that add_submodule_odb() has been called */
1800 refs
= ref_store_init(submodule_sb
.buf
,
1801 REF_STORE_READ
| REF_STORE_ODB
);
1802 register_ref_store_map(&submodule_ref_stores
, "submodule",
1806 strbuf_release(&submodule_sb
);
1812 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1814 struct ref_store
*refs
;
1818 return get_main_ref_store(the_repository
);
1820 id
= wt
->id
? wt
->id
: "/";
1821 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1826 refs
= ref_store_init(git_common_path("worktrees/%s", wt
->id
),
1827 REF_STORE_ALL_CAPS
);
1829 refs
= ref_store_init(get_git_common_dir(),
1830 REF_STORE_ALL_CAPS
);
1833 register_ref_store_map(&worktree_ref_stores
, "worktree",
1838 void base_ref_store_init(struct ref_store
*refs
,
1839 const struct ref_storage_be
*be
)
1844 /* backend functions */
1845 int refs_pack_refs(struct ref_store
*refs
, unsigned int flags
)
1847 return refs
->be
->pack_refs(refs
, flags
);
1850 int refs_peel_ref(struct ref_store
*refs
, const char *refname
,
1851 struct object_id
*oid
)
1854 struct object_id base
;
1856 if (current_ref_iter
&& current_ref_iter
->refname
== refname
) {
1857 struct object_id peeled
;
1859 if (ref_iterator_peel(current_ref_iter
, &peeled
))
1861 oidcpy(oid
, &peeled
);
1865 if (refs_read_ref_full(refs
, refname
,
1866 RESOLVE_REF_READING
, &base
, &flag
))
1869 return peel_object(&base
, oid
);
1872 int peel_ref(const char *refname
, struct object_id
*oid
)
1874 return refs_peel_ref(get_main_ref_store(the_repository
), refname
, oid
);
1877 int refs_create_symref(struct ref_store
*refs
,
1878 const char *ref_target
,
1879 const char *refs_heads_master
,
1882 return refs
->be
->create_symref(refs
, ref_target
,
1887 int create_symref(const char *ref_target
, const char *refs_heads_master
,
1890 return refs_create_symref(get_main_ref_store(the_repository
), ref_target
,
1891 refs_heads_master
, logmsg
);
1894 int ref_update_reject_duplicates(struct string_list
*refnames
,
1897 size_t i
, n
= refnames
->nr
;
1901 for (i
= 1; i
< n
; i
++) {
1902 int cmp
= strcmp(refnames
->items
[i
- 1].string
,
1903 refnames
->items
[i
].string
);
1907 _("multiple updates for ref '%s' not allowed"),
1908 refnames
->items
[i
].string
);
1910 } else if (cmp
> 0) {
1911 BUG("ref_update_reject_duplicates() received unsorted list");
1917 int ref_transaction_prepare(struct ref_transaction
*transaction
,
1920 struct ref_store
*refs
= transaction
->ref_store
;
1922 switch (transaction
->state
) {
1923 case REF_TRANSACTION_OPEN
:
1926 case REF_TRANSACTION_PREPARED
:
1927 BUG("prepare called twice on reference transaction");
1929 case REF_TRANSACTION_CLOSED
:
1930 BUG("prepare called on a closed reference transaction");
1933 BUG("unexpected reference transaction state");
1937 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
1939 _("ref updates forbidden inside quarantine environment"));
1943 return refs
->be
->transaction_prepare(refs
, transaction
, err
);
1946 int ref_transaction_abort(struct ref_transaction
*transaction
,
1949 struct ref_store
*refs
= transaction
->ref_store
;
1952 switch (transaction
->state
) {
1953 case REF_TRANSACTION_OPEN
:
1954 /* No need to abort explicitly. */
1956 case REF_TRANSACTION_PREPARED
:
1957 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
1959 case REF_TRANSACTION_CLOSED
:
1960 BUG("abort called on a closed reference transaction");
1963 BUG("unexpected reference transaction state");
1967 ref_transaction_free(transaction
);
1971 int ref_transaction_commit(struct ref_transaction
*transaction
,
1974 struct ref_store
*refs
= transaction
->ref_store
;
1977 switch (transaction
->state
) {
1978 case REF_TRANSACTION_OPEN
:
1979 /* Need to prepare first. */
1980 ret
= ref_transaction_prepare(transaction
, err
);
1984 case REF_TRANSACTION_PREPARED
:
1985 /* Fall through to finish. */
1987 case REF_TRANSACTION_CLOSED
:
1988 BUG("commit called on a closed reference transaction");
1991 BUG("unexpected reference transaction state");
1995 return refs
->be
->transaction_finish(refs
, transaction
, err
);
1998 int refs_verify_refname_available(struct ref_store
*refs
,
1999 const char *refname
,
2000 const struct string_list
*extras
,
2001 const struct string_list
*skip
,
2005 const char *extra_refname
;
2006 struct strbuf dirname
= STRBUF_INIT
;
2007 struct strbuf referent
= STRBUF_INIT
;
2008 struct object_id oid
;
2010 struct ref_iterator
*iter
;
2015 * For the sake of comments in this function, suppose that
2016 * refname is "refs/foo/bar".
2021 strbuf_grow(&dirname
, strlen(refname
) + 1);
2022 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2023 /* Expand dirname to the new prefix, not including the trailing slash: */
2024 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2027 * We are still at a leading dir of the refname (e.g.,
2028 * "refs/foo"; if there is a reference with that name,
2029 * it is a conflict, *unless* it is in skip.
2031 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2034 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
, &type
)) {
2035 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2036 dirname
.buf
, refname
);
2040 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2041 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2042 refname
, dirname
.buf
);
2048 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2049 * There is no point in searching for a reference with that
2050 * name, because a refname isn't considered to conflict with
2051 * itself. But we still need to check for references whose
2052 * names are in the "refs/foo/bar/" namespace, because they
2055 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2056 strbuf_addch(&dirname
, '/');
2058 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2059 DO_FOR_EACH_INCLUDE_BROKEN
);
2060 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2062 string_list_has_string(skip
, iter
->refname
))
2065 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2066 iter
->refname
, refname
);
2067 ref_iterator_abort(iter
);
2071 if (ok
!= ITER_DONE
)
2072 BUG("error while iterating over references");
2074 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2076 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2077 refname
, extra_refname
);
2082 strbuf_release(&referent
);
2083 strbuf_release(&dirname
);
2087 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2089 struct ref_iterator
*iter
;
2090 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2092 iter
= refs
->be
->reflog_iterator_begin(refs
);
2094 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2095 do_for_each_ref_helper
, &hp
);
2098 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2100 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2103 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2104 const char *refname
,
2105 each_reflog_ent_fn fn
,
2108 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2112 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2115 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2116 refname
, fn
, cb_data
);
2119 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2120 each_reflog_ent_fn fn
, void *cb_data
)
2122 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2125 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2128 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2132 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2134 return refs
->be
->reflog_exists(refs
, refname
);
2137 int reflog_exists(const char *refname
)
2139 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2142 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2143 int force_create
, struct strbuf
*err
)
2145 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2148 int safe_create_reflog(const char *refname
, int force_create
,
2151 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2155 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2157 return refs
->be
->delete_reflog(refs
, refname
);
2160 int delete_reflog(const char *refname
)
2162 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2165 int refs_reflog_expire(struct ref_store
*refs
,
2166 const char *refname
, const struct object_id
*oid
,
2168 reflog_expiry_prepare_fn prepare_fn
,
2169 reflog_expiry_should_prune_fn should_prune_fn
,
2170 reflog_expiry_cleanup_fn cleanup_fn
,
2171 void *policy_cb_data
)
2173 return refs
->be
->reflog_expire(refs
, refname
, oid
, flags
,
2174 prepare_fn
, should_prune_fn
,
2175 cleanup_fn
, policy_cb_data
);
2178 int reflog_expire(const char *refname
, const struct object_id
*oid
,
2180 reflog_expiry_prepare_fn prepare_fn
,
2181 reflog_expiry_should_prune_fn should_prune_fn
,
2182 reflog_expiry_cleanup_fn cleanup_fn
,
2183 void *policy_cb_data
)
2185 return refs_reflog_expire(get_main_ref_store(the_repository
),
2186 refname
, oid
, flags
,
2187 prepare_fn
, should_prune_fn
,
2188 cleanup_fn
, policy_cb_data
);
2191 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2194 struct ref_store
*refs
= transaction
->ref_store
;
2196 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2199 int refs_delete_refs(struct ref_store
*refs
, const char *msg
,
2200 struct string_list
*refnames
, unsigned int flags
)
2202 return refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2205 int delete_refs(const char *msg
, struct string_list
*refnames
,
2208 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2211 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2212 const char *newref
, const char *logmsg
)
2214 return refs
->be
->rename_ref(refs
, oldref
, newref
, logmsg
);
2217 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2219 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2222 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2223 const char *newref
, const char *logmsg
)
2225 return refs
->be
->copy_ref(refs
, oldref
, newref
, logmsg
);
2228 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2230 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);