date: make DATE_MODE thread-safe
[git.git] / refs.c
blob55d2e0b2cb9e959443e98eb329fdf97eff9073a9
1 /*
2 * The backend-independent part of the reference module.
3 */
5 #include "git-compat-util.h"
6 #include "advice.h"
7 #include "config.h"
8 #include "environment.h"
9 #include "hashmap.h"
10 #include "gettext.h"
11 #include "hex.h"
12 #include "lockfile.h"
13 #include "iterator.h"
14 #include "refs.h"
15 #include "refs/refs-internal.h"
16 #include "run-command.h"
17 #include "hook.h"
18 #include "object-name.h"
19 #include "object-store-ll.h"
20 #include "object.h"
21 #include "path.h"
22 #include "tag.h"
23 #include "submodule.h"
24 #include "worktree.h"
25 #include "strvec.h"
26 #include "repository.h"
27 #include "setup.h"
28 #include "sigchain.h"
29 #include "date.h"
30 #include "commit.h"
31 #include "wildmatch.h"
34 * List of all available backends
36 static const struct ref_storage_be *refs_backends[] = {
37 [REF_STORAGE_FORMAT_FILES] = &refs_be_files,
38 [REF_STORAGE_FORMAT_REFTABLE] = &refs_be_reftable,
41 static const struct ref_storage_be *find_ref_storage_backend(unsigned int ref_storage_format)
43 if (ref_storage_format < ARRAY_SIZE(refs_backends))
44 return refs_backends[ref_storage_format];
45 return NULL;
48 unsigned int ref_storage_format_by_name(const char *name)
50 for (unsigned int i = 0; i < ARRAY_SIZE(refs_backends); i++)
51 if (refs_backends[i] && !strcmp(refs_backends[i]->name, name))
52 return i;
53 return REF_STORAGE_FORMAT_UNKNOWN;
56 const char *ref_storage_format_to_name(unsigned int ref_storage_format)
58 const struct ref_storage_be *be = find_ref_storage_backend(ref_storage_format);
59 if (!be)
60 return "unknown";
61 return be->name;
65 * How to handle various characters in refnames:
66 * 0: An acceptable character for refs
67 * 1: End-of-component
68 * 2: ., look for a preceding . to reject .. in refs
69 * 3: {, look for a preceding @ to reject @{ in refs
70 * 4: A bad character: ASCII control characters, and
71 * ":", "?", "[", "\", "^", "~", SP, or TAB
72 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
74 static unsigned char refname_disposition[256] = {
75 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
82 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
85 struct ref_namespace_info ref_namespace[] = {
86 [NAMESPACE_HEAD] = {
87 .ref = "HEAD",
88 .decoration = DECORATION_REF_HEAD,
89 .exact = 1,
91 [NAMESPACE_BRANCHES] = {
92 .ref = "refs/heads/",
93 .decoration = DECORATION_REF_LOCAL,
95 [NAMESPACE_TAGS] = {
96 .ref = "refs/tags/",
97 .decoration = DECORATION_REF_TAG,
99 [NAMESPACE_REMOTE_REFS] = {
101 * The default refspec for new remotes copies refs from
102 * refs/heads/ on the remote into refs/remotes/<remote>/.
103 * As such, "refs/remotes/" has special handling.
105 .ref = "refs/remotes/",
106 .decoration = DECORATION_REF_REMOTE,
108 [NAMESPACE_STASH] = {
110 * The single ref "refs/stash" stores the latest stash.
111 * Older stashes can be found in the reflog.
113 .ref = "refs/stash",
114 .exact = 1,
115 .decoration = DECORATION_REF_STASH,
117 [NAMESPACE_REPLACE] = {
119 * This namespace allows Git to act as if one object ID
120 * points to the content of another. Unlike the other
121 * ref namespaces, this one can be changed by the
122 * GIT_REPLACE_REF_BASE environment variable. This
123 * .namespace value will be overwritten in setup_git_env().
125 .ref = "refs/replace/",
126 .decoration = DECORATION_GRAFTED,
128 [NAMESPACE_NOTES] = {
130 * The refs/notes/commit ref points to the tip of a
131 * parallel commit history that adds metadata to commits
132 * in the normal history. This ref can be overwritten
133 * by the core.notesRef config variable or the
134 * GIT_NOTES_REFS environment variable.
136 .ref = "refs/notes/commit",
137 .exact = 1,
139 [NAMESPACE_PREFETCH] = {
141 * Prefetch refs are written by the background 'fetch'
142 * maintenance task. It allows faster foreground fetches
143 * by advertising these previously-downloaded tips without
144 * updating refs/remotes/ without user intervention.
146 .ref = "refs/prefetch/",
148 [NAMESPACE_REWRITTEN] = {
150 * Rewritten refs are used by the 'label' command in the
151 * sequencer. These are particularly useful during an
152 * interactive rebase that uses the 'merge' command.
154 .ref = "refs/rewritten/",
158 void update_ref_namespace(enum ref_namespace namespace, char *ref)
160 struct ref_namespace_info *info = &ref_namespace[namespace];
161 if (info->ref_updated)
162 free(info->ref);
163 info->ref = ref;
164 info->ref_updated = 1;
168 * Try to read one refname component from the front of refname.
169 * Return the length of the component found, or -1 if the component is
170 * not legal. It is legal if it is something reasonable to have under
171 * ".git/refs/"; We do not like it if:
173 * - it begins with ".", or
174 * - it has double dots "..", or
175 * - it has ASCII control characters, or
176 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
177 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
178 * - it ends with a "/", or
179 * - it ends with ".lock", or
180 * - it contains a "@{" portion
182 * When sanitized is not NULL, instead of rejecting the input refname
183 * as an error, try to come up with a usable replacement for the input
184 * refname in it.
186 static int check_refname_component(const char *refname, int *flags,
187 struct strbuf *sanitized)
189 const char *cp;
190 char last = '\0';
191 size_t component_start = 0; /* garbage - not a reasonable initial value */
193 if (sanitized)
194 component_start = sanitized->len;
196 for (cp = refname; ; cp++) {
197 int ch = *cp & 255;
198 unsigned char disp = refname_disposition[ch];
200 if (sanitized && disp != 1)
201 strbuf_addch(sanitized, ch);
203 switch (disp) {
204 case 1:
205 goto out;
206 case 2:
207 if (last == '.') { /* Refname contains "..". */
208 if (sanitized)
209 /* collapse ".." to single "." */
210 strbuf_setlen(sanitized, sanitized->len - 1);
211 else
212 return -1;
214 break;
215 case 3:
216 if (last == '@') { /* Refname contains "@{". */
217 if (sanitized)
218 sanitized->buf[sanitized->len-1] = '-';
219 else
220 return -1;
222 break;
223 case 4:
224 /* forbidden char */
225 if (sanitized)
226 sanitized->buf[sanitized->len-1] = '-';
227 else
228 return -1;
229 break;
230 case 5:
231 if (!(*flags & REFNAME_REFSPEC_PATTERN)) {
232 /* refspec can't be a pattern */
233 if (sanitized)
234 sanitized->buf[sanitized->len-1] = '-';
235 else
236 return -1;
240 * Unset the pattern flag so that we only accept
241 * a single asterisk for one side of refspec.
243 *flags &= ~ REFNAME_REFSPEC_PATTERN;
244 break;
246 last = ch;
248 out:
249 if (cp == refname)
250 return 0; /* Component has zero length. */
252 if (refname[0] == '.') { /* Component starts with '.'. */
253 if (sanitized)
254 sanitized->buf[component_start] = '-';
255 else
256 return -1;
258 if (cp - refname >= LOCK_SUFFIX_LEN &&
259 !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN)) {
260 if (!sanitized)
261 return -1;
262 /* Refname ends with ".lock". */
263 while (strbuf_strip_suffix(sanitized, LOCK_SUFFIX)) {
264 /* try again in case we have .lock.lock */
267 return cp - refname;
270 static int check_or_sanitize_refname(const char *refname, int flags,
271 struct strbuf *sanitized)
273 int component_len, component_count = 0;
275 if (!strcmp(refname, "@")) {
276 /* Refname is a single character '@'. */
277 if (sanitized)
278 strbuf_addch(sanitized, '-');
279 else
280 return -1;
283 while (1) {
284 if (sanitized && sanitized->len)
285 strbuf_complete(sanitized, '/');
287 /* We are at the start of a path component. */
288 component_len = check_refname_component(refname, &flags,
289 sanitized);
290 if (sanitized && component_len == 0)
291 ; /* OK, omit empty component */
292 else if (component_len <= 0)
293 return -1;
295 component_count++;
296 if (refname[component_len] == '\0')
297 break;
298 /* Skip to next component. */
299 refname += component_len + 1;
302 if (refname[component_len - 1] == '.') {
303 /* Refname ends with '.'. */
304 if (sanitized)
305 ; /* omit ending dot */
306 else
307 return -1;
309 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
310 return -1; /* Refname has only one component. */
311 return 0;
314 int check_refname_format(const char *refname, int flags)
316 return check_or_sanitize_refname(refname, flags, NULL);
319 void sanitize_refname_component(const char *refname, struct strbuf *out)
321 if (check_or_sanitize_refname(refname, REFNAME_ALLOW_ONELEVEL, out))
322 BUG("sanitizing refname '%s' check returned error", refname);
325 int refname_is_safe(const char *refname)
327 const char *rest;
329 if (skip_prefix(refname, "refs/", &rest)) {
330 char *buf;
331 int result;
332 size_t restlen = strlen(rest);
334 /* rest must not be empty, or start or end with "/" */
335 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
336 return 0;
339 * Does the refname try to escape refs/?
340 * For example: refs/foo/../bar is safe but refs/foo/../../bar
341 * is not.
343 buf = xmallocz(restlen);
344 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
345 free(buf);
346 return result;
349 do {
350 if (!isupper(*refname) && *refname != '_')
351 return 0;
352 refname++;
353 } while (*refname);
354 return 1;
358 * Return true if refname, which has the specified oid and flags, can
359 * be resolved to an object in the database. If the referred-to object
360 * does not exist, emit a warning and return false.
362 int ref_resolves_to_object(const char *refname,
363 struct repository *repo,
364 const struct object_id *oid,
365 unsigned int flags)
367 if (flags & REF_ISBROKEN)
368 return 0;
369 if (!repo_has_object_file(repo, oid)) {
370 error(_("%s does not point to a valid object!"), refname);
371 return 0;
373 return 1;
376 char *refs_resolve_refdup(struct ref_store *refs,
377 const char *refname, int resolve_flags,
378 struct object_id *oid, int *flags)
380 const char *result;
382 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
383 oid, flags);
384 return xstrdup_or_null(result);
387 char *resolve_refdup(const char *refname, int resolve_flags,
388 struct object_id *oid, int *flags)
390 return refs_resolve_refdup(get_main_ref_store(the_repository),
391 refname, resolve_flags,
392 oid, flags);
395 /* The argument to for_each_filter_refs */
396 struct for_each_ref_filter {
397 const char *pattern;
398 const char *prefix;
399 each_ref_fn *fn;
400 void *cb_data;
403 int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags)
405 struct ref_store *refs = get_main_ref_store(the_repository);
407 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags,
408 oid, flags))
409 return 0;
410 return -1;
413 int read_ref(const char *refname, struct object_id *oid)
415 return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
418 int refs_ref_exists(struct ref_store *refs, const char *refname)
420 return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING,
421 NULL, NULL);
424 int ref_exists(const char *refname)
426 return refs_ref_exists(get_main_ref_store(the_repository), refname);
429 static int for_each_filter_refs(const char *refname,
430 const struct object_id *oid,
431 int flags, void *data)
433 struct for_each_ref_filter *filter = data;
435 if (wildmatch(filter->pattern, refname, 0))
436 return 0;
437 if (filter->prefix)
438 skip_prefix(refname, filter->prefix, &refname);
439 return filter->fn(refname, oid, flags, filter->cb_data);
442 enum peel_status peel_object(const struct object_id *name, struct object_id *oid)
444 struct object *o = lookup_unknown_object(the_repository, name);
446 if (o->type == OBJ_NONE) {
447 int type = oid_object_info(the_repository, name, NULL);
448 if (type < 0 || !object_as_type(o, type, 0))
449 return PEEL_INVALID;
452 if (o->type != OBJ_TAG)
453 return PEEL_NON_TAG;
455 o = deref_tag_noverify(o);
456 if (!o)
457 return PEEL_INVALID;
459 oidcpy(oid, &o->oid);
460 return PEEL_PEELED;
463 struct warn_if_dangling_data {
464 FILE *fp;
465 const char *refname;
466 const struct string_list *refnames;
467 const char *msg_fmt;
470 static int warn_if_dangling_symref(const char *refname,
471 const struct object_id *oid UNUSED,
472 int flags, void *cb_data)
474 struct warn_if_dangling_data *d = cb_data;
475 const char *resolves_to;
477 if (!(flags & REF_ISSYMREF))
478 return 0;
480 resolves_to = resolve_ref_unsafe(refname, 0, NULL, NULL);
481 if (!resolves_to
482 || (d->refname
483 ? strcmp(resolves_to, d->refname)
484 : !string_list_has_string(d->refnames, resolves_to))) {
485 return 0;
488 fprintf(d->fp, d->msg_fmt, refname);
489 fputc('\n', d->fp);
490 return 0;
493 void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
495 struct warn_if_dangling_data data;
497 data.fp = fp;
498 data.refname = refname;
499 data.refnames = NULL;
500 data.msg_fmt = msg_fmt;
501 for_each_rawref(warn_if_dangling_symref, &data);
504 void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
506 struct warn_if_dangling_data data;
508 data.fp = fp;
509 data.refname = NULL;
510 data.refnames = refnames;
511 data.msg_fmt = msg_fmt;
512 for_each_rawref(warn_if_dangling_symref, &data);
515 int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
517 return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
520 int for_each_tag_ref(each_ref_fn fn, void *cb_data)
522 return refs_for_each_tag_ref(get_main_ref_store(the_repository), fn, cb_data);
525 int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
527 return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
530 int for_each_branch_ref(each_ref_fn fn, void *cb_data)
532 return refs_for_each_branch_ref(get_main_ref_store(the_repository), fn, cb_data);
535 int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
537 return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
540 int for_each_remote_ref(each_ref_fn fn, void *cb_data)
542 return refs_for_each_remote_ref(get_main_ref_store(the_repository), fn, cb_data);
545 int head_ref_namespaced(each_ref_fn fn, void *cb_data)
547 struct strbuf buf = STRBUF_INIT;
548 int ret = 0;
549 struct object_id oid;
550 int flag;
552 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
553 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, &oid, &flag))
554 ret = fn(buf.buf, &oid, flag, cb_data);
555 strbuf_release(&buf);
557 return ret;
560 void normalize_glob_ref(struct string_list_item *item, const char *prefix,
561 const char *pattern)
563 struct strbuf normalized_pattern = STRBUF_INIT;
565 if (*pattern == '/')
566 BUG("pattern must not start with '/'");
568 if (prefix)
569 strbuf_addstr(&normalized_pattern, prefix);
570 else if (!starts_with(pattern, "refs/") &&
571 strcmp(pattern, "HEAD"))
572 strbuf_addstr(&normalized_pattern, "refs/");
574 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
575 * MERGE_HEAD, etc.
578 strbuf_addstr(&normalized_pattern, pattern);
579 strbuf_strip_suffix(&normalized_pattern, "/");
581 item->string = strbuf_detach(&normalized_pattern, NULL);
582 item->util = has_glob_specials(pattern) ? NULL : item->string;
583 strbuf_release(&normalized_pattern);
586 int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
587 const char *prefix, void *cb_data)
589 struct strbuf real_pattern = STRBUF_INIT;
590 struct for_each_ref_filter filter;
591 int ret;
593 if (!prefix && !starts_with(pattern, "refs/"))
594 strbuf_addstr(&real_pattern, "refs/");
595 else if (prefix)
596 strbuf_addstr(&real_pattern, prefix);
597 strbuf_addstr(&real_pattern, pattern);
599 if (!has_glob_specials(pattern)) {
600 /* Append implied '/' '*' if not present. */
601 strbuf_complete(&real_pattern, '/');
602 /* No need to check for '*', there is none. */
603 strbuf_addch(&real_pattern, '*');
606 filter.pattern = real_pattern.buf;
607 filter.prefix = prefix;
608 filter.fn = fn;
609 filter.cb_data = cb_data;
610 ret = for_each_ref(for_each_filter_refs, &filter);
612 strbuf_release(&real_pattern);
613 return ret;
616 int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
618 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
621 const char *prettify_refname(const char *name)
623 if (skip_prefix(name, "refs/heads/", &name) ||
624 skip_prefix(name, "refs/tags/", &name) ||
625 skip_prefix(name, "refs/remotes/", &name))
626 ; /* nothing */
627 return name;
630 static const char *ref_rev_parse_rules[] = {
631 "%.*s",
632 "refs/%.*s",
633 "refs/tags/%.*s",
634 "refs/heads/%.*s",
635 "refs/remotes/%.*s",
636 "refs/remotes/%.*s/HEAD",
637 NULL
640 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
643 * Is it possible that the caller meant full_name with abbrev_name?
644 * If so return a non-zero value to signal "yes"; the magnitude of
645 * the returned value gives the precedence used for disambiguation.
647 * If abbrev_name cannot mean full_name, return 0.
649 int refname_match(const char *abbrev_name, const char *full_name)
651 const char **p;
652 const int abbrev_name_len = strlen(abbrev_name);
653 const int num_rules = NUM_REV_PARSE_RULES;
655 for (p = ref_rev_parse_rules; *p; p++)
656 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name)))
657 return &ref_rev_parse_rules[num_rules] - p;
659 return 0;
663 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
664 * the results to 'prefixes'
666 void expand_ref_prefix(struct strvec *prefixes, const char *prefix)
668 const char **p;
669 int len = strlen(prefix);
671 for (p = ref_rev_parse_rules; *p; p++)
672 strvec_pushf(prefixes, *p, len, prefix);
675 static const char default_branch_name_advice[] = N_(
676 "Using '%s' as the name for the initial branch. This default branch name\n"
677 "is subject to change. To configure the initial branch name to use in all\n"
678 "of your new repositories, which will suppress this warning, call:\n"
679 "\n"
680 "\tgit config --global init.defaultBranch <name>\n"
681 "\n"
682 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
683 "'development'. The just-created branch can be renamed via this command:\n"
684 "\n"
685 "\tgit branch -m <name>\n"
688 char *repo_default_branch_name(struct repository *r, int quiet)
690 const char *config_key = "init.defaultbranch";
691 const char *config_display_key = "init.defaultBranch";
692 char *ret = NULL, *full_ref;
693 const char *env = getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
695 if (env && *env)
696 ret = xstrdup(env);
697 else if (repo_config_get_string(r, config_key, &ret) < 0)
698 die(_("could not retrieve `%s`"), config_display_key);
700 if (!ret) {
701 ret = xstrdup("master");
702 if (!quiet)
703 advise(_(default_branch_name_advice), ret);
706 full_ref = xstrfmt("refs/heads/%s", ret);
707 if (check_refname_format(full_ref, 0))
708 die(_("invalid branch name: %s = %s"), config_display_key, ret);
709 free(full_ref);
711 return ret;
714 const char *git_default_branch_name(int quiet)
716 static char *ret;
718 if (!ret)
719 ret = repo_default_branch_name(the_repository, quiet);
721 return ret;
725 * *string and *len will only be substituted, and *string returned (for
726 * later free()ing) if the string passed in is a magic short-hand form
727 * to name a branch.
729 static char *substitute_branch_name(struct repository *r,
730 const char **string, int *len,
731 int nonfatal_dangling_mark)
733 struct strbuf buf = STRBUF_INIT;
734 struct interpret_branch_name_options options = {
735 .nonfatal_dangling_mark = nonfatal_dangling_mark
737 int ret = repo_interpret_branch_name(r, *string, *len, &buf, &options);
739 if (ret == *len) {
740 size_t size;
741 *string = strbuf_detach(&buf, &size);
742 *len = size;
743 return (char *)*string;
746 return NULL;
749 int repo_dwim_ref(struct repository *r, const char *str, int len,
750 struct object_id *oid, char **ref, int nonfatal_dangling_mark)
752 char *last_branch = substitute_branch_name(r, &str, &len,
753 nonfatal_dangling_mark);
754 int refs_found = expand_ref(r, str, len, oid, ref);
755 free(last_branch);
756 return refs_found;
759 int expand_ref(struct repository *repo, const char *str, int len,
760 struct object_id *oid, char **ref)
762 const char **p, *r;
763 int refs_found = 0;
764 struct strbuf fullref = STRBUF_INIT;
766 *ref = NULL;
767 for (p = ref_rev_parse_rules; *p; p++) {
768 struct object_id oid_from_ref;
769 struct object_id *this_result;
770 int flag;
771 struct ref_store *refs = get_main_ref_store(repo);
773 this_result = refs_found ? &oid_from_ref : oid;
774 strbuf_reset(&fullref);
775 strbuf_addf(&fullref, *p, len, str);
776 r = refs_resolve_ref_unsafe(refs, fullref.buf,
777 RESOLVE_REF_READING,
778 this_result, &flag);
779 if (r) {
780 if (!refs_found++)
781 *ref = xstrdup(r);
782 if (!warn_ambiguous_refs)
783 break;
784 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
785 warning(_("ignoring dangling symref %s"), fullref.buf);
786 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
787 warning(_("ignoring broken ref %s"), fullref.buf);
790 strbuf_release(&fullref);
791 return refs_found;
794 int repo_dwim_log(struct repository *r, const char *str, int len,
795 struct object_id *oid, char **log)
797 struct ref_store *refs = get_main_ref_store(r);
798 char *last_branch = substitute_branch_name(r, &str, &len, 0);
799 const char **p;
800 int logs_found = 0;
801 struct strbuf path = STRBUF_INIT;
803 *log = NULL;
804 for (p = ref_rev_parse_rules; *p; p++) {
805 struct object_id hash;
806 const char *ref, *it;
808 strbuf_reset(&path);
809 strbuf_addf(&path, *p, len, str);
810 ref = refs_resolve_ref_unsafe(refs, path.buf,
811 RESOLVE_REF_READING,
812 oid ? &hash : NULL, NULL);
813 if (!ref)
814 continue;
815 if (refs_reflog_exists(refs, path.buf))
816 it = path.buf;
817 else if (strcmp(ref, path.buf) &&
818 refs_reflog_exists(refs, ref))
819 it = ref;
820 else
821 continue;
822 if (!logs_found++) {
823 *log = xstrdup(it);
824 if (oid)
825 oidcpy(oid, &hash);
827 if (!warn_ambiguous_refs)
828 break;
830 strbuf_release(&path);
831 free(last_branch);
832 return logs_found;
835 int dwim_log(const char *str, int len, struct object_id *oid, char **log)
837 return repo_dwim_log(the_repository, str, len, oid, log);
840 int is_per_worktree_ref(const char *refname)
842 return starts_with(refname, "refs/worktree/") ||
843 starts_with(refname, "refs/bisect/") ||
844 starts_with(refname, "refs/rewritten/");
847 static int is_pseudoref_syntax(const char *refname)
849 const char *c;
851 for (c = refname; *c; c++) {
852 if (!isupper(*c) && *c != '-' && *c != '_')
853 return 0;
857 * HEAD is not a pseudoref, but it certainly uses the
858 * pseudoref syntax.
860 return 1;
863 int is_pseudoref(struct ref_store *refs, const char *refname)
865 static const char *const irregular_pseudorefs[] = {
866 "AUTO_MERGE",
867 "BISECT_EXPECTED_REV",
868 "NOTES_MERGE_PARTIAL",
869 "NOTES_MERGE_REF",
870 "MERGE_AUTOSTASH",
872 struct object_id oid;
873 size_t i;
875 if (!is_pseudoref_syntax(refname))
876 return 0;
878 if (ends_with(refname, "_HEAD")) {
879 refs_resolve_ref_unsafe(refs, refname,
880 RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,
881 &oid, NULL);
882 return !is_null_oid(&oid);
885 for (i = 0; i < ARRAY_SIZE(irregular_pseudorefs); i++)
886 if (!strcmp(refname, irregular_pseudorefs[i])) {
887 refs_resolve_ref_unsafe(refs, refname,
888 RESOLVE_REF_READING | RESOLVE_REF_NO_RECURSE,
889 &oid, NULL);
890 return !is_null_oid(&oid);
893 return 0;
896 int is_headref(struct ref_store *refs, const char *refname)
898 if (!strcmp(refname, "HEAD"))
899 return refs_ref_exists(refs, refname);
901 return 0;
904 static int is_current_worktree_ref(const char *ref) {
905 return is_pseudoref_syntax(ref) || is_per_worktree_ref(ref);
908 enum ref_worktree_type parse_worktree_ref(const char *maybe_worktree_ref,
909 const char **worktree_name, int *worktree_name_length,
910 const char **bare_refname)
912 const char *name_dummy;
913 int name_length_dummy;
914 const char *ref_dummy;
916 if (!worktree_name)
917 worktree_name = &name_dummy;
918 if (!worktree_name_length)
919 worktree_name_length = &name_length_dummy;
920 if (!bare_refname)
921 bare_refname = &ref_dummy;
923 if (skip_prefix(maybe_worktree_ref, "worktrees/", bare_refname)) {
924 const char *slash = strchr(*bare_refname, '/');
926 *worktree_name = *bare_refname;
927 if (!slash) {
928 *worktree_name_length = strlen(*worktree_name);
930 /* This is an error condition, and the caller tell because the bare_refname is "" */
931 *bare_refname = *worktree_name + *worktree_name_length;
932 return REF_WORKTREE_OTHER;
935 *worktree_name_length = slash - *bare_refname;
936 *bare_refname = slash + 1;
938 if (is_current_worktree_ref(*bare_refname))
939 return REF_WORKTREE_OTHER;
942 *worktree_name = NULL;
943 *worktree_name_length = 0;
945 if (skip_prefix(maybe_worktree_ref, "main-worktree/", bare_refname)
946 && is_current_worktree_ref(*bare_refname))
947 return REF_WORKTREE_MAIN;
949 *bare_refname = maybe_worktree_ref;
950 if (is_current_worktree_ref(maybe_worktree_ref))
951 return REF_WORKTREE_CURRENT;
953 return REF_WORKTREE_SHARED;
956 long get_files_ref_lock_timeout_ms(void)
958 static int configured = 0;
960 /* The default timeout is 100 ms: */
961 static int timeout_ms = 100;
963 if (!configured) {
964 git_config_get_int("core.filesreflocktimeout", &timeout_ms);
965 configured = 1;
968 return timeout_ms;
971 int refs_delete_ref(struct ref_store *refs, const char *msg,
972 const char *refname,
973 const struct object_id *old_oid,
974 unsigned int flags)
976 struct ref_transaction *transaction;
977 struct strbuf err = STRBUF_INIT;
979 transaction = ref_store_transaction_begin(refs, &err);
980 if (!transaction ||
981 ref_transaction_delete(transaction, refname, old_oid,
982 flags, msg, &err) ||
983 ref_transaction_commit(transaction, &err)) {
984 error("%s", err.buf);
985 ref_transaction_free(transaction);
986 strbuf_release(&err);
987 return 1;
989 ref_transaction_free(transaction);
990 strbuf_release(&err);
991 return 0;
994 int delete_ref(const char *msg, const char *refname,
995 const struct object_id *old_oid, unsigned int flags)
997 return refs_delete_ref(get_main_ref_store(the_repository), msg, refname,
998 old_oid, flags);
1001 static void copy_reflog_msg(struct strbuf *sb, const char *msg)
1003 char c;
1004 int wasspace = 1;
1006 while ((c = *msg++)) {
1007 if (wasspace && isspace(c))
1008 continue;
1009 wasspace = isspace(c);
1010 if (wasspace)
1011 c = ' ';
1012 strbuf_addch(sb, c);
1014 strbuf_rtrim(sb);
1017 static char *normalize_reflog_message(const char *msg)
1019 struct strbuf sb = STRBUF_INIT;
1021 if (msg && *msg)
1022 copy_reflog_msg(&sb, msg);
1023 return strbuf_detach(&sb, NULL);
1026 int should_autocreate_reflog(const char *refname)
1028 switch (log_all_ref_updates) {
1029 case LOG_REFS_ALWAYS:
1030 return 1;
1031 case LOG_REFS_NORMAL:
1032 return starts_with(refname, "refs/heads/") ||
1033 starts_with(refname, "refs/remotes/") ||
1034 starts_with(refname, "refs/notes/") ||
1035 !strcmp(refname, "HEAD");
1036 default:
1037 return 0;
1041 int is_branch(const char *refname)
1043 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
1046 struct read_ref_at_cb {
1047 const char *refname;
1048 timestamp_t at_time;
1049 int cnt;
1050 int reccnt;
1051 struct object_id *oid;
1052 int found_it;
1054 struct object_id ooid;
1055 struct object_id noid;
1056 int tz;
1057 timestamp_t date;
1058 char **msg;
1059 timestamp_t *cutoff_time;
1060 int *cutoff_tz;
1061 int *cutoff_cnt;
1064 static void set_read_ref_cutoffs(struct read_ref_at_cb *cb,
1065 timestamp_t timestamp, int tz, const char *message)
1067 if (cb->msg)
1068 *cb->msg = xstrdup(message);
1069 if (cb->cutoff_time)
1070 *cb->cutoff_time = timestamp;
1071 if (cb->cutoff_tz)
1072 *cb->cutoff_tz = tz;
1073 if (cb->cutoff_cnt)
1074 *cb->cutoff_cnt = cb->reccnt;
1077 static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
1078 const char *email UNUSED,
1079 timestamp_t timestamp, int tz,
1080 const char *message, void *cb_data)
1082 struct read_ref_at_cb *cb = cb_data;
1084 cb->tz = tz;
1085 cb->date = timestamp;
1087 if (timestamp <= cb->at_time || cb->cnt == 0) {
1088 set_read_ref_cutoffs(cb, timestamp, tz, message);
1090 * we have not yet updated cb->[n|o]oid so they still
1091 * hold the values for the previous record.
1093 if (!is_null_oid(&cb->ooid)) {
1094 oidcpy(cb->oid, noid);
1095 if (!oideq(&cb->ooid, noid))
1096 warning(_("log for ref %s has gap after %s"),
1097 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
1099 else if (cb->date == cb->at_time)
1100 oidcpy(cb->oid, noid);
1101 else if (!oideq(noid, cb->oid))
1102 warning(_("log for ref %s unexpectedly ended on %s"),
1103 cb->refname, show_date(cb->date, cb->tz,
1104 DATE_MODE(RFC2822)));
1105 cb->reccnt++;
1106 oidcpy(&cb->ooid, ooid);
1107 oidcpy(&cb->noid, noid);
1108 cb->found_it = 1;
1109 return 1;
1111 cb->reccnt++;
1112 oidcpy(&cb->ooid, ooid);
1113 oidcpy(&cb->noid, noid);
1114 if (cb->cnt > 0)
1115 cb->cnt--;
1116 return 0;
1119 static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
1120 const char *email UNUSED,
1121 timestamp_t timestamp, int tz,
1122 const char *message, void *cb_data)
1124 struct read_ref_at_cb *cb = cb_data;
1126 set_read_ref_cutoffs(cb, timestamp, tz, message);
1127 oidcpy(cb->oid, ooid);
1128 if (cb->at_time && is_null_oid(cb->oid))
1129 oidcpy(cb->oid, noid);
1130 /* We just want the first entry */
1131 return 1;
1134 int read_ref_at(struct ref_store *refs, const char *refname,
1135 unsigned int flags, timestamp_t at_time, int cnt,
1136 struct object_id *oid, char **msg,
1137 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
1139 struct read_ref_at_cb cb;
1141 memset(&cb, 0, sizeof(cb));
1142 cb.refname = refname;
1143 cb.at_time = at_time;
1144 cb.cnt = cnt;
1145 cb.msg = msg;
1146 cb.cutoff_time = cutoff_time;
1147 cb.cutoff_tz = cutoff_tz;
1148 cb.cutoff_cnt = cutoff_cnt;
1149 cb.oid = oid;
1151 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
1153 if (!cb.reccnt) {
1154 if (cnt == 0) {
1156 * The caller asked for ref@{0}, and we had no entries.
1157 * It's a bit subtle, but in practice all callers have
1158 * prepped the "oid" field with the current value of
1159 * the ref, which is the most reasonable fallback.
1161 * We'll put dummy values into the out-parameters (so
1162 * they're not just uninitialized garbage), and the
1163 * caller can take our return value as a hint that
1164 * we did not find any such reflog.
1166 set_read_ref_cutoffs(&cb, 0, 0, "empty reflog");
1167 return 1;
1169 if (flags & GET_OID_QUIETLY)
1170 exit(128);
1171 else
1172 die(_("log for %s is empty"), refname);
1174 if (cb.found_it)
1175 return 0;
1177 refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
1179 return 1;
1182 struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
1183 struct strbuf *err)
1185 struct ref_transaction *tr;
1186 assert(err);
1188 CALLOC_ARRAY(tr, 1);
1189 tr->ref_store = refs;
1190 return tr;
1193 struct ref_transaction *ref_transaction_begin(struct strbuf *err)
1195 return ref_store_transaction_begin(get_main_ref_store(the_repository), err);
1198 void ref_transaction_free(struct ref_transaction *transaction)
1200 size_t i;
1202 if (!transaction)
1203 return;
1205 switch (transaction->state) {
1206 case REF_TRANSACTION_OPEN:
1207 case REF_TRANSACTION_CLOSED:
1208 /* OK */
1209 break;
1210 case REF_TRANSACTION_PREPARED:
1211 BUG("free called on a prepared reference transaction");
1212 break;
1213 default:
1214 BUG("unexpected reference transaction state");
1215 break;
1218 for (i = 0; i < transaction->nr; i++) {
1219 free(transaction->updates[i]->msg);
1220 free(transaction->updates[i]);
1222 free(transaction->updates);
1223 free(transaction);
1226 struct ref_update *ref_transaction_add_update(
1227 struct ref_transaction *transaction,
1228 const char *refname, unsigned int flags,
1229 const struct object_id *new_oid,
1230 const struct object_id *old_oid,
1231 const char *msg)
1233 struct ref_update *update;
1235 if (transaction->state != REF_TRANSACTION_OPEN)
1236 BUG("update called for transaction that is not open");
1238 FLEX_ALLOC_STR(update, refname, refname);
1239 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
1240 transaction->updates[transaction->nr++] = update;
1242 update->flags = flags;
1244 if (flags & REF_HAVE_NEW)
1245 oidcpy(&update->new_oid, new_oid);
1246 if (flags & REF_HAVE_OLD)
1247 oidcpy(&update->old_oid, old_oid);
1248 update->msg = normalize_reflog_message(msg);
1249 return update;
1252 int ref_transaction_update(struct ref_transaction *transaction,
1253 const char *refname,
1254 const struct object_id *new_oid,
1255 const struct object_id *old_oid,
1256 unsigned int flags, const char *msg,
1257 struct strbuf *err)
1259 assert(err);
1261 if (!(flags & REF_SKIP_REFNAME_VERIFICATION) &&
1262 ((new_oid && !is_null_oid(new_oid)) ?
1263 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
1264 !refname_is_safe(refname))) {
1265 strbuf_addf(err, _("refusing to update ref with bad name '%s'"),
1266 refname);
1267 return -1;
1270 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
1271 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
1274 * Clear flags outside the allowed set; this should be a noop because
1275 * of the BUG() check above, but it works around a -Wnonnull warning
1276 * with some versions of "gcc -O3".
1278 flags &= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS;
1280 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
1282 ref_transaction_add_update(transaction, refname, flags,
1283 new_oid, old_oid, msg);
1284 return 0;
1287 int ref_transaction_create(struct ref_transaction *transaction,
1288 const char *refname,
1289 const struct object_id *new_oid,
1290 unsigned int flags, const char *msg,
1291 struct strbuf *err)
1293 if (!new_oid || is_null_oid(new_oid)) {
1294 strbuf_addf(err, "'%s' has a null OID", refname);
1295 return 1;
1297 return ref_transaction_update(transaction, refname, new_oid,
1298 null_oid(), flags, msg, err);
1301 int ref_transaction_delete(struct ref_transaction *transaction,
1302 const char *refname,
1303 const struct object_id *old_oid,
1304 unsigned int flags, const char *msg,
1305 struct strbuf *err)
1307 if (old_oid && is_null_oid(old_oid))
1308 BUG("delete called with old_oid set to zeros");
1309 return ref_transaction_update(transaction, refname,
1310 null_oid(), old_oid,
1311 flags, msg, err);
1314 int ref_transaction_verify(struct ref_transaction *transaction,
1315 const char *refname,
1316 const struct object_id *old_oid,
1317 unsigned int flags,
1318 struct strbuf *err)
1320 if (!old_oid)
1321 BUG("verify called with old_oid set to NULL");
1322 return ref_transaction_update(transaction, refname,
1323 NULL, old_oid,
1324 flags, NULL, err);
1327 int refs_update_ref(struct ref_store *refs, const char *msg,
1328 const char *refname, const struct object_id *new_oid,
1329 const struct object_id *old_oid, unsigned int flags,
1330 enum action_on_err onerr)
1332 struct ref_transaction *t = NULL;
1333 struct strbuf err = STRBUF_INIT;
1334 int ret = 0;
1336 t = ref_store_transaction_begin(refs, &err);
1337 if (!t ||
1338 ref_transaction_update(t, refname, new_oid, old_oid, flags, msg,
1339 &err) ||
1340 ref_transaction_commit(t, &err)) {
1341 ret = 1;
1342 ref_transaction_free(t);
1344 if (ret) {
1345 const char *str = _("update_ref failed for ref '%s': %s");
1347 switch (onerr) {
1348 case UPDATE_REFS_MSG_ON_ERR:
1349 error(str, refname, err.buf);
1350 break;
1351 case UPDATE_REFS_DIE_ON_ERR:
1352 die(str, refname, err.buf);
1353 break;
1354 case UPDATE_REFS_QUIET_ON_ERR:
1355 break;
1357 strbuf_release(&err);
1358 return 1;
1360 strbuf_release(&err);
1361 if (t)
1362 ref_transaction_free(t);
1363 return 0;
1366 int update_ref(const char *msg, const char *refname,
1367 const struct object_id *new_oid,
1368 const struct object_id *old_oid,
1369 unsigned int flags, enum action_on_err onerr)
1371 return refs_update_ref(get_main_ref_store(the_repository), msg, refname, new_oid,
1372 old_oid, flags, onerr);
1376 * Check that the string refname matches a rule of the form
1377 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1378 * "foo/%.*s/baz", and return the string "bar".
1380 static const char *match_parse_rule(const char *refname, const char *rule,
1381 size_t *len)
1384 * Check that rule matches refname up to the first percent in the rule.
1385 * We can bail immediately if not, but otherwise we leave "rule" at the
1386 * %-placeholder, and "refname" at the start of the potential matched
1387 * name.
1389 while (*rule != '%') {
1390 if (!*rule)
1391 BUG("rev-parse rule did not have percent");
1392 if (*refname++ != *rule++)
1393 return NULL;
1397 * Check that our "%" is the expected placeholder. This assumes there
1398 * are no other percents (placeholder or quoted) in the string, but
1399 * that is sufficient for our rev-parse rules.
1401 if (!skip_prefix(rule, "%.*s", &rule))
1402 return NULL;
1405 * And now check that our suffix (if any) matches.
1407 if (!strip_suffix(refname, rule, len))
1408 return NULL;
1410 return refname; /* len set by strip_suffix() */
1413 char *refs_shorten_unambiguous_ref(struct ref_store *refs,
1414 const char *refname, int strict)
1416 int i;
1417 struct strbuf resolved_buf = STRBUF_INIT;
1419 /* skip first rule, it will always match */
1420 for (i = NUM_REV_PARSE_RULES - 1; i > 0 ; --i) {
1421 int j;
1422 int rules_to_fail = i;
1423 const char *short_name;
1424 size_t short_name_len;
1426 short_name = match_parse_rule(refname, ref_rev_parse_rules[i],
1427 &short_name_len);
1428 if (!short_name)
1429 continue;
1432 * in strict mode, all (except the matched one) rules
1433 * must fail to resolve to a valid non-ambiguous ref
1435 if (strict)
1436 rules_to_fail = NUM_REV_PARSE_RULES;
1439 * check if the short name resolves to a valid ref,
1440 * but use only rules prior to the matched one
1442 for (j = 0; j < rules_to_fail; j++) {
1443 const char *rule = ref_rev_parse_rules[j];
1445 /* skip matched rule */
1446 if (i == j)
1447 continue;
1450 * the short name is ambiguous, if it resolves
1451 * (with this previous rule) to a valid ref
1452 * read_ref() returns 0 on success
1454 strbuf_reset(&resolved_buf);
1455 strbuf_addf(&resolved_buf, rule,
1456 cast_size_t_to_int(short_name_len),
1457 short_name);
1458 if (refs_ref_exists(refs, resolved_buf.buf))
1459 break;
1463 * short name is non-ambiguous if all previous rules
1464 * haven't resolved to a valid ref
1466 if (j == rules_to_fail) {
1467 strbuf_release(&resolved_buf);
1468 return xmemdupz(short_name, short_name_len);
1472 strbuf_release(&resolved_buf);
1473 return xstrdup(refname);
1476 char *shorten_unambiguous_ref(const char *refname, int strict)
1478 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
1479 refname, strict);
1482 int parse_hide_refs_config(const char *var, const char *value, const char *section,
1483 struct strvec *hide_refs)
1485 const char *key;
1486 if (!strcmp("transfer.hiderefs", var) ||
1487 (!parse_config_key(var, section, NULL, NULL, &key) &&
1488 !strcmp(key, "hiderefs"))) {
1489 char *ref;
1490 int len;
1492 if (!value)
1493 return config_error_nonbool(var);
1495 /* drop const to remove trailing '/' characters */
1496 ref = (char *)strvec_push(hide_refs, value);
1497 len = strlen(ref);
1498 while (len && ref[len - 1] == '/')
1499 ref[--len] = '\0';
1501 return 0;
1504 int ref_is_hidden(const char *refname, const char *refname_full,
1505 const struct strvec *hide_refs)
1507 int i;
1509 for (i = hide_refs->nr - 1; i >= 0; i--) {
1510 const char *match = hide_refs->v[i];
1511 const char *subject;
1512 int neg = 0;
1513 const char *p;
1515 if (*match == '!') {
1516 neg = 1;
1517 match++;
1520 if (*match == '^') {
1521 subject = refname_full;
1522 match++;
1523 } else {
1524 subject = refname;
1527 /* refname can be NULL when namespaces are used. */
1528 if (subject &&
1529 skip_prefix(subject, match, &p) &&
1530 (!*p || *p == '/'))
1531 return !neg;
1533 return 0;
1536 const char **hidden_refs_to_excludes(const struct strvec *hide_refs)
1538 const char **pattern;
1539 for (pattern = hide_refs->v; *pattern; pattern++) {
1541 * We can't feed any excludes from hidden refs config
1542 * sections, since later rules may override previous
1543 * ones. For example, with rules "refs/foo" and
1544 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1545 * everything underneath it), but the earlier exclusion
1546 * would cause us to skip all of "refs/foo". We
1547 * likewise don't implement the namespace stripping
1548 * required for '^' rules.
1550 * Both are possible to do, but complicated, so avoid
1551 * populating the jump list at all if we see either of
1552 * these patterns.
1554 if (**pattern == '!' || **pattern == '^')
1555 return NULL;
1557 return hide_refs->v;
1560 const char *find_descendant_ref(const char *dirname,
1561 const struct string_list *extras,
1562 const struct string_list *skip)
1564 int pos;
1566 if (!extras)
1567 return NULL;
1570 * Look at the place where dirname would be inserted into
1571 * extras. If there is an entry at that position that starts
1572 * with dirname (remember, dirname includes the trailing
1573 * slash) and is not in skip, then we have a conflict.
1575 for (pos = string_list_find_insert_index(extras, dirname, 0);
1576 pos < extras->nr; pos++) {
1577 const char *extra_refname = extras->items[pos].string;
1579 if (!starts_with(extra_refname, dirname))
1580 break;
1582 if (!skip || !string_list_has_string(skip, extra_refname))
1583 return extra_refname;
1585 return NULL;
1588 int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1590 struct object_id oid;
1591 int flag;
1593 if (refs_resolve_ref_unsafe(refs, "HEAD", RESOLVE_REF_READING,
1594 &oid, &flag))
1595 return fn("HEAD", &oid, flag, cb_data);
1597 return 0;
1600 int head_ref(each_ref_fn fn, void *cb_data)
1602 return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
1605 struct ref_iterator *refs_ref_iterator_begin(
1606 struct ref_store *refs,
1607 const char *prefix,
1608 const char **exclude_patterns,
1609 int trim,
1610 enum do_for_each_ref_flags flags)
1612 struct ref_iterator *iter;
1614 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
1615 static int ref_paranoia = -1;
1617 if (ref_paranoia < 0)
1618 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 1);
1619 if (ref_paranoia) {
1620 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1621 flags |= DO_FOR_EACH_OMIT_DANGLING_SYMREFS;
1625 iter = refs->be->iterator_begin(refs, prefix, exclude_patterns, flags);
1627 * `iterator_begin()` already takes care of prefix, but we
1628 * might need to do some trimming:
1630 if (trim)
1631 iter = prefix_ref_iterator_begin(iter, "", trim);
1633 return iter;
1637 * Call fn for each reference in the specified submodule for which the
1638 * refname begins with prefix. If trim is non-zero, then trim that
1639 * many characters off the beginning of each refname before passing
1640 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1641 * include broken references in the iteration. If fn ever returns a
1642 * non-zero value, stop the iteration and return that value;
1643 * otherwise, return 0.
1645 static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1646 each_repo_ref_fn fn, int trim, int flags,
1647 void *cb_data)
1649 struct ref_iterator *iter;
1650 struct ref_store *refs = get_main_ref_store(r);
1652 if (!refs)
1653 return 0;
1655 iter = refs_ref_iterator_begin(refs, prefix, NULL, trim, flags);
1657 return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1660 struct do_for_each_ref_help {
1661 each_ref_fn *fn;
1662 void *cb_data;
1665 static int do_for_each_ref_helper(struct repository *r UNUSED,
1666 const char *refname,
1667 const struct object_id *oid,
1668 int flags,
1669 void *cb_data)
1671 struct do_for_each_ref_help *hp = cb_data;
1673 return hp->fn(refname, oid, flags, hp->cb_data);
1676 static int do_for_each_ref(struct ref_store *refs, const char *prefix,
1677 const char **exclude_patterns,
1678 each_ref_fn fn, int trim,
1679 enum do_for_each_ref_flags flags, void *cb_data)
1681 struct ref_iterator *iter;
1682 struct do_for_each_ref_help hp = { fn, cb_data };
1684 if (!refs)
1685 return 0;
1687 iter = refs_ref_iterator_begin(refs, prefix, exclude_patterns, trim,
1688 flags);
1690 return do_for_each_repo_ref_iterator(the_repository, iter,
1691 do_for_each_ref_helper, &hp);
1694 int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1696 return do_for_each_ref(refs, "", NULL, fn, 0, 0, cb_data);
1699 int for_each_ref(each_ref_fn fn, void *cb_data)
1701 return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
1704 int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1705 each_ref_fn fn, void *cb_data)
1707 return do_for_each_ref(refs, prefix, NULL, fn, strlen(prefix), 0, cb_data);
1710 int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1712 return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
1715 int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1717 return do_for_each_ref(get_main_ref_store(the_repository),
1718 prefix, NULL, fn, 0, 0, cb_data);
1721 int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
1722 const char **exclude_patterns,
1723 each_ref_fn fn, void *cb_data)
1725 return do_for_each_ref(refs, prefix, exclude_patterns, fn, 0, 0, cb_data);
1728 int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
1730 const char *git_replace_ref_base = ref_namespace[NAMESPACE_REPLACE].ref;
1731 return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1732 strlen(git_replace_ref_base),
1733 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1736 int for_each_namespaced_ref(const char **exclude_patterns,
1737 each_ref_fn fn, void *cb_data)
1739 struct strbuf buf = STRBUF_INIT;
1740 int ret;
1741 strbuf_addf(&buf, "%srefs/", get_git_namespace());
1742 ret = do_for_each_ref(get_main_ref_store(the_repository),
1743 buf.buf, exclude_patterns, fn, 0, 0, cb_data);
1744 strbuf_release(&buf);
1745 return ret;
1748 int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1750 return do_for_each_ref(refs, "", NULL, fn, 0,
1751 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1754 int for_each_rawref(each_ref_fn fn, void *cb_data)
1756 return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
1759 int refs_for_each_include_root_refs(struct ref_store *refs, each_ref_fn fn,
1760 void *cb_data)
1762 return do_for_each_ref(refs, "", NULL, fn, 0,
1763 DO_FOR_EACH_INCLUDE_ROOT_REFS, cb_data);
1766 static int qsort_strcmp(const void *va, const void *vb)
1768 const char *a = *(const char **)va;
1769 const char *b = *(const char **)vb;
1771 return strcmp(a, b);
1774 static void find_longest_prefixes_1(struct string_list *out,
1775 struct strbuf *prefix,
1776 const char **patterns, size_t nr)
1778 size_t i;
1780 for (i = 0; i < nr; i++) {
1781 char c = patterns[i][prefix->len];
1782 if (!c || is_glob_special(c)) {
1783 string_list_append(out, prefix->buf);
1784 return;
1788 i = 0;
1789 while (i < nr) {
1790 size_t end;
1793 * Set "end" to the index of the element _after_ the last one
1794 * in our group.
1796 for (end = i + 1; end < nr; end++) {
1797 if (patterns[i][prefix->len] != patterns[end][prefix->len])
1798 break;
1801 strbuf_addch(prefix, patterns[i][prefix->len]);
1802 find_longest_prefixes_1(out, prefix, patterns + i, end - i);
1803 strbuf_setlen(prefix, prefix->len - 1);
1805 i = end;
1809 static void find_longest_prefixes(struct string_list *out,
1810 const char **patterns)
1812 struct strvec sorted = STRVEC_INIT;
1813 struct strbuf prefix = STRBUF_INIT;
1815 strvec_pushv(&sorted, patterns);
1816 QSORT(sorted.v, sorted.nr, qsort_strcmp);
1818 find_longest_prefixes_1(out, &prefix, sorted.v, sorted.nr);
1820 strvec_clear(&sorted);
1821 strbuf_release(&prefix);
1824 int refs_for_each_fullref_in_prefixes(struct ref_store *ref_store,
1825 const char *namespace,
1826 const char **patterns,
1827 const char **exclude_patterns,
1828 each_ref_fn fn, void *cb_data)
1830 struct string_list prefixes = STRING_LIST_INIT_DUP;
1831 struct string_list_item *prefix;
1832 struct strbuf buf = STRBUF_INIT;
1833 int ret = 0, namespace_len;
1835 find_longest_prefixes(&prefixes, patterns);
1837 if (namespace)
1838 strbuf_addstr(&buf, namespace);
1839 namespace_len = buf.len;
1841 for_each_string_list_item(prefix, &prefixes) {
1842 strbuf_addstr(&buf, prefix->string);
1843 ret = refs_for_each_fullref_in(ref_store, buf.buf,
1844 exclude_patterns, fn, cb_data);
1845 if (ret)
1846 break;
1847 strbuf_setlen(&buf, namespace_len);
1850 string_list_clear(&prefixes, 0);
1851 strbuf_release(&buf);
1852 return ret;
1855 static int refs_read_special_head(struct ref_store *ref_store,
1856 const char *refname, struct object_id *oid,
1857 struct strbuf *referent, unsigned int *type,
1858 int *failure_errno)
1860 struct strbuf full_path = STRBUF_INIT;
1861 struct strbuf content = STRBUF_INIT;
1862 int result = -1;
1863 strbuf_addf(&full_path, "%s/%s", ref_store->gitdir, refname);
1865 if (strbuf_read_file(&content, full_path.buf, 0) < 0) {
1866 *failure_errno = errno;
1867 goto done;
1870 result = parse_loose_ref_contents(content.buf, oid, referent, type,
1871 failure_errno);
1873 done:
1874 strbuf_release(&full_path);
1875 strbuf_release(&content);
1876 return result;
1879 static int is_special_ref(const char *refname)
1882 * Special references are refs that have different semantics compared
1883 * to "normal" refs. These refs can thus not be stored in the ref
1884 * backend, but must always be accessed via the filesystem. The
1885 * following refs are special:
1887 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1888 * carries additional metadata like where it came from.
1890 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1891 * heads.
1893 * Reading, writing or deleting references must consistently go either
1894 * through the filesystem (special refs) or through the reference
1895 * backend (normal ones).
1897 static const char * const special_refs[] = {
1898 "FETCH_HEAD",
1899 "MERGE_HEAD",
1901 size_t i;
1903 for (i = 0; i < ARRAY_SIZE(special_refs); i++)
1904 if (!strcmp(refname, special_refs[i]))
1905 return 1;
1907 return 0;
1910 int refs_read_raw_ref(struct ref_store *ref_store, const char *refname,
1911 struct object_id *oid, struct strbuf *referent,
1912 unsigned int *type, int *failure_errno)
1914 assert(failure_errno);
1915 if (is_special_ref(refname))
1916 return refs_read_special_head(ref_store, refname, oid, referent,
1917 type, failure_errno);
1919 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent,
1920 type, failure_errno);
1923 int refs_read_symbolic_ref(struct ref_store *ref_store, const char *refname,
1924 struct strbuf *referent)
1926 return ref_store->be->read_symbolic_ref(ref_store, refname, referent);
1929 const char *refs_resolve_ref_unsafe(struct ref_store *refs,
1930 const char *refname,
1931 int resolve_flags,
1932 struct object_id *oid,
1933 int *flags)
1935 static struct strbuf sb_refname = STRBUF_INIT;
1936 struct object_id unused_oid;
1937 int unused_flags;
1938 int symref_count;
1940 if (!oid)
1941 oid = &unused_oid;
1942 if (!flags)
1943 flags = &unused_flags;
1945 *flags = 0;
1947 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1948 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1949 !refname_is_safe(refname))
1950 return NULL;
1953 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1954 * missing refs and refs that were present but invalid,
1955 * to complain about the latter to stderr.
1957 * We don't know whether the ref exists, so don't set
1958 * REF_ISBROKEN yet.
1960 *flags |= REF_BAD_NAME;
1963 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1964 unsigned int read_flags = 0;
1965 int failure_errno;
1967 if (refs_read_raw_ref(refs, refname, oid, &sb_refname,
1968 &read_flags, &failure_errno)) {
1969 *flags |= read_flags;
1971 /* In reading mode, refs must eventually resolve */
1972 if (resolve_flags & RESOLVE_REF_READING)
1973 return NULL;
1976 * Otherwise a missing ref is OK. But the files backend
1977 * may show errors besides ENOENT if there are
1978 * similarly-named refs.
1980 if (failure_errno != ENOENT &&
1981 failure_errno != EISDIR &&
1982 failure_errno != ENOTDIR)
1983 return NULL;
1985 oidclr(oid);
1986 if (*flags & REF_BAD_NAME)
1987 *flags |= REF_ISBROKEN;
1988 return refname;
1991 *flags |= read_flags;
1993 if (!(read_flags & REF_ISSYMREF)) {
1994 if (*flags & REF_BAD_NAME) {
1995 oidclr(oid);
1996 *flags |= REF_ISBROKEN;
1998 return refname;
2001 refname = sb_refname.buf;
2002 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
2003 oidclr(oid);
2004 return refname;
2006 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
2007 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
2008 !refname_is_safe(refname))
2009 return NULL;
2011 *flags |= REF_ISBROKEN | REF_BAD_NAME;
2015 return NULL;
2018 /* backend functions */
2019 int refs_init_db(struct ref_store *refs, int flags, struct strbuf *err)
2021 return refs->be->init_db(refs, flags, err);
2024 const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
2025 struct object_id *oid, int *flags)
2027 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
2028 resolve_flags, oid, flags);
2031 int resolve_gitlink_ref(const char *submodule, const char *refname,
2032 struct object_id *oid)
2034 struct ref_store *refs;
2035 int flags;
2037 refs = get_submodule_ref_store(submodule);
2039 if (!refs)
2040 return -1;
2042 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
2043 is_null_oid(oid))
2044 return -1;
2045 return 0;
2048 struct ref_store_hash_entry
2050 struct hashmap_entry ent;
2052 struct ref_store *refs;
2054 /* NUL-terminated identifier of the ref store: */
2055 char name[FLEX_ARRAY];
2058 static int ref_store_hash_cmp(const void *cmp_data UNUSED,
2059 const struct hashmap_entry *eptr,
2060 const struct hashmap_entry *entry_or_key,
2061 const void *keydata)
2063 const struct ref_store_hash_entry *e1, *e2;
2064 const char *name;
2066 e1 = container_of(eptr, const struct ref_store_hash_entry, ent);
2067 e2 = container_of(entry_or_key, const struct ref_store_hash_entry, ent);
2068 name = keydata ? keydata : e2->name;
2070 return strcmp(e1->name, name);
2073 static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
2074 const char *name, struct ref_store *refs)
2076 struct ref_store_hash_entry *entry;
2078 FLEX_ALLOC_STR(entry, name, name);
2079 hashmap_entry_init(&entry->ent, strhash(name));
2080 entry->refs = refs;
2081 return entry;
2084 /* A hashmap of ref_stores, stored by submodule name: */
2085 static struct hashmap submodule_ref_stores;
2087 /* A hashmap of ref_stores, stored by worktree id: */
2088 static struct hashmap worktree_ref_stores;
2091 * Look up a ref store by name. If that ref_store hasn't been
2092 * registered yet, return NULL.
2094 static struct ref_store *lookup_ref_store_map(struct hashmap *map,
2095 const char *name)
2097 struct ref_store_hash_entry *entry;
2098 unsigned int hash;
2100 if (!map->tablesize)
2101 /* It's initialized on demand in register_ref_store(). */
2102 return NULL;
2104 hash = strhash(name);
2105 entry = hashmap_get_entry_from_hash(map, hash, name,
2106 struct ref_store_hash_entry, ent);
2107 return entry ? entry->refs : NULL;
2111 * Create, record, and return a ref_store instance for the specified
2112 * gitdir.
2114 static struct ref_store *ref_store_init(struct repository *repo,
2115 const char *gitdir,
2116 unsigned int flags)
2118 const struct ref_storage_be *be;
2119 struct ref_store *refs;
2121 be = find_ref_storage_backend(repo->ref_storage_format);
2122 if (!be)
2123 BUG("reference backend is unknown");
2125 refs = be->init(repo, gitdir, flags);
2126 return refs;
2129 struct ref_store *get_main_ref_store(struct repository *r)
2131 if (r->refs_private)
2132 return r->refs_private;
2134 if (!r->gitdir)
2135 BUG("attempting to get main_ref_store outside of repository");
2137 r->refs_private = ref_store_init(r, r->gitdir, REF_STORE_ALL_CAPS);
2138 r->refs_private = maybe_debug_wrap_ref_store(r->gitdir, r->refs_private);
2139 return r->refs_private;
2143 * Associate a ref store with a name. It is a fatal error to call this
2144 * function twice for the same name.
2146 static void register_ref_store_map(struct hashmap *map,
2147 const char *type,
2148 struct ref_store *refs,
2149 const char *name)
2151 struct ref_store_hash_entry *entry;
2153 if (!map->tablesize)
2154 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
2156 entry = alloc_ref_store_hash_entry(name, refs);
2157 if (hashmap_put(map, &entry->ent))
2158 BUG("%s ref_store '%s' initialized twice", type, name);
2161 struct ref_store *get_submodule_ref_store(const char *submodule)
2163 struct strbuf submodule_sb = STRBUF_INIT;
2164 struct ref_store *refs;
2165 char *to_free = NULL;
2166 size_t len;
2167 struct repository *subrepo;
2169 if (!submodule)
2170 return NULL;
2172 len = strlen(submodule);
2173 while (len && is_dir_sep(submodule[len - 1]))
2174 len--;
2175 if (!len)
2176 return NULL;
2178 if (submodule[len])
2179 /* We need to strip off one or more trailing slashes */
2180 submodule = to_free = xmemdupz(submodule, len);
2182 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
2183 if (refs)
2184 goto done;
2186 strbuf_addstr(&submodule_sb, submodule);
2187 if (!is_nonbare_repository_dir(&submodule_sb))
2188 goto done;
2190 if (submodule_to_gitdir(&submodule_sb, submodule))
2191 goto done;
2193 subrepo = xmalloc(sizeof(*subrepo));
2195 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2196 * superprojects other than the_repository. This probably should be
2197 * done by making it take a struct repository * parameter instead of a
2198 * submodule path.
2200 if (repo_submodule_init(subrepo, the_repository, submodule,
2201 null_oid())) {
2202 free(subrepo);
2203 goto done;
2205 refs = ref_store_init(subrepo, submodule_sb.buf,
2206 REF_STORE_READ | REF_STORE_ODB);
2207 register_ref_store_map(&submodule_ref_stores, "submodule",
2208 refs, submodule);
2210 done:
2211 strbuf_release(&submodule_sb);
2212 free(to_free);
2214 return refs;
2217 struct ref_store *get_worktree_ref_store(const struct worktree *wt)
2219 struct ref_store *refs;
2220 const char *id;
2222 if (wt->is_current)
2223 return get_main_ref_store(the_repository);
2225 id = wt->id ? wt->id : "/";
2226 refs = lookup_ref_store_map(&worktree_ref_stores, id);
2227 if (refs)
2228 return refs;
2230 if (wt->id)
2231 refs = ref_store_init(the_repository,
2232 git_common_path("worktrees/%s", wt->id),
2233 REF_STORE_ALL_CAPS);
2234 else
2235 refs = ref_store_init(the_repository,
2236 get_git_common_dir(),
2237 REF_STORE_ALL_CAPS);
2239 if (refs)
2240 register_ref_store_map(&worktree_ref_stores, "worktree",
2241 refs, id);
2242 return refs;
2245 void base_ref_store_init(struct ref_store *refs, struct repository *repo,
2246 const char *path, const struct ref_storage_be *be)
2248 refs->be = be;
2249 refs->repo = repo;
2250 refs->gitdir = xstrdup(path);
2253 /* backend functions */
2254 int refs_pack_refs(struct ref_store *refs, struct pack_refs_opts *opts)
2256 return refs->be->pack_refs(refs, opts);
2259 int peel_iterated_oid(const struct object_id *base, struct object_id *peeled)
2261 if (current_ref_iter &&
2262 (current_ref_iter->oid == base ||
2263 oideq(current_ref_iter->oid, base)))
2264 return ref_iterator_peel(current_ref_iter, peeled);
2266 return peel_object(base, peeled) ? -1 : 0;
2269 int refs_create_symref(struct ref_store *refs,
2270 const char *ref_target,
2271 const char *refs_heads_master,
2272 const char *logmsg)
2274 char *msg;
2275 int retval;
2277 msg = normalize_reflog_message(logmsg);
2278 retval = refs->be->create_symref(refs, ref_target, refs_heads_master,
2279 msg);
2280 free(msg);
2281 return retval;
2284 int create_symref(const char *ref_target, const char *refs_heads_master,
2285 const char *logmsg)
2287 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
2288 refs_heads_master, logmsg);
2291 int ref_update_reject_duplicates(struct string_list *refnames,
2292 struct strbuf *err)
2294 size_t i, n = refnames->nr;
2296 assert(err);
2298 for (i = 1; i < n; i++) {
2299 int cmp = strcmp(refnames->items[i - 1].string,
2300 refnames->items[i].string);
2302 if (!cmp) {
2303 strbuf_addf(err,
2304 _("multiple updates for ref '%s' not allowed"),
2305 refnames->items[i].string);
2306 return 1;
2307 } else if (cmp > 0) {
2308 BUG("ref_update_reject_duplicates() received unsorted list");
2311 return 0;
2314 static int run_transaction_hook(struct ref_transaction *transaction,
2315 const char *state)
2317 struct child_process proc = CHILD_PROCESS_INIT;
2318 struct strbuf buf = STRBUF_INIT;
2319 const char *hook;
2320 int ret = 0, i;
2322 hook = find_hook("reference-transaction");
2323 if (!hook)
2324 return ret;
2326 strvec_pushl(&proc.args, hook, state, NULL);
2327 proc.in = -1;
2328 proc.stdout_to_stderr = 1;
2329 proc.trace2_hook_name = "reference-transaction";
2331 ret = start_command(&proc);
2332 if (ret)
2333 return ret;
2335 sigchain_push(SIGPIPE, SIG_IGN);
2337 for (i = 0; i < transaction->nr; i++) {
2338 struct ref_update *update = transaction->updates[i];
2340 strbuf_reset(&buf);
2341 strbuf_addf(&buf, "%s %s %s\n",
2342 oid_to_hex(&update->old_oid),
2343 oid_to_hex(&update->new_oid),
2344 update->refname);
2346 if (write_in_full(proc.in, buf.buf, buf.len) < 0) {
2347 if (errno != EPIPE) {
2348 /* Don't leak errno outside this API */
2349 errno = 0;
2350 ret = -1;
2352 break;
2356 close(proc.in);
2357 sigchain_pop(SIGPIPE);
2358 strbuf_release(&buf);
2360 ret |= finish_command(&proc);
2361 return ret;
2364 int ref_transaction_prepare(struct ref_transaction *transaction,
2365 struct strbuf *err)
2367 struct ref_store *refs = transaction->ref_store;
2368 int ret;
2370 switch (transaction->state) {
2371 case REF_TRANSACTION_OPEN:
2372 /* Good. */
2373 break;
2374 case REF_TRANSACTION_PREPARED:
2375 BUG("prepare called twice on reference transaction");
2376 break;
2377 case REF_TRANSACTION_CLOSED:
2378 BUG("prepare called on a closed reference transaction");
2379 break;
2380 default:
2381 BUG("unexpected reference transaction state");
2382 break;
2385 if (refs->repo->objects->odb->disable_ref_updates) {
2386 strbuf_addstr(err,
2387 _("ref updates forbidden inside quarantine environment"));
2388 return -1;
2391 ret = refs->be->transaction_prepare(refs, transaction, err);
2392 if (ret)
2393 return ret;
2395 ret = run_transaction_hook(transaction, "prepared");
2396 if (ret) {
2397 ref_transaction_abort(transaction, err);
2398 die(_("ref updates aborted by hook"));
2401 return 0;
2404 int ref_transaction_abort(struct ref_transaction *transaction,
2405 struct strbuf *err)
2407 struct ref_store *refs = transaction->ref_store;
2408 int ret = 0;
2410 switch (transaction->state) {
2411 case REF_TRANSACTION_OPEN:
2412 /* No need to abort explicitly. */
2413 break;
2414 case REF_TRANSACTION_PREPARED:
2415 ret = refs->be->transaction_abort(refs, transaction, err);
2416 break;
2417 case REF_TRANSACTION_CLOSED:
2418 BUG("abort called on a closed reference transaction");
2419 break;
2420 default:
2421 BUG("unexpected reference transaction state");
2422 break;
2425 run_transaction_hook(transaction, "aborted");
2427 ref_transaction_free(transaction);
2428 return ret;
2431 int ref_transaction_commit(struct ref_transaction *transaction,
2432 struct strbuf *err)
2434 struct ref_store *refs = transaction->ref_store;
2435 int ret;
2437 switch (transaction->state) {
2438 case REF_TRANSACTION_OPEN:
2439 /* Need to prepare first. */
2440 ret = ref_transaction_prepare(transaction, err);
2441 if (ret)
2442 return ret;
2443 break;
2444 case REF_TRANSACTION_PREPARED:
2445 /* Fall through to finish. */
2446 break;
2447 case REF_TRANSACTION_CLOSED:
2448 BUG("commit called on a closed reference transaction");
2449 break;
2450 default:
2451 BUG("unexpected reference transaction state");
2452 break;
2455 ret = refs->be->transaction_finish(refs, transaction, err);
2456 if (!ret)
2457 run_transaction_hook(transaction, "committed");
2458 return ret;
2461 int refs_verify_refname_available(struct ref_store *refs,
2462 const char *refname,
2463 const struct string_list *extras,
2464 const struct string_list *skip,
2465 struct strbuf *err)
2467 const char *slash;
2468 const char *extra_refname;
2469 struct strbuf dirname = STRBUF_INIT;
2470 struct strbuf referent = STRBUF_INIT;
2471 struct object_id oid;
2472 unsigned int type;
2473 struct ref_iterator *iter;
2474 int ok;
2475 int ret = -1;
2478 * For the sake of comments in this function, suppose that
2479 * refname is "refs/foo/bar".
2482 assert(err);
2484 strbuf_grow(&dirname, strlen(refname) + 1);
2485 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
2487 * Just saying "Is a directory" when we e.g. can't
2488 * lock some multi-level ref isn't very informative,
2489 * the user won't be told *what* is a directory, so
2490 * let's not use strerror() below.
2492 int ignore_errno;
2493 /* Expand dirname to the new prefix, not including the trailing slash: */
2494 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2497 * We are still at a leading dir of the refname (e.g.,
2498 * "refs/foo"; if there is a reference with that name,
2499 * it is a conflict, *unless* it is in skip.
2501 if (skip && string_list_has_string(skip, dirname.buf))
2502 continue;
2504 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent,
2505 &type, &ignore_errno)) {
2506 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2507 dirname.buf, refname);
2508 goto cleanup;
2511 if (extras && string_list_has_string(extras, dirname.buf)) {
2512 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2513 refname, dirname.buf);
2514 goto cleanup;
2519 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2520 * There is no point in searching for a reference with that
2521 * name, because a refname isn't considered to conflict with
2522 * itself. But we still need to check for references whose
2523 * names are in the "refs/foo/bar/" namespace, because they
2524 * *do* conflict.
2526 strbuf_addstr(&dirname, refname + dirname.len);
2527 strbuf_addch(&dirname, '/');
2529 iter = refs_ref_iterator_begin(refs, dirname.buf, NULL, 0,
2530 DO_FOR_EACH_INCLUDE_BROKEN);
2531 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2532 if (skip &&
2533 string_list_has_string(skip, iter->refname))
2534 continue;
2536 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2537 iter->refname, refname);
2538 ref_iterator_abort(iter);
2539 goto cleanup;
2542 if (ok != ITER_DONE)
2543 BUG("error while iterating over references");
2545 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2546 if (extra_refname)
2547 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2548 refname, extra_refname);
2549 else
2550 ret = 0;
2552 cleanup:
2553 strbuf_release(&referent);
2554 strbuf_release(&dirname);
2555 return ret;
2558 struct do_for_each_reflog_help {
2559 each_reflog_fn *fn;
2560 void *cb_data;
2563 static int do_for_each_reflog_helper(struct repository *r UNUSED,
2564 const char *refname,
2565 const struct object_id *oid UNUSED,
2566 int flags,
2567 void *cb_data)
2569 struct do_for_each_reflog_help *hp = cb_data;
2570 return hp->fn(refname, hp->cb_data);
2573 int refs_for_each_reflog(struct ref_store *refs, each_reflog_fn fn, void *cb_data)
2575 struct ref_iterator *iter;
2576 struct do_for_each_reflog_help hp = { fn, cb_data };
2578 iter = refs->be->reflog_iterator_begin(refs);
2580 return do_for_each_repo_ref_iterator(the_repository, iter,
2581 do_for_each_reflog_helper, &hp);
2584 int for_each_reflog(each_reflog_fn fn, void *cb_data)
2586 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
2589 int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2590 const char *refname,
2591 each_reflog_ent_fn fn,
2592 void *cb_data)
2594 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2595 fn, cb_data);
2598 int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2599 void *cb_data)
2601 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
2602 refname, fn, cb_data);
2605 int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2606 each_reflog_ent_fn fn, void *cb_data)
2608 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2611 int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2612 void *cb_data)
2614 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
2615 fn, cb_data);
2618 int refs_reflog_exists(struct ref_store *refs, const char *refname)
2620 return refs->be->reflog_exists(refs, refname);
2623 int reflog_exists(const char *refname)
2625 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
2628 int refs_create_reflog(struct ref_store *refs, const char *refname,
2629 struct strbuf *err)
2631 return refs->be->create_reflog(refs, refname, err);
2634 int safe_create_reflog(const char *refname, struct strbuf *err)
2636 return refs_create_reflog(get_main_ref_store(the_repository), refname,
2637 err);
2640 int refs_delete_reflog(struct ref_store *refs, const char *refname)
2642 return refs->be->delete_reflog(refs, refname);
2645 int delete_reflog(const char *refname)
2647 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
2650 int refs_reflog_expire(struct ref_store *refs,
2651 const char *refname,
2652 unsigned int flags,
2653 reflog_expiry_prepare_fn prepare_fn,
2654 reflog_expiry_should_prune_fn should_prune_fn,
2655 reflog_expiry_cleanup_fn cleanup_fn,
2656 void *policy_cb_data)
2658 return refs->be->reflog_expire(refs, refname, flags,
2659 prepare_fn, should_prune_fn,
2660 cleanup_fn, policy_cb_data);
2663 int reflog_expire(const char *refname,
2664 unsigned int flags,
2665 reflog_expiry_prepare_fn prepare_fn,
2666 reflog_expiry_should_prune_fn should_prune_fn,
2667 reflog_expiry_cleanup_fn cleanup_fn,
2668 void *policy_cb_data)
2670 return refs_reflog_expire(get_main_ref_store(the_repository),
2671 refname, flags,
2672 prepare_fn, should_prune_fn,
2673 cleanup_fn, policy_cb_data);
2676 int initial_ref_transaction_commit(struct ref_transaction *transaction,
2677 struct strbuf *err)
2679 struct ref_store *refs = transaction->ref_store;
2681 return refs->be->initial_transaction_commit(refs, transaction, err);
2684 void ref_transaction_for_each_queued_update(struct ref_transaction *transaction,
2685 ref_transaction_for_each_queued_update_fn cb,
2686 void *cb_data)
2688 int i;
2690 for (i = 0; i < transaction->nr; i++) {
2691 struct ref_update *update = transaction->updates[i];
2693 cb(update->refname,
2694 (update->flags & REF_HAVE_OLD) ? &update->old_oid : NULL,
2695 (update->flags & REF_HAVE_NEW) ? &update->new_oid : NULL,
2696 cb_data);
2700 int refs_delete_refs(struct ref_store *refs, const char *logmsg,
2701 struct string_list *refnames, unsigned int flags)
2703 struct ref_transaction *transaction;
2704 struct strbuf err = STRBUF_INIT;
2705 struct string_list_item *item;
2706 int ret = 0, failures = 0;
2707 char *msg;
2709 if (!refnames->nr)
2710 return 0;
2712 msg = normalize_reflog_message(logmsg);
2715 * Since we don't check the references' old_oids, the
2716 * individual updates can't fail, so we can pack all of the
2717 * updates into a single transaction.
2719 transaction = ref_store_transaction_begin(refs, &err);
2720 if (!transaction) {
2721 ret = error("%s", err.buf);
2722 goto out;
2725 for_each_string_list_item(item, refnames) {
2726 ret = ref_transaction_delete(transaction, item->string,
2727 NULL, flags, msg, &err);
2728 if (ret) {
2729 warning(_("could not delete reference %s: %s"),
2730 item->string, err.buf);
2731 strbuf_reset(&err);
2732 failures = 1;
2736 ret = ref_transaction_commit(transaction, &err);
2737 if (ret) {
2738 if (refnames->nr == 1)
2739 error(_("could not delete reference %s: %s"),
2740 refnames->items[0].string, err.buf);
2741 else
2742 error(_("could not delete references: %s"), err.buf);
2745 out:
2746 if (!ret && failures)
2747 ret = -1;
2748 ref_transaction_free(transaction);
2749 strbuf_release(&err);
2750 free(msg);
2751 return ret;
2754 int delete_refs(const char *msg, struct string_list *refnames,
2755 unsigned int flags)
2757 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
2760 int refs_rename_ref(struct ref_store *refs, const char *oldref,
2761 const char *newref, const char *logmsg)
2763 char *msg;
2764 int retval;
2766 msg = normalize_reflog_message(logmsg);
2767 retval = refs->be->rename_ref(refs, oldref, newref, msg);
2768 free(msg);
2769 return retval;
2772 int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2774 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
2777 int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2778 const char *newref, const char *logmsg)
2780 char *msg;
2781 int retval;
2783 msg = normalize_reflog_message(logmsg);
2784 retval = refs->be->copy_ref(refs, oldref, newref, msg);
2785 free(msg);
2786 return retval;
2789 int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2791 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);