2 * The backend-independent part of the reference module.
11 #include "refs/refs-internal.h"
12 #include "run-command.h"
13 #include "object-store.h"
16 #include "submodule.h"
19 #include "repository.h"
23 * List of all available backends
25 static struct ref_storage_be
*refs_backends
= &refs_be_files
;
27 static struct ref_storage_be
*find_ref_storage_backend(const char *name
)
29 struct ref_storage_be
*be
;
30 for (be
= refs_backends
; be
; be
= be
->next
)
31 if (!strcmp(be
->name
, name
))
36 int ref_storage_backend_exists(const char *name
)
38 return find_ref_storage_backend(name
) != NULL
;
42 * How to handle various characters in refnames:
43 * 0: An acceptable character for refs
45 * 2: ., look for a preceding . to reject .. in refs
46 * 3: {, look for a preceding @ to reject @{ in refs
47 * 4: A bad character: ASCII control characters, and
48 * ":", "?", "[", "\", "^", "~", SP, or TAB
49 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
51 static unsigned char refname_disposition
[256] = {
52 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
53 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
54 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
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, 4, 4, 0, 4, 0,
58 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
59 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
63 * Try to read one refname component from the front of refname.
64 * Return the length of the component found, or -1 if the component is
65 * not legal. It is legal if it is something reasonable to have under
66 * ".git/refs/"; We do not like it if:
68 * - it begins with ".", or
69 * - it has double dots "..", or
70 * - it has ASCII control characters, or
71 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
72 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
73 * - it ends with a "/", or
74 * - it ends with ".lock", or
75 * - it contains a "@{" portion
77 * When sanitized is not NULL, instead of rejecting the input refname
78 * as an error, try to come up with a usable replacement for the input
81 static int check_refname_component(const char *refname
, int *flags
,
82 struct strbuf
*sanitized
)
86 size_t component_start
= 0; /* garbage - not a reasonable initial value */
89 component_start
= sanitized
->len
;
91 for (cp
= refname
; ; cp
++) {
93 unsigned char disp
= refname_disposition
[ch
];
95 if (sanitized
&& disp
!= 1)
96 strbuf_addch(sanitized
, ch
);
102 if (last
== '.') { /* Refname contains "..". */
104 /* collapse ".." to single "." */
105 strbuf_setlen(sanitized
, sanitized
->len
- 1);
111 if (last
== '@') { /* Refname contains "@{". */
113 sanitized
->buf
[sanitized
->len
-1] = '-';
121 sanitized
->buf
[sanitized
->len
-1] = '-';
126 if (!(*flags
& REFNAME_REFSPEC_PATTERN
)) {
127 /* refspec can't be a pattern */
129 sanitized
->buf
[sanitized
->len
-1] = '-';
135 * Unset the pattern flag so that we only accept
136 * a single asterisk for one side of refspec.
138 *flags
&= ~ REFNAME_REFSPEC_PATTERN
;
145 return 0; /* Component has zero length. */
147 if (refname
[0] == '.') { /* Component starts with '.'. */
149 sanitized
->buf
[component_start
] = '-';
153 if (cp
- refname
>= LOCK_SUFFIX_LEN
&&
154 !memcmp(cp
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
, LOCK_SUFFIX_LEN
)) {
157 /* Refname ends with ".lock". */
158 while (strbuf_strip_suffix(sanitized
, LOCK_SUFFIX
)) {
159 /* try again in case we have .lock.lock */
165 static int check_or_sanitize_refname(const char *refname
, int flags
,
166 struct strbuf
*sanitized
)
168 int component_len
, component_count
= 0;
170 if (!strcmp(refname
, "@")) {
171 /* Refname is a single character '@'. */
173 strbuf_addch(sanitized
, '-');
179 if (sanitized
&& sanitized
->len
)
180 strbuf_complete(sanitized
, '/');
182 /* We are at the start of a path component. */
183 component_len
= check_refname_component(refname
, &flags
,
185 if (sanitized
&& component_len
== 0)
186 ; /* OK, omit empty component */
187 else if (component_len
<= 0)
191 if (refname
[component_len
] == '\0')
193 /* Skip to next component. */
194 refname
+= component_len
+ 1;
197 if (refname
[component_len
- 1] == '.') {
198 /* Refname ends with '.'. */
200 ; /* omit ending dot */
204 if (!(flags
& REFNAME_ALLOW_ONELEVEL
) && component_count
< 2)
205 return -1; /* Refname has only one component. */
209 int check_refname_format(const char *refname
, int flags
)
211 return check_or_sanitize_refname(refname
, flags
, NULL
);
214 void sanitize_refname_component(const char *refname
, struct strbuf
*out
)
216 if (check_or_sanitize_refname(refname
, REFNAME_ALLOW_ONELEVEL
, out
))
217 BUG("sanitizing refname '%s' check returned error", refname
);
220 int refname_is_safe(const char *refname
)
224 if (skip_prefix(refname
, "refs/", &rest
)) {
227 size_t restlen
= strlen(rest
);
229 /* rest must not be empty, or start or end with "/" */
230 if (!restlen
|| *rest
== '/' || rest
[restlen
- 1] == '/')
234 * Does the refname try to escape refs/?
235 * For example: refs/foo/../bar is safe but refs/foo/../../bar
238 buf
= xmallocz(restlen
);
239 result
= !normalize_path_copy(buf
, rest
) && !strcmp(buf
, rest
);
245 if (!isupper(*refname
) && *refname
!= '_')
253 * Return true if refname, which has the specified oid and flags, can
254 * be resolved to an object in the database. If the referred-to object
255 * does not exist, emit a warning and return false.
257 int ref_resolves_to_object(const char *refname
,
258 const struct object_id
*oid
,
261 if (flags
& REF_ISBROKEN
)
263 if (!has_object_file(oid
)) {
264 error(_("%s does not point to a valid object!"), refname
);
270 char *refs_resolve_refdup(struct ref_store
*refs
,
271 const char *refname
, int resolve_flags
,
272 struct object_id
*oid
, int *flags
)
276 result
= refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
,
278 return xstrdup_or_null(result
);
281 char *resolve_refdup(const char *refname
, int resolve_flags
,
282 struct object_id
*oid
, int *flags
)
284 return refs_resolve_refdup(get_main_ref_store(the_repository
),
285 refname
, resolve_flags
,
289 /* The argument to filter_refs */
297 int refs_read_ref_full(struct ref_store
*refs
, const char *refname
,
298 int resolve_flags
, struct object_id
*oid
, int *flags
)
300 if (refs_resolve_ref_unsafe(refs
, refname
, resolve_flags
, oid
, flags
))
305 int read_ref_full(const char *refname
, int resolve_flags
, struct object_id
*oid
, int *flags
)
307 return refs_read_ref_full(get_main_ref_store(the_repository
), refname
,
308 resolve_flags
, oid
, flags
);
311 int read_ref(const char *refname
, struct object_id
*oid
)
313 return read_ref_full(refname
, RESOLVE_REF_READING
, oid
, NULL
);
316 int refs_ref_exists(struct ref_store
*refs
, const char *refname
)
318 return !!refs_resolve_ref_unsafe(refs
, refname
, RESOLVE_REF_READING
, NULL
, NULL
);
321 int ref_exists(const char *refname
)
323 return refs_ref_exists(get_main_ref_store(the_repository
), refname
);
326 static int filter_refs(const char *refname
, const struct object_id
*oid
,
327 int flags
, void *data
)
329 struct ref_filter
*filter
= (struct ref_filter
*)data
;
331 if (wildmatch(filter
->pattern
, refname
, 0))
334 skip_prefix(refname
, filter
->prefix
, &refname
);
335 return filter
->fn(refname
, oid
, flags
, filter
->cb_data
);
338 enum peel_status
peel_object(const struct object_id
*name
, struct object_id
*oid
)
340 struct object
*o
= lookup_unknown_object(the_repository
, name
);
342 if (o
->type
== OBJ_NONE
) {
343 int type
= oid_object_info(the_repository
, name
, NULL
);
344 if (type
< 0 || !object_as_type(o
, type
, 0))
348 if (o
->type
!= OBJ_TAG
)
351 o
= deref_tag_noverify(o
);
355 oidcpy(oid
, &o
->oid
);
359 struct warn_if_dangling_data
{
362 const struct string_list
*refnames
;
366 static int warn_if_dangling_symref(const char *refname
, const struct object_id
*oid
,
367 int flags
, void *cb_data
)
369 struct warn_if_dangling_data
*d
= cb_data
;
370 const char *resolves_to
;
372 if (!(flags
& REF_ISSYMREF
))
375 resolves_to
= resolve_ref_unsafe(refname
, 0, NULL
, NULL
);
378 ? strcmp(resolves_to
, d
->refname
)
379 : !string_list_has_string(d
->refnames
, resolves_to
))) {
383 fprintf(d
->fp
, d
->msg_fmt
, refname
);
388 void warn_dangling_symref(FILE *fp
, const char *msg_fmt
, const char *refname
)
390 struct warn_if_dangling_data data
;
393 data
.refname
= refname
;
394 data
.refnames
= NULL
;
395 data
.msg_fmt
= msg_fmt
;
396 for_each_rawref(warn_if_dangling_symref
, &data
);
399 void warn_dangling_symrefs(FILE *fp
, const char *msg_fmt
, const struct string_list
*refnames
)
401 struct warn_if_dangling_data data
;
405 data
.refnames
= refnames
;
406 data
.msg_fmt
= msg_fmt
;
407 for_each_rawref(warn_if_dangling_symref
, &data
);
410 int refs_for_each_tag_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
412 return refs_for_each_ref_in(refs
, "refs/tags/", fn
, cb_data
);
415 int for_each_tag_ref(each_ref_fn fn
, void *cb_data
)
417 return refs_for_each_tag_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
420 int refs_for_each_branch_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
422 return refs_for_each_ref_in(refs
, "refs/heads/", fn
, cb_data
);
425 int for_each_branch_ref(each_ref_fn fn
, void *cb_data
)
427 return refs_for_each_branch_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
430 int refs_for_each_remote_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
432 return refs_for_each_ref_in(refs
, "refs/remotes/", fn
, cb_data
);
435 int for_each_remote_ref(each_ref_fn fn
, void *cb_data
)
437 return refs_for_each_remote_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
440 int head_ref_namespaced(each_ref_fn fn
, void *cb_data
)
442 struct strbuf buf
= STRBUF_INIT
;
444 struct object_id oid
;
447 strbuf_addf(&buf
, "%sHEAD", get_git_namespace());
448 if (!read_ref_full(buf
.buf
, RESOLVE_REF_READING
, &oid
, &flag
))
449 ret
= fn(buf
.buf
, &oid
, flag
, cb_data
);
450 strbuf_release(&buf
);
455 void normalize_glob_ref(struct string_list_item
*item
, const char *prefix
,
458 struct strbuf normalized_pattern
= STRBUF_INIT
;
461 BUG("pattern must not start with '/'");
464 strbuf_addstr(&normalized_pattern
, prefix
);
466 else if (!starts_with(pattern
, "refs/"))
467 strbuf_addstr(&normalized_pattern
, "refs/");
468 strbuf_addstr(&normalized_pattern
, pattern
);
469 strbuf_strip_suffix(&normalized_pattern
, "/");
471 item
->string
= strbuf_detach(&normalized_pattern
, NULL
);
472 item
->util
= has_glob_specials(pattern
) ? NULL
: item
->string
;
473 strbuf_release(&normalized_pattern
);
476 int for_each_glob_ref_in(each_ref_fn fn
, const char *pattern
,
477 const char *prefix
, void *cb_data
)
479 struct strbuf real_pattern
= STRBUF_INIT
;
480 struct ref_filter filter
;
483 if (!prefix
&& !starts_with(pattern
, "refs/"))
484 strbuf_addstr(&real_pattern
, "refs/");
486 strbuf_addstr(&real_pattern
, prefix
);
487 strbuf_addstr(&real_pattern
, pattern
);
489 if (!has_glob_specials(pattern
)) {
490 /* Append implied '/' '*' if not present. */
491 strbuf_complete(&real_pattern
, '/');
492 /* No need to check for '*', there is none. */
493 strbuf_addch(&real_pattern
, '*');
496 filter
.pattern
= real_pattern
.buf
;
497 filter
.prefix
= prefix
;
499 filter
.cb_data
= cb_data
;
500 ret
= for_each_ref(filter_refs
, &filter
);
502 strbuf_release(&real_pattern
);
506 int for_each_glob_ref(each_ref_fn fn
, const char *pattern
, void *cb_data
)
508 return for_each_glob_ref_in(fn
, pattern
, NULL
, cb_data
);
511 const char *prettify_refname(const char *name
)
513 if (skip_prefix(name
, "refs/heads/", &name
) ||
514 skip_prefix(name
, "refs/tags/", &name
) ||
515 skip_prefix(name
, "refs/remotes/", &name
))
520 static const char *ref_rev_parse_rules
[] = {
526 "refs/remotes/%.*s/HEAD",
530 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
533 * Is it possible that the caller meant full_name with abbrev_name?
534 * If so return a non-zero value to signal "yes"; the magnitude of
535 * the returned value gives the precedence used for disambiguation.
537 * If abbrev_name cannot mean full_name, return 0.
539 int refname_match(const char *abbrev_name
, const char *full_name
)
542 const int abbrev_name_len
= strlen(abbrev_name
);
543 const int num_rules
= NUM_REV_PARSE_RULES
;
545 for (p
= ref_rev_parse_rules
; *p
; p
++)
546 if (!strcmp(full_name
, mkpath(*p
, abbrev_name_len
, abbrev_name
)))
547 return &ref_rev_parse_rules
[num_rules
] - p
;
553 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
554 * the results to 'prefixes'
556 void expand_ref_prefix(struct strvec
*prefixes
, const char *prefix
)
559 int len
= strlen(prefix
);
561 for (p
= ref_rev_parse_rules
; *p
; p
++)
562 strvec_pushf(prefixes
, *p
, len
, prefix
);
565 static const char default_branch_name_advice
[] = N_(
566 "Using '%s' as the name for the initial branch. This default branch name\n"
567 "is subject to change. To configure the initial branch name to use in all\n"
568 "of your new repositories, which will suppress this warning, call:\n"
570 "\tgit config --global init.defaultBranch <name>\n"
572 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
573 "'development'. The just-created branch can be renamed via this command:\n"
575 "\tgit branch -m <name>\n"
578 char *repo_default_branch_name(struct repository
*r
, int quiet
)
580 const char *config_key
= "init.defaultbranch";
581 const char *config_display_key
= "init.defaultBranch";
582 char *ret
= NULL
, *full_ref
;
583 const char *env
= getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
587 else if (repo_config_get_string(r
, config_key
, &ret
) < 0)
588 die(_("could not retrieve `%s`"), config_display_key
);
591 ret
= xstrdup("master");
593 advise(_(default_branch_name_advice
), ret
);
596 full_ref
= xstrfmt("refs/heads/%s", ret
);
597 if (check_refname_format(full_ref
, 0))
598 die(_("invalid branch name: %s = %s"), config_display_key
, ret
);
604 const char *git_default_branch_name(int quiet
)
609 ret
= repo_default_branch_name(the_repository
, quiet
);
615 * *string and *len will only be substituted, and *string returned (for
616 * later free()ing) if the string passed in is a magic short-hand form
619 static char *substitute_branch_name(struct repository
*r
,
620 const char **string
, int *len
,
621 int nonfatal_dangling_mark
)
623 struct strbuf buf
= STRBUF_INIT
;
624 struct interpret_branch_name_options options
= {
625 .nonfatal_dangling_mark
= nonfatal_dangling_mark
627 int ret
= repo_interpret_branch_name(r
, *string
, *len
, &buf
, &options
);
631 *string
= strbuf_detach(&buf
, &size
);
633 return (char *)*string
;
639 int repo_dwim_ref(struct repository
*r
, const char *str
, int len
,
640 struct object_id
*oid
, char **ref
, int nonfatal_dangling_mark
)
642 char *last_branch
= substitute_branch_name(r
, &str
, &len
,
643 nonfatal_dangling_mark
);
644 int refs_found
= expand_ref(r
, str
, len
, oid
, ref
);
649 int expand_ref(struct repository
*repo
, const char *str
, int len
,
650 struct object_id
*oid
, char **ref
)
654 struct strbuf fullref
= STRBUF_INIT
;
657 for (p
= ref_rev_parse_rules
; *p
; p
++) {
658 struct object_id oid_from_ref
;
659 struct object_id
*this_result
;
662 this_result
= refs_found
? &oid_from_ref
: oid
;
663 strbuf_reset(&fullref
);
664 strbuf_addf(&fullref
, *p
, len
, str
);
665 r
= refs_resolve_ref_unsafe(get_main_ref_store(repo
),
666 fullref
.buf
, RESOLVE_REF_READING
,
671 if (!warn_ambiguous_refs
)
673 } else if ((flag
& REF_ISSYMREF
) && strcmp(fullref
.buf
, "HEAD")) {
674 warning(_("ignoring dangling symref %s"), fullref
.buf
);
675 } else if ((flag
& REF_ISBROKEN
) && strchr(fullref
.buf
, '/')) {
676 warning(_("ignoring broken ref %s"), fullref
.buf
);
679 strbuf_release(&fullref
);
683 int repo_dwim_log(struct repository
*r
, const char *str
, int len
,
684 struct object_id
*oid
, char **log
)
686 struct ref_store
*refs
= get_main_ref_store(r
);
687 char *last_branch
= substitute_branch_name(r
, &str
, &len
, 0);
690 struct strbuf path
= STRBUF_INIT
;
693 for (p
= ref_rev_parse_rules
; *p
; p
++) {
694 struct object_id hash
;
695 const char *ref
, *it
;
698 strbuf_addf(&path
, *p
, len
, str
);
699 ref
= refs_resolve_ref_unsafe(refs
, path
.buf
,
701 oid
? &hash
: NULL
, NULL
);
704 if (refs_reflog_exists(refs
, path
.buf
))
706 else if (strcmp(ref
, path
.buf
) &&
707 refs_reflog_exists(refs
, ref
))
716 if (!warn_ambiguous_refs
)
719 strbuf_release(&path
);
724 int dwim_log(const char *str
, int len
, struct object_id
*oid
, char **log
)
726 return repo_dwim_log(the_repository
, str
, len
, oid
, log
);
729 static int is_per_worktree_ref(const char *refname
)
731 return starts_with(refname
, "refs/worktree/") ||
732 starts_with(refname
, "refs/bisect/") ||
733 starts_with(refname
, "refs/rewritten/");
736 static int is_pseudoref_syntax(const char *refname
)
740 for (c
= refname
; *c
; c
++) {
741 if (!isupper(*c
) && *c
!= '-' && *c
!= '_')
748 static int is_main_pseudoref_syntax(const char *refname
)
750 return skip_prefix(refname
, "main-worktree/", &refname
) &&
752 is_pseudoref_syntax(refname
);
755 static int is_other_pseudoref_syntax(const char *refname
)
757 if (!skip_prefix(refname
, "worktrees/", &refname
))
759 refname
= strchr(refname
, '/');
760 if (!refname
|| !refname
[1])
762 return is_pseudoref_syntax(refname
+ 1);
765 enum ref_type
ref_type(const char *refname
)
767 if (is_per_worktree_ref(refname
))
768 return REF_TYPE_PER_WORKTREE
;
769 if (is_pseudoref_syntax(refname
))
770 return REF_TYPE_PSEUDOREF
;
771 if (is_main_pseudoref_syntax(refname
))
772 return REF_TYPE_MAIN_PSEUDOREF
;
773 if (is_other_pseudoref_syntax(refname
))
774 return REF_TYPE_OTHER_PSEUDOREF
;
775 return REF_TYPE_NORMAL
;
778 long get_files_ref_lock_timeout_ms(void)
780 static int configured
= 0;
782 /* The default timeout is 100 ms: */
783 static int timeout_ms
= 100;
786 git_config_get_int("core.filesreflocktimeout", &timeout_ms
);
793 int refs_delete_ref(struct ref_store
*refs
, const char *msg
,
795 const struct object_id
*old_oid
,
798 struct ref_transaction
*transaction
;
799 struct strbuf err
= STRBUF_INIT
;
801 transaction
= ref_store_transaction_begin(refs
, &err
);
803 ref_transaction_delete(transaction
, refname
, old_oid
,
805 ref_transaction_commit(transaction
, &err
)) {
806 error("%s", err
.buf
);
807 ref_transaction_free(transaction
);
808 strbuf_release(&err
);
811 ref_transaction_free(transaction
);
812 strbuf_release(&err
);
816 int delete_ref(const char *msg
, const char *refname
,
817 const struct object_id
*old_oid
, unsigned int flags
)
819 return refs_delete_ref(get_main_ref_store(the_repository
), msg
, refname
,
823 static void copy_reflog_msg(struct strbuf
*sb
, const char *msg
)
828 while ((c
= *msg
++)) {
829 if (wasspace
&& isspace(c
))
831 wasspace
= isspace(c
);
839 static char *normalize_reflog_message(const char *msg
)
841 struct strbuf sb
= STRBUF_INIT
;
844 copy_reflog_msg(&sb
, msg
);
845 return strbuf_detach(&sb
, NULL
);
848 int should_autocreate_reflog(const char *refname
)
850 switch (log_all_ref_updates
) {
851 case LOG_REFS_ALWAYS
:
853 case LOG_REFS_NORMAL
:
854 return starts_with(refname
, "refs/heads/") ||
855 starts_with(refname
, "refs/remotes/") ||
856 starts_with(refname
, "refs/notes/") ||
857 !strcmp(refname
, "HEAD");
863 int is_branch(const char *refname
)
865 return !strcmp(refname
, "HEAD") || starts_with(refname
, "refs/heads/");
868 struct read_ref_at_cb
{
873 struct object_id
*oid
;
876 struct object_id ooid
;
877 struct object_id noid
;
881 timestamp_t
*cutoff_time
;
886 static void set_read_ref_cutoffs(struct read_ref_at_cb
*cb
,
887 timestamp_t timestamp
, int tz
, const char *message
)
890 *cb
->msg
= xstrdup(message
);
892 *cb
->cutoff_time
= timestamp
;
896 *cb
->cutoff_cnt
= cb
->reccnt
;
899 static int read_ref_at_ent(struct object_id
*ooid
, struct object_id
*noid
,
900 const char *email
, timestamp_t timestamp
, int tz
,
901 const char *message
, void *cb_data
)
903 struct read_ref_at_cb
*cb
= cb_data
;
907 cb
->date
= timestamp
;
910 * It is not possible for cb->cnt == 0 on the first iteration because
911 * that special case is handled in read_ref_at().
915 reached_count
= cb
->cnt
== 0 && !is_null_oid(ooid
);
916 if (timestamp
<= cb
->at_time
|| reached_count
) {
917 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
919 * we have not yet updated cb->[n|o]oid so they still
920 * hold the values for the previous record.
922 if (!is_null_oid(&cb
->ooid
) && !oideq(&cb
->ooid
, noid
))
923 warning(_("log for ref %s has gap after %s"),
924 cb
->refname
, show_date(cb
->date
, cb
->tz
, DATE_MODE(RFC2822
)));
926 oidcpy(cb
->oid
, ooid
);
927 else if (!is_null_oid(&cb
->ooid
) || cb
->date
== cb
->at_time
)
928 oidcpy(cb
->oid
, noid
);
929 else if (!oideq(noid
, cb
->oid
))
930 warning(_("log for ref %s unexpectedly ended on %s"),
931 cb
->refname
, show_date(cb
->date
, cb
->tz
,
932 DATE_MODE(RFC2822
)));
936 oidcpy(&cb
->ooid
, ooid
);
937 oidcpy(&cb
->noid
, noid
);
941 static int read_ref_at_ent_newest(struct object_id
*ooid
, struct object_id
*noid
,
942 const char *email
, timestamp_t timestamp
,
943 int tz
, const char *message
, void *cb_data
)
945 struct read_ref_at_cb
*cb
= cb_data
;
947 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
948 oidcpy(cb
->oid
, noid
);
949 /* We just want the first entry */
953 static int read_ref_at_ent_oldest(struct object_id
*ooid
, struct object_id
*noid
,
954 const char *email
, timestamp_t timestamp
,
955 int tz
, const char *message
, void *cb_data
)
957 struct read_ref_at_cb
*cb
= cb_data
;
959 set_read_ref_cutoffs(cb
, timestamp
, tz
, message
);
960 oidcpy(cb
->oid
, ooid
);
961 if (is_null_oid(cb
->oid
))
962 oidcpy(cb
->oid
, noid
);
963 /* We just want the first entry */
967 int read_ref_at(struct ref_store
*refs
, const char *refname
,
968 unsigned int flags
, timestamp_t at_time
, int cnt
,
969 struct object_id
*oid
, char **msg
,
970 timestamp_t
*cutoff_time
, int *cutoff_tz
, int *cutoff_cnt
)
972 struct read_ref_at_cb cb
;
974 memset(&cb
, 0, sizeof(cb
));
975 cb
.refname
= refname
;
976 cb
.at_time
= at_time
;
979 cb
.cutoff_time
= cutoff_time
;
980 cb
.cutoff_tz
= cutoff_tz
;
981 cb
.cutoff_cnt
= cutoff_cnt
;
985 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent_newest
, &cb
);
989 refs_for_each_reflog_ent_reverse(refs
, refname
, read_ref_at_ent
, &cb
);
992 if (flags
& GET_OID_QUIETLY
)
995 die(_("log for %s is empty"), refname
);
1000 refs_for_each_reflog_ent(refs
, refname
, read_ref_at_ent_oldest
, &cb
);
1005 struct ref_transaction
*ref_store_transaction_begin(struct ref_store
*refs
,
1008 struct ref_transaction
*tr
;
1011 CALLOC_ARRAY(tr
, 1);
1012 tr
->ref_store
= refs
;
1016 struct ref_transaction
*ref_transaction_begin(struct strbuf
*err
)
1018 return ref_store_transaction_begin(get_main_ref_store(the_repository
), err
);
1021 void ref_transaction_free(struct ref_transaction
*transaction
)
1028 switch (transaction
->state
) {
1029 case REF_TRANSACTION_OPEN
:
1030 case REF_TRANSACTION_CLOSED
:
1033 case REF_TRANSACTION_PREPARED
:
1034 BUG("free called on a prepared reference transaction");
1037 BUG("unexpected reference transaction state");
1041 for (i
= 0; i
< transaction
->nr
; i
++) {
1042 free(transaction
->updates
[i
]->msg
);
1043 free(transaction
->updates
[i
]);
1045 free(transaction
->updates
);
1049 struct ref_update
*ref_transaction_add_update(
1050 struct ref_transaction
*transaction
,
1051 const char *refname
, unsigned int flags
,
1052 const struct object_id
*new_oid
,
1053 const struct object_id
*old_oid
,
1056 struct ref_update
*update
;
1058 if (transaction
->state
!= REF_TRANSACTION_OPEN
)
1059 BUG("update called for transaction that is not open");
1061 FLEX_ALLOC_STR(update
, refname
, refname
);
1062 ALLOC_GROW(transaction
->updates
, transaction
->nr
+ 1, transaction
->alloc
);
1063 transaction
->updates
[transaction
->nr
++] = update
;
1065 update
->flags
= flags
;
1067 if (flags
& REF_HAVE_NEW
)
1068 oidcpy(&update
->new_oid
, new_oid
);
1069 if (flags
& REF_HAVE_OLD
)
1070 oidcpy(&update
->old_oid
, old_oid
);
1071 update
->msg
= normalize_reflog_message(msg
);
1075 int ref_transaction_update(struct ref_transaction
*transaction
,
1076 const char *refname
,
1077 const struct object_id
*new_oid
,
1078 const struct object_id
*old_oid
,
1079 unsigned int flags
, const char *msg
,
1084 if ((new_oid
&& !is_null_oid(new_oid
)) ?
1085 check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
) :
1086 !refname_is_safe(refname
)) {
1087 strbuf_addf(err
, _("refusing to update ref with bad name '%s'"),
1092 if (flags
& ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS
)
1093 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags
);
1095 flags
|= (new_oid
? REF_HAVE_NEW
: 0) | (old_oid
? REF_HAVE_OLD
: 0);
1097 ref_transaction_add_update(transaction
, refname
, flags
,
1098 new_oid
, old_oid
, msg
);
1102 int ref_transaction_create(struct ref_transaction
*transaction
,
1103 const char *refname
,
1104 const struct object_id
*new_oid
,
1105 unsigned int flags
, const char *msg
,
1108 if (!new_oid
|| is_null_oid(new_oid
))
1109 BUG("create called without valid new_oid");
1110 return ref_transaction_update(transaction
, refname
, new_oid
,
1111 null_oid(), flags
, msg
, err
);
1114 int ref_transaction_delete(struct ref_transaction
*transaction
,
1115 const char *refname
,
1116 const struct object_id
*old_oid
,
1117 unsigned int flags
, const char *msg
,
1120 if (old_oid
&& is_null_oid(old_oid
))
1121 BUG("delete called with old_oid set to zeros");
1122 return ref_transaction_update(transaction
, refname
,
1123 null_oid(), old_oid
,
1127 int ref_transaction_verify(struct ref_transaction
*transaction
,
1128 const char *refname
,
1129 const struct object_id
*old_oid
,
1134 BUG("verify called with old_oid set to NULL");
1135 return ref_transaction_update(transaction
, refname
,
1140 int refs_update_ref(struct ref_store
*refs
, const char *msg
,
1141 const char *refname
, const struct object_id
*new_oid
,
1142 const struct object_id
*old_oid
, unsigned int flags
,
1143 enum action_on_err onerr
)
1145 struct ref_transaction
*t
= NULL
;
1146 struct strbuf err
= STRBUF_INIT
;
1149 t
= ref_store_transaction_begin(refs
, &err
);
1151 ref_transaction_update(t
, refname
, new_oid
, old_oid
, flags
, msg
,
1153 ref_transaction_commit(t
, &err
)) {
1155 ref_transaction_free(t
);
1158 const char *str
= _("update_ref failed for ref '%s': %s");
1161 case UPDATE_REFS_MSG_ON_ERR
:
1162 error(str
, refname
, err
.buf
);
1164 case UPDATE_REFS_DIE_ON_ERR
:
1165 die(str
, refname
, err
.buf
);
1167 case UPDATE_REFS_QUIET_ON_ERR
:
1170 strbuf_release(&err
);
1173 strbuf_release(&err
);
1175 ref_transaction_free(t
);
1179 int update_ref(const char *msg
, const char *refname
,
1180 const struct object_id
*new_oid
,
1181 const struct object_id
*old_oid
,
1182 unsigned int flags
, enum action_on_err onerr
)
1184 return refs_update_ref(get_main_ref_store(the_repository
), msg
, refname
, new_oid
,
1185 old_oid
, flags
, onerr
);
1188 char *refs_shorten_unambiguous_ref(struct ref_store
*refs
,
1189 const char *refname
, int strict
)
1192 static char **scanf_fmts
;
1193 static int nr_rules
;
1195 struct strbuf resolved_buf
= STRBUF_INIT
;
1199 * Pre-generate scanf formats from ref_rev_parse_rules[].
1200 * Generate a format suitable for scanf from a
1201 * ref_rev_parse_rules rule by interpolating "%s" at the
1202 * location of the "%.*s".
1204 size_t total_len
= 0;
1207 /* the rule list is NULL terminated, count them first */
1208 for (nr_rules
= 0; ref_rev_parse_rules
[nr_rules
]; nr_rules
++)
1209 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1210 total_len
+= strlen(ref_rev_parse_rules
[nr_rules
]) - 2 + 1;
1212 scanf_fmts
= xmalloc(st_add(st_mult(sizeof(char *), nr_rules
), total_len
));
1215 for (i
= 0; i
< nr_rules
; i
++) {
1216 assert(offset
< total_len
);
1217 scanf_fmts
[i
] = (char *)&scanf_fmts
[nr_rules
] + offset
;
1218 offset
+= xsnprintf(scanf_fmts
[i
], total_len
- offset
,
1219 ref_rev_parse_rules
[i
], 2, "%s") + 1;
1223 /* bail out if there are no rules */
1225 return xstrdup(refname
);
1227 /* buffer for scanf result, at most refname must fit */
1228 short_name
= xstrdup(refname
);
1230 /* skip first rule, it will always match */
1231 for (i
= nr_rules
- 1; i
> 0 ; --i
) {
1233 int rules_to_fail
= i
;
1236 if (1 != sscanf(refname
, scanf_fmts
[i
], short_name
))
1239 short_name_len
= strlen(short_name
);
1242 * in strict mode, all (except the matched one) rules
1243 * must fail to resolve to a valid non-ambiguous ref
1246 rules_to_fail
= nr_rules
;
1249 * check if the short name resolves to a valid ref,
1250 * but use only rules prior to the matched one
1252 for (j
= 0; j
< rules_to_fail
; j
++) {
1253 const char *rule
= ref_rev_parse_rules
[j
];
1255 /* skip matched rule */
1260 * the short name is ambiguous, if it resolves
1261 * (with this previous rule) to a valid ref
1262 * read_ref() returns 0 on success
1264 strbuf_reset(&resolved_buf
);
1265 strbuf_addf(&resolved_buf
, rule
,
1266 short_name_len
, short_name
);
1267 if (refs_ref_exists(refs
, resolved_buf
.buf
))
1272 * short name is non-ambiguous if all previous rules
1273 * haven't resolved to a valid ref
1275 if (j
== rules_to_fail
) {
1276 strbuf_release(&resolved_buf
);
1281 strbuf_release(&resolved_buf
);
1283 return xstrdup(refname
);
1286 char *shorten_unambiguous_ref(const char *refname
, int strict
)
1288 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository
),
1292 static struct string_list
*hide_refs
;
1294 int parse_hide_refs_config(const char *var
, const char *value
, const char *section
)
1297 if (!strcmp("transfer.hiderefs", var
) ||
1298 (!parse_config_key(var
, section
, NULL
, NULL
, &key
) &&
1299 !strcmp(key
, "hiderefs"))) {
1304 return config_error_nonbool(var
);
1305 ref
= xstrdup(value
);
1307 while (len
&& ref
[len
- 1] == '/')
1310 CALLOC_ARRAY(hide_refs
, 1);
1311 hide_refs
->strdup_strings
= 1;
1313 string_list_append(hide_refs
, ref
);
1318 int ref_is_hidden(const char *refname
, const char *refname_full
)
1324 for (i
= hide_refs
->nr
- 1; i
>= 0; i
--) {
1325 const char *match
= hide_refs
->items
[i
].string
;
1326 const char *subject
;
1330 if (*match
== '!') {
1335 if (*match
== '^') {
1336 subject
= refname_full
;
1342 /* refname can be NULL when namespaces are used. */
1344 skip_prefix(subject
, match
, &p
) &&
1351 const char *find_descendant_ref(const char *dirname
,
1352 const struct string_list
*extras
,
1353 const struct string_list
*skip
)
1361 * Look at the place where dirname would be inserted into
1362 * extras. If there is an entry at that position that starts
1363 * with dirname (remember, dirname includes the trailing
1364 * slash) and is not in skip, then we have a conflict.
1366 for (pos
= string_list_find_insert_index(extras
, dirname
, 0);
1367 pos
< extras
->nr
; pos
++) {
1368 const char *extra_refname
= extras
->items
[pos
].string
;
1370 if (!starts_with(extra_refname
, dirname
))
1373 if (!skip
|| !string_list_has_string(skip
, extra_refname
))
1374 return extra_refname
;
1379 int refs_rename_ref_available(struct ref_store
*refs
,
1380 const char *old_refname
,
1381 const char *new_refname
)
1383 struct string_list skip
= STRING_LIST_INIT_NODUP
;
1384 struct strbuf err
= STRBUF_INIT
;
1387 string_list_insert(&skip
, old_refname
);
1388 ok
= !refs_verify_refname_available(refs
, new_refname
,
1391 error("%s", err
.buf
);
1393 string_list_clear(&skip
, 0);
1394 strbuf_release(&err
);
1398 int refs_head_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1400 struct object_id oid
;
1403 if (!refs_read_ref_full(refs
, "HEAD", RESOLVE_REF_READING
,
1405 return fn("HEAD", &oid
, flag
, cb_data
);
1410 int head_ref(each_ref_fn fn
, void *cb_data
)
1412 return refs_head_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1415 struct ref_iterator
*refs_ref_iterator_begin(
1416 struct ref_store
*refs
,
1417 const char *prefix
, int trim
, int flags
)
1419 struct ref_iterator
*iter
;
1421 if (ref_paranoia
< 0)
1422 ref_paranoia
= git_env_bool("GIT_REF_PARANOIA", 0);
1424 flags
|= DO_FOR_EACH_INCLUDE_BROKEN
;
1426 iter
= refs
->be
->iterator_begin(refs
, prefix
, flags
);
1429 * `iterator_begin()` already takes care of prefix, but we
1430 * might need to do some trimming:
1433 iter
= prefix_ref_iterator_begin(iter
, "", trim
);
1435 /* Sanity check for subclasses: */
1437 BUG("reference iterator is not ordered");
1443 * Call fn for each reference in the specified submodule for which the
1444 * refname begins with prefix. If trim is non-zero, then trim that
1445 * many characters off the beginning of each refname before passing
1446 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1447 * include broken references in the iteration. If fn ever returns a
1448 * non-zero value, stop the iteration and return that value;
1449 * otherwise, return 0.
1451 static int do_for_each_repo_ref(struct repository
*r
, const char *prefix
,
1452 each_repo_ref_fn fn
, int trim
, int flags
,
1455 struct ref_iterator
*iter
;
1456 struct ref_store
*refs
= get_main_ref_store(r
);
1461 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1463 return do_for_each_repo_ref_iterator(r
, iter
, fn
, cb_data
);
1466 struct do_for_each_ref_help
{
1471 static int do_for_each_ref_helper(struct repository
*r
,
1472 const char *refname
,
1473 const struct object_id
*oid
,
1477 struct do_for_each_ref_help
*hp
= cb_data
;
1479 return hp
->fn(refname
, oid
, flags
, hp
->cb_data
);
1482 static int do_for_each_ref(struct ref_store
*refs
, const char *prefix
,
1483 each_ref_fn fn
, int trim
, int flags
, void *cb_data
)
1485 struct ref_iterator
*iter
;
1486 struct do_for_each_ref_help hp
= { fn
, cb_data
};
1491 iter
= refs_ref_iterator_begin(refs
, prefix
, trim
, flags
);
1493 return do_for_each_repo_ref_iterator(the_repository
, iter
,
1494 do_for_each_ref_helper
, &hp
);
1497 int refs_for_each_ref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1499 return do_for_each_ref(refs
, "", fn
, 0, 0, cb_data
);
1502 int for_each_ref(each_ref_fn fn
, void *cb_data
)
1504 return refs_for_each_ref(get_main_ref_store(the_repository
), fn
, cb_data
);
1507 int refs_for_each_ref_in(struct ref_store
*refs
, const char *prefix
,
1508 each_ref_fn fn
, void *cb_data
)
1510 return do_for_each_ref(refs
, prefix
, fn
, strlen(prefix
), 0, cb_data
);
1513 int for_each_ref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
)
1515 return refs_for_each_ref_in(get_main_ref_store(the_repository
), prefix
, fn
, cb_data
);
1518 int for_each_fullref_in(const char *prefix
, each_ref_fn fn
, void *cb_data
, unsigned int broken
)
1520 unsigned int flag
= 0;
1523 flag
= DO_FOR_EACH_INCLUDE_BROKEN
;
1524 return do_for_each_ref(get_main_ref_store(the_repository
),
1525 prefix
, fn
, 0, flag
, cb_data
);
1528 int refs_for_each_fullref_in(struct ref_store
*refs
, const char *prefix
,
1529 each_ref_fn fn
, void *cb_data
,
1530 unsigned int broken
)
1532 unsigned int flag
= 0;
1535 flag
= DO_FOR_EACH_INCLUDE_BROKEN
;
1536 return do_for_each_ref(refs
, prefix
, fn
, 0, flag
, cb_data
);
1539 int for_each_replace_ref(struct repository
*r
, each_repo_ref_fn fn
, void *cb_data
)
1541 return do_for_each_repo_ref(r
, git_replace_ref_base
, fn
,
1542 strlen(git_replace_ref_base
),
1543 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1546 int for_each_namespaced_ref(each_ref_fn fn
, void *cb_data
)
1548 struct strbuf buf
= STRBUF_INIT
;
1550 strbuf_addf(&buf
, "%srefs/", get_git_namespace());
1551 ret
= do_for_each_ref(get_main_ref_store(the_repository
),
1552 buf
.buf
, fn
, 0, 0, cb_data
);
1553 strbuf_release(&buf
);
1557 int refs_for_each_rawref(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
1559 return do_for_each_ref(refs
, "", fn
, 0,
1560 DO_FOR_EACH_INCLUDE_BROKEN
, cb_data
);
1563 int for_each_rawref(each_ref_fn fn
, void *cb_data
)
1565 return refs_for_each_rawref(get_main_ref_store(the_repository
), fn
, cb_data
);
1568 static int qsort_strcmp(const void *va
, const void *vb
)
1570 const char *a
= *(const char **)va
;
1571 const char *b
= *(const char **)vb
;
1573 return strcmp(a
, b
);
1576 static void find_longest_prefixes_1(struct string_list
*out
,
1577 struct strbuf
*prefix
,
1578 const char **patterns
, size_t nr
)
1582 for (i
= 0; i
< nr
; i
++) {
1583 char c
= patterns
[i
][prefix
->len
];
1584 if (!c
|| is_glob_special(c
)) {
1585 string_list_append(out
, prefix
->buf
);
1595 * Set "end" to the index of the element _after_ the last one
1598 for (end
= i
+ 1; end
< nr
; end
++) {
1599 if (patterns
[i
][prefix
->len
] != patterns
[end
][prefix
->len
])
1603 strbuf_addch(prefix
, patterns
[i
][prefix
->len
]);
1604 find_longest_prefixes_1(out
, prefix
, patterns
+ i
, end
- i
);
1605 strbuf_setlen(prefix
, prefix
->len
- 1);
1611 static void find_longest_prefixes(struct string_list
*out
,
1612 const char **patterns
)
1614 struct strvec sorted
= STRVEC_INIT
;
1615 struct strbuf prefix
= STRBUF_INIT
;
1617 strvec_pushv(&sorted
, patterns
);
1618 QSORT(sorted
.v
, sorted
.nr
, qsort_strcmp
);
1620 find_longest_prefixes_1(out
, &prefix
, sorted
.v
, sorted
.nr
);
1622 strvec_clear(&sorted
);
1623 strbuf_release(&prefix
);
1626 int for_each_fullref_in_prefixes(const char *namespace,
1627 const char **patterns
,
1628 each_ref_fn fn
, void *cb_data
,
1629 unsigned int broken
)
1631 struct string_list prefixes
= STRING_LIST_INIT_DUP
;
1632 struct string_list_item
*prefix
;
1633 struct strbuf buf
= STRBUF_INIT
;
1634 int ret
= 0, namespace_len
;
1636 find_longest_prefixes(&prefixes
, patterns
);
1639 strbuf_addstr(&buf
, namespace);
1640 namespace_len
= buf
.len
;
1642 for_each_string_list_item(prefix
, &prefixes
) {
1643 strbuf_addstr(&buf
, prefix
->string
);
1644 ret
= for_each_fullref_in(buf
.buf
, fn
, cb_data
, broken
);
1647 strbuf_setlen(&buf
, namespace_len
);
1650 string_list_clear(&prefixes
, 0);
1651 strbuf_release(&buf
);
1655 static int refs_read_special_head(struct ref_store
*ref_store
,
1656 const char *refname
, struct object_id
*oid
,
1657 struct strbuf
*referent
, unsigned int *type
)
1659 struct strbuf full_path
= STRBUF_INIT
;
1660 struct strbuf content
= STRBUF_INIT
;
1662 strbuf_addf(&full_path
, "%s/%s", ref_store
->gitdir
, refname
);
1664 if (strbuf_read_file(&content
, full_path
.buf
, 0) < 0)
1667 result
= parse_loose_ref_contents(content
.buf
, oid
, referent
, type
);
1670 strbuf_release(&full_path
);
1671 strbuf_release(&content
);
1675 int refs_read_raw_ref(struct ref_store
*ref_store
,
1676 const char *refname
, struct object_id
*oid
,
1677 struct strbuf
*referent
, unsigned int *type
)
1679 if (!strcmp(refname
, "FETCH_HEAD") || !strcmp(refname
, "MERGE_HEAD")) {
1680 return refs_read_special_head(ref_store
, refname
, oid
, referent
,
1684 return ref_store
->be
->read_raw_ref(ref_store
, refname
, oid
, referent
,
1688 /* This function needs to return a meaningful errno on failure */
1689 const char *refs_resolve_ref_unsafe(struct ref_store
*refs
,
1690 const char *refname
,
1692 struct object_id
*oid
, int *flags
)
1694 static struct strbuf sb_refname
= STRBUF_INIT
;
1695 struct object_id unused_oid
;
1702 flags
= &unused_flags
;
1706 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1707 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1708 !refname_is_safe(refname
)) {
1714 * dwim_ref() uses REF_ISBROKEN to distinguish between
1715 * missing refs and refs that were present but invalid,
1716 * to complain about the latter to stderr.
1718 * We don't know whether the ref exists, so don't set
1721 *flags
|= REF_BAD_NAME
;
1724 for (symref_count
= 0; symref_count
< SYMREF_MAXDEPTH
; symref_count
++) {
1725 unsigned int read_flags
= 0;
1727 if (refs_read_raw_ref(refs
, refname
,
1728 oid
, &sb_refname
, &read_flags
)) {
1729 *flags
|= read_flags
;
1731 /* In reading mode, refs must eventually resolve */
1732 if (resolve_flags
& RESOLVE_REF_READING
)
1736 * Otherwise a missing ref is OK. But the files backend
1737 * may show errors besides ENOENT if there are
1738 * similarly-named refs.
1740 if (errno
!= ENOENT
&&
1746 if (*flags
& REF_BAD_NAME
)
1747 *flags
|= REF_ISBROKEN
;
1751 *flags
|= read_flags
;
1753 if (!(read_flags
& REF_ISSYMREF
)) {
1754 if (*flags
& REF_BAD_NAME
) {
1756 *flags
|= REF_ISBROKEN
;
1761 refname
= sb_refname
.buf
;
1762 if (resolve_flags
& RESOLVE_REF_NO_RECURSE
) {
1766 if (check_refname_format(refname
, REFNAME_ALLOW_ONELEVEL
)) {
1767 if (!(resolve_flags
& RESOLVE_REF_ALLOW_BAD_NAME
) ||
1768 !refname_is_safe(refname
)) {
1773 *flags
|= REF_ISBROKEN
| REF_BAD_NAME
;
1781 /* backend functions */
1782 int refs_init_db(struct strbuf
*err
)
1784 struct ref_store
*refs
= get_main_ref_store(the_repository
);
1786 return refs
->be
->init_db(refs
, err
);
1789 const char *resolve_ref_unsafe(const char *refname
, int resolve_flags
,
1790 struct object_id
*oid
, int *flags
)
1792 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository
), refname
,
1793 resolve_flags
, oid
, flags
);
1796 int resolve_gitlink_ref(const char *submodule
, const char *refname
,
1797 struct object_id
*oid
)
1799 struct ref_store
*refs
;
1802 refs
= get_submodule_ref_store(submodule
);
1807 if (!refs_resolve_ref_unsafe(refs
, refname
, 0, oid
, &flags
) ||
1813 struct ref_store_hash_entry
1815 struct hashmap_entry ent
;
1817 struct ref_store
*refs
;
1819 /* NUL-terminated identifier of the ref store: */
1820 char name
[FLEX_ARRAY
];
1823 static int ref_store_hash_cmp(const void *unused_cmp_data
,
1824 const struct hashmap_entry
*eptr
,
1825 const struct hashmap_entry
*entry_or_key
,
1826 const void *keydata
)
1828 const struct ref_store_hash_entry
*e1
, *e2
;
1831 e1
= container_of(eptr
, const struct ref_store_hash_entry
, ent
);
1832 e2
= container_of(entry_or_key
, const struct ref_store_hash_entry
, ent
);
1833 name
= keydata
? keydata
: e2
->name
;
1835 return strcmp(e1
->name
, name
);
1838 static struct ref_store_hash_entry
*alloc_ref_store_hash_entry(
1839 const char *name
, struct ref_store
*refs
)
1841 struct ref_store_hash_entry
*entry
;
1843 FLEX_ALLOC_STR(entry
, name
, name
);
1844 hashmap_entry_init(&entry
->ent
, strhash(name
));
1849 /* A hashmap of ref_stores, stored by submodule name: */
1850 static struct hashmap submodule_ref_stores
;
1852 /* A hashmap of ref_stores, stored by worktree id: */
1853 static struct hashmap worktree_ref_stores
;
1856 * Look up a ref store by name. If that ref_store hasn't been
1857 * registered yet, return NULL.
1859 static struct ref_store
*lookup_ref_store_map(struct hashmap
*map
,
1862 struct ref_store_hash_entry
*entry
;
1865 if (!map
->tablesize
)
1866 /* It's initialized on demand in register_ref_store(). */
1869 hash
= strhash(name
);
1870 entry
= hashmap_get_entry_from_hash(map
, hash
, name
,
1871 struct ref_store_hash_entry
, ent
);
1872 return entry
? entry
->refs
: NULL
;
1876 * Create, record, and return a ref_store instance for the specified
1879 static struct ref_store
*ref_store_init(const char *gitdir
,
1882 const char *be_name
= "files";
1883 struct ref_storage_be
*be
= find_ref_storage_backend(be_name
);
1884 struct ref_store
*refs
;
1887 BUG("reference backend %s is unknown", be_name
);
1889 refs
= be
->init(gitdir
, flags
);
1893 struct ref_store
*get_main_ref_store(struct repository
*r
)
1895 if (r
->refs_private
)
1896 return r
->refs_private
;
1899 BUG("attempting to get main_ref_store outside of repository");
1901 r
->refs_private
= ref_store_init(r
->gitdir
, REF_STORE_ALL_CAPS
);
1902 r
->refs_private
= maybe_debug_wrap_ref_store(r
->gitdir
, r
->refs_private
);
1903 return r
->refs_private
;
1907 * Associate a ref store with a name. It is a fatal error to call this
1908 * function twice for the same name.
1910 static void register_ref_store_map(struct hashmap
*map
,
1912 struct ref_store
*refs
,
1915 struct ref_store_hash_entry
*entry
;
1917 if (!map
->tablesize
)
1918 hashmap_init(map
, ref_store_hash_cmp
, NULL
, 0);
1920 entry
= alloc_ref_store_hash_entry(name
, refs
);
1921 if (hashmap_put(map
, &entry
->ent
))
1922 BUG("%s ref_store '%s' initialized twice", type
, name
);
1925 struct ref_store
*get_submodule_ref_store(const char *submodule
)
1927 struct strbuf submodule_sb
= STRBUF_INIT
;
1928 struct ref_store
*refs
;
1929 char *to_free
= NULL
;
1935 len
= strlen(submodule
);
1936 while (len
&& is_dir_sep(submodule
[len
- 1]))
1942 /* We need to strip off one or more trailing slashes */
1943 submodule
= to_free
= xmemdupz(submodule
, len
);
1945 refs
= lookup_ref_store_map(&submodule_ref_stores
, submodule
);
1949 strbuf_addstr(&submodule_sb
, submodule
);
1950 if (!is_nonbare_repository_dir(&submodule_sb
))
1953 if (submodule_to_gitdir(&submodule_sb
, submodule
))
1956 /* assume that add_submodule_odb() has been called */
1957 refs
= ref_store_init(submodule_sb
.buf
,
1958 REF_STORE_READ
| REF_STORE_ODB
);
1959 register_ref_store_map(&submodule_ref_stores
, "submodule",
1963 strbuf_release(&submodule_sb
);
1969 struct ref_store
*get_worktree_ref_store(const struct worktree
*wt
)
1971 struct ref_store
*refs
;
1975 return get_main_ref_store(the_repository
);
1977 id
= wt
->id
? wt
->id
: "/";
1978 refs
= lookup_ref_store_map(&worktree_ref_stores
, id
);
1983 refs
= ref_store_init(git_common_path("worktrees/%s", wt
->id
),
1984 REF_STORE_ALL_CAPS
);
1986 refs
= ref_store_init(get_git_common_dir(),
1987 REF_STORE_ALL_CAPS
);
1990 register_ref_store_map(&worktree_ref_stores
, "worktree",
1995 void base_ref_store_init(struct ref_store
*refs
,
1996 const struct ref_storage_be
*be
)
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 hook
= find_hook("reference-transaction");
2074 strvec_pushl(&proc
.args
, hook
, state
, NULL
);
2076 proc
.stdout_to_stderr
= 1;
2077 proc
.trace2_hook_name
= "reference-transaction";
2079 ret
= start_command(&proc
);
2083 sigchain_push(SIGPIPE
, SIG_IGN
);
2085 for (i
= 0; i
< transaction
->nr
; i
++) {
2086 struct ref_update
*update
= transaction
->updates
[i
];
2089 strbuf_addf(&buf
, "%s %s %s\n",
2090 oid_to_hex(&update
->old_oid
),
2091 oid_to_hex(&update
->new_oid
),
2094 if (write_in_full(proc
.in
, buf
.buf
, buf
.len
) < 0) {
2102 sigchain_pop(SIGPIPE
);
2103 strbuf_release(&buf
);
2105 ret
|= finish_command(&proc
);
2109 int ref_transaction_prepare(struct ref_transaction
*transaction
,
2112 struct ref_store
*refs
= transaction
->ref_store
;
2115 switch (transaction
->state
) {
2116 case REF_TRANSACTION_OPEN
:
2119 case REF_TRANSACTION_PREPARED
:
2120 BUG("prepare called twice on reference transaction");
2122 case REF_TRANSACTION_CLOSED
:
2123 BUG("prepare called on a closed reference transaction");
2126 BUG("unexpected reference transaction state");
2130 if (getenv(GIT_QUARANTINE_ENVIRONMENT
)) {
2132 _("ref updates forbidden inside quarantine environment"));
2136 ret
= refs
->be
->transaction_prepare(refs
, transaction
, err
);
2140 ret
= run_transaction_hook(transaction
, "prepared");
2142 ref_transaction_abort(transaction
, err
);
2143 die(_("ref updates aborted by hook"));
2149 int ref_transaction_abort(struct ref_transaction
*transaction
,
2152 struct ref_store
*refs
= transaction
->ref_store
;
2155 switch (transaction
->state
) {
2156 case REF_TRANSACTION_OPEN
:
2157 /* No need to abort explicitly. */
2159 case REF_TRANSACTION_PREPARED
:
2160 ret
= refs
->be
->transaction_abort(refs
, transaction
, err
);
2162 case REF_TRANSACTION_CLOSED
:
2163 BUG("abort called on a closed reference transaction");
2166 BUG("unexpected reference transaction state");
2170 run_transaction_hook(transaction
, "aborted");
2172 ref_transaction_free(transaction
);
2176 int ref_transaction_commit(struct ref_transaction
*transaction
,
2179 struct ref_store
*refs
= transaction
->ref_store
;
2182 switch (transaction
->state
) {
2183 case REF_TRANSACTION_OPEN
:
2184 /* Need to prepare first. */
2185 ret
= ref_transaction_prepare(transaction
, err
);
2189 case REF_TRANSACTION_PREPARED
:
2190 /* Fall through to finish. */
2192 case REF_TRANSACTION_CLOSED
:
2193 BUG("commit called on a closed reference transaction");
2196 BUG("unexpected reference transaction state");
2200 ret
= refs
->be
->transaction_finish(refs
, transaction
, err
);
2202 run_transaction_hook(transaction
, "committed");
2206 int refs_verify_refname_available(struct ref_store
*refs
,
2207 const char *refname
,
2208 const struct string_list
*extras
,
2209 const struct string_list
*skip
,
2213 const char *extra_refname
;
2214 struct strbuf dirname
= STRBUF_INIT
;
2215 struct strbuf referent
= STRBUF_INIT
;
2216 struct object_id oid
;
2218 struct ref_iterator
*iter
;
2223 * For the sake of comments in this function, suppose that
2224 * refname is "refs/foo/bar".
2229 strbuf_grow(&dirname
, strlen(refname
) + 1);
2230 for (slash
= strchr(refname
, '/'); slash
; slash
= strchr(slash
+ 1, '/')) {
2231 /* Expand dirname to the new prefix, not including the trailing slash: */
2232 strbuf_add(&dirname
, refname
+ dirname
.len
, slash
- refname
- dirname
.len
);
2235 * We are still at a leading dir of the refname (e.g.,
2236 * "refs/foo"; if there is a reference with that name,
2237 * it is a conflict, *unless* it is in skip.
2239 if (skip
&& string_list_has_string(skip
, dirname
.buf
))
2242 if (!refs_read_raw_ref(refs
, dirname
.buf
, &oid
, &referent
, &type
)) {
2243 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2244 dirname
.buf
, refname
);
2248 if (extras
&& string_list_has_string(extras
, dirname
.buf
)) {
2249 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2250 refname
, dirname
.buf
);
2256 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2257 * There is no point in searching for a reference with that
2258 * name, because a refname isn't considered to conflict with
2259 * itself. But we still need to check for references whose
2260 * names are in the "refs/foo/bar/" namespace, because they
2263 strbuf_addstr(&dirname
, refname
+ dirname
.len
);
2264 strbuf_addch(&dirname
, '/');
2266 iter
= refs_ref_iterator_begin(refs
, dirname
.buf
, 0,
2267 DO_FOR_EACH_INCLUDE_BROKEN
);
2268 while ((ok
= ref_iterator_advance(iter
)) == ITER_OK
) {
2270 string_list_has_string(skip
, iter
->refname
))
2273 strbuf_addf(err
, _("'%s' exists; cannot create '%s'"),
2274 iter
->refname
, refname
);
2275 ref_iterator_abort(iter
);
2279 if (ok
!= ITER_DONE
)
2280 BUG("error while iterating over references");
2282 extra_refname
= find_descendant_ref(dirname
.buf
, extras
, skip
);
2284 strbuf_addf(err
, _("cannot process '%s' and '%s' at the same time"),
2285 refname
, extra_refname
);
2290 strbuf_release(&referent
);
2291 strbuf_release(&dirname
);
2295 int refs_for_each_reflog(struct ref_store
*refs
, each_ref_fn fn
, void *cb_data
)
2297 struct ref_iterator
*iter
;
2298 struct do_for_each_ref_help hp
= { fn
, cb_data
};
2300 iter
= refs
->be
->reflog_iterator_begin(refs
);
2302 return do_for_each_repo_ref_iterator(the_repository
, iter
,
2303 do_for_each_ref_helper
, &hp
);
2306 int for_each_reflog(each_ref_fn fn
, void *cb_data
)
2308 return refs_for_each_reflog(get_main_ref_store(the_repository
), fn
, cb_data
);
2311 int refs_for_each_reflog_ent_reverse(struct ref_store
*refs
,
2312 const char *refname
,
2313 each_reflog_ent_fn fn
,
2316 return refs
->be
->for_each_reflog_ent_reverse(refs
, refname
,
2320 int for_each_reflog_ent_reverse(const char *refname
, each_reflog_ent_fn fn
,
2323 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository
),
2324 refname
, fn
, cb_data
);
2327 int refs_for_each_reflog_ent(struct ref_store
*refs
, const char *refname
,
2328 each_reflog_ent_fn fn
, void *cb_data
)
2330 return refs
->be
->for_each_reflog_ent(refs
, refname
, fn
, cb_data
);
2333 int for_each_reflog_ent(const char *refname
, each_reflog_ent_fn fn
,
2336 return refs_for_each_reflog_ent(get_main_ref_store(the_repository
), refname
,
2340 int refs_reflog_exists(struct ref_store
*refs
, const char *refname
)
2342 return refs
->be
->reflog_exists(refs
, refname
);
2345 int reflog_exists(const char *refname
)
2347 return refs_reflog_exists(get_main_ref_store(the_repository
), refname
);
2350 int refs_create_reflog(struct ref_store
*refs
, const char *refname
,
2351 int force_create
, struct strbuf
*err
)
2353 return refs
->be
->create_reflog(refs
, refname
, force_create
, err
);
2356 int safe_create_reflog(const char *refname
, int force_create
,
2359 return refs_create_reflog(get_main_ref_store(the_repository
), refname
,
2363 int refs_delete_reflog(struct ref_store
*refs
, const char *refname
)
2365 return refs
->be
->delete_reflog(refs
, refname
);
2368 int delete_reflog(const char *refname
)
2370 return refs_delete_reflog(get_main_ref_store(the_repository
), refname
);
2373 int refs_reflog_expire(struct ref_store
*refs
,
2374 const char *refname
,
2376 reflog_expiry_prepare_fn prepare_fn
,
2377 reflog_expiry_should_prune_fn should_prune_fn
,
2378 reflog_expiry_cleanup_fn cleanup_fn
,
2379 void *policy_cb_data
)
2381 return refs
->be
->reflog_expire(refs
, refname
, flags
,
2382 prepare_fn
, should_prune_fn
,
2383 cleanup_fn
, policy_cb_data
);
2386 int reflog_expire(const char *refname
,
2388 reflog_expiry_prepare_fn prepare_fn
,
2389 reflog_expiry_should_prune_fn should_prune_fn
,
2390 reflog_expiry_cleanup_fn cleanup_fn
,
2391 void *policy_cb_data
)
2393 return refs_reflog_expire(get_main_ref_store(the_repository
),
2395 prepare_fn
, should_prune_fn
,
2396 cleanup_fn
, policy_cb_data
);
2399 int initial_ref_transaction_commit(struct ref_transaction
*transaction
,
2402 struct ref_store
*refs
= transaction
->ref_store
;
2404 return refs
->be
->initial_transaction_commit(refs
, transaction
, err
);
2407 int refs_delete_refs(struct ref_store
*refs
, const char *logmsg
,
2408 struct string_list
*refnames
, unsigned int flags
)
2413 msg
= normalize_reflog_message(logmsg
);
2414 retval
= refs
->be
->delete_refs(refs
, msg
, refnames
, flags
);
2419 int delete_refs(const char *msg
, struct string_list
*refnames
,
2422 return refs_delete_refs(get_main_ref_store(the_repository
), msg
, refnames
, flags
);
2425 int refs_rename_ref(struct ref_store
*refs
, const char *oldref
,
2426 const char *newref
, const char *logmsg
)
2431 msg
= normalize_reflog_message(logmsg
);
2432 retval
= refs
->be
->rename_ref(refs
, oldref
, newref
, msg
);
2437 int rename_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2439 return refs_rename_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);
2442 int refs_copy_existing_ref(struct ref_store
*refs
, const char *oldref
,
2443 const char *newref
, const char *logmsg
)
2448 msg
= normalize_reflog_message(logmsg
);
2449 retval
= refs
->be
->copy_ref(refs
, oldref
, newref
, msg
);
2454 int copy_existing_ref(const char *oldref
, const char *newref
, const char *logmsg
)
2456 return refs_copy_existing_ref(get_main_ref_store(the_repository
), oldref
, newref
, logmsg
);