Merge branch '2.44-uk-update' of github.com:arkid15r/git-ukrainian-l10n
[alt-git.git] / refs.c
blobc633abf2847cf1b05eec9c9b4d0c817cf78618b6
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,
40 static const struct ref_storage_be *find_ref_storage_backend(unsigned int ref_storage_format)
42 if (ref_storage_format < ARRAY_SIZE(refs_backends))
43 return refs_backends[ref_storage_format];
44 return NULL;
47 unsigned int ref_storage_format_by_name(const char *name)
49 for (unsigned int i = 0; i < ARRAY_SIZE(refs_backends); i++)
50 if (refs_backends[i] && !strcmp(refs_backends[i]->name, name))
51 return i;
52 return REF_STORAGE_FORMAT_UNKNOWN;
55 const char *ref_storage_format_to_name(unsigned int ref_storage_format)
57 const struct ref_storage_be *be = find_ref_storage_backend(ref_storage_format);
58 if (!be)
59 return "unknown";
60 return be->name;
64 * How to handle various characters in refnames:
65 * 0: An acceptable character for refs
66 * 1: End-of-component
67 * 2: ., look for a preceding . to reject .. in refs
68 * 3: {, look for a preceding @ to reject @{ in refs
69 * 4: A bad character: ASCII control characters, and
70 * ":", "?", "[", "\", "^", "~", SP, or TAB
71 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
73 static unsigned char refname_disposition[256] = {
74 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
75 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
77 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
84 struct ref_namespace_info ref_namespace[] = {
85 [NAMESPACE_HEAD] = {
86 .ref = "HEAD",
87 .decoration = DECORATION_REF_HEAD,
88 .exact = 1,
90 [NAMESPACE_BRANCHES] = {
91 .ref = "refs/heads/",
92 .decoration = DECORATION_REF_LOCAL,
94 [NAMESPACE_TAGS] = {
95 .ref = "refs/tags/",
96 .decoration = DECORATION_REF_TAG,
98 [NAMESPACE_REMOTE_REFS] = {
100 * The default refspec for new remotes copies refs from
101 * refs/heads/ on the remote into refs/remotes/<remote>/.
102 * As such, "refs/remotes/" has special handling.
104 .ref = "refs/remotes/",
105 .decoration = DECORATION_REF_REMOTE,
107 [NAMESPACE_STASH] = {
109 * The single ref "refs/stash" stores the latest stash.
110 * Older stashes can be found in the reflog.
112 .ref = "refs/stash",
113 .exact = 1,
114 .decoration = DECORATION_REF_STASH,
116 [NAMESPACE_REPLACE] = {
118 * This namespace allows Git to act as if one object ID
119 * points to the content of another. Unlike the other
120 * ref namespaces, this one can be changed by the
121 * GIT_REPLACE_REF_BASE environment variable. This
122 * .namespace value will be overwritten in setup_git_env().
124 .ref = "refs/replace/",
125 .decoration = DECORATION_GRAFTED,
127 [NAMESPACE_NOTES] = {
129 * The refs/notes/commit ref points to the tip of a
130 * parallel commit history that adds metadata to commits
131 * in the normal history. This ref can be overwritten
132 * by the core.notesRef config variable or the
133 * GIT_NOTES_REFS environment variable.
135 .ref = "refs/notes/commit",
136 .exact = 1,
138 [NAMESPACE_PREFETCH] = {
140 * Prefetch refs are written by the background 'fetch'
141 * maintenance task. It allows faster foreground fetches
142 * by advertising these previously-downloaded tips without
143 * updating refs/remotes/ without user intervention.
145 .ref = "refs/prefetch/",
147 [NAMESPACE_REWRITTEN] = {
149 * Rewritten refs are used by the 'label' command in the
150 * sequencer. These are particularly useful during an
151 * interactive rebase that uses the 'merge' command.
153 .ref = "refs/rewritten/",
157 void update_ref_namespace(enum ref_namespace namespace, char *ref)
159 struct ref_namespace_info *info = &ref_namespace[namespace];
160 if (info->ref_updated)
161 free(info->ref);
162 info->ref = ref;
163 info->ref_updated = 1;
167 * Try to read one refname component from the front of refname.
168 * Return the length of the component found, or -1 if the component is
169 * not legal. It is legal if it is something reasonable to have under
170 * ".git/refs/"; We do not like it if:
172 * - it begins with ".", or
173 * - it has double dots "..", or
174 * - it has ASCII control characters, or
175 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
176 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
177 * - it ends with a "/", or
178 * - it ends with ".lock", or
179 * - it contains a "@{" portion
181 * When sanitized is not NULL, instead of rejecting the input refname
182 * as an error, try to come up with a usable replacement for the input
183 * refname in it.
185 static int check_refname_component(const char *refname, int *flags,
186 struct strbuf *sanitized)
188 const char *cp;
189 char last = '\0';
190 size_t component_start = 0; /* garbage - not a reasonable initial value */
192 if (sanitized)
193 component_start = sanitized->len;
195 for (cp = refname; ; cp++) {
196 int ch = *cp & 255;
197 unsigned char disp = refname_disposition[ch];
199 if (sanitized && disp != 1)
200 strbuf_addch(sanitized, ch);
202 switch (disp) {
203 case 1:
204 goto out;
205 case 2:
206 if (last == '.') { /* Refname contains "..". */
207 if (sanitized)
208 /* collapse ".." to single "." */
209 strbuf_setlen(sanitized, sanitized->len - 1);
210 else
211 return -1;
213 break;
214 case 3:
215 if (last == '@') { /* Refname contains "@{". */
216 if (sanitized)
217 sanitized->buf[sanitized->len-1] = '-';
218 else
219 return -1;
221 break;
222 case 4:
223 /* forbidden char */
224 if (sanitized)
225 sanitized->buf[sanitized->len-1] = '-';
226 else
227 return -1;
228 break;
229 case 5:
230 if (!(*flags & REFNAME_REFSPEC_PATTERN)) {
231 /* refspec can't be a pattern */
232 if (sanitized)
233 sanitized->buf[sanitized->len-1] = '-';
234 else
235 return -1;
239 * Unset the pattern flag so that we only accept
240 * a single asterisk for one side of refspec.
242 *flags &= ~ REFNAME_REFSPEC_PATTERN;
243 break;
245 last = ch;
247 out:
248 if (cp == refname)
249 return 0; /* Component has zero length. */
251 if (refname[0] == '.') { /* Component starts with '.'. */
252 if (sanitized)
253 sanitized->buf[component_start] = '-';
254 else
255 return -1;
257 if (cp - refname >= LOCK_SUFFIX_LEN &&
258 !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN)) {
259 if (!sanitized)
260 return -1;
261 /* Refname ends with ".lock". */
262 while (strbuf_strip_suffix(sanitized, LOCK_SUFFIX)) {
263 /* try again in case we have .lock.lock */
266 return cp - refname;
269 static int check_or_sanitize_refname(const char *refname, int flags,
270 struct strbuf *sanitized)
272 int component_len, component_count = 0;
274 if (!strcmp(refname, "@")) {
275 /* Refname is a single character '@'. */
276 if (sanitized)
277 strbuf_addch(sanitized, '-');
278 else
279 return -1;
282 while (1) {
283 if (sanitized && sanitized->len)
284 strbuf_complete(sanitized, '/');
286 /* We are at the start of a path component. */
287 component_len = check_refname_component(refname, &flags,
288 sanitized);
289 if (sanitized && component_len == 0)
290 ; /* OK, omit empty component */
291 else if (component_len <= 0)
292 return -1;
294 component_count++;
295 if (refname[component_len] == '\0')
296 break;
297 /* Skip to next component. */
298 refname += component_len + 1;
301 if (refname[component_len - 1] == '.') {
302 /* Refname ends with '.'. */
303 if (sanitized)
304 ; /* omit ending dot */
305 else
306 return -1;
308 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
309 return -1; /* Refname has only one component. */
310 return 0;
313 int check_refname_format(const char *refname, int flags)
315 return check_or_sanitize_refname(refname, flags, NULL);
318 void sanitize_refname_component(const char *refname, struct strbuf *out)
320 if (check_or_sanitize_refname(refname, REFNAME_ALLOW_ONELEVEL, out))
321 BUG("sanitizing refname '%s' check returned error", refname);
324 int refname_is_safe(const char *refname)
326 const char *rest;
328 if (skip_prefix(refname, "refs/", &rest)) {
329 char *buf;
330 int result;
331 size_t restlen = strlen(rest);
333 /* rest must not be empty, or start or end with "/" */
334 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
335 return 0;
338 * Does the refname try to escape refs/?
339 * For example: refs/foo/../bar is safe but refs/foo/../../bar
340 * is not.
342 buf = xmallocz(restlen);
343 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
344 free(buf);
345 return result;
348 do {
349 if (!isupper(*refname) && *refname != '_')
350 return 0;
351 refname++;
352 } while (*refname);
353 return 1;
357 * Return true if refname, which has the specified oid and flags, can
358 * be resolved to an object in the database. If the referred-to object
359 * does not exist, emit a warning and return false.
361 int ref_resolves_to_object(const char *refname,
362 struct repository *repo,
363 const struct object_id *oid,
364 unsigned int flags)
366 if (flags & REF_ISBROKEN)
367 return 0;
368 if (!repo_has_object_file(repo, oid)) {
369 error(_("%s does not point to a valid object!"), refname);
370 return 0;
372 return 1;
375 char *refs_resolve_refdup(struct ref_store *refs,
376 const char *refname, int resolve_flags,
377 struct object_id *oid, int *flags)
379 const char *result;
381 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
382 oid, flags);
383 return xstrdup_or_null(result);
386 char *resolve_refdup(const char *refname, int resolve_flags,
387 struct object_id *oid, int *flags)
389 return refs_resolve_refdup(get_main_ref_store(the_repository),
390 refname, resolve_flags,
391 oid, flags);
394 /* The argument to for_each_filter_refs */
395 struct for_each_ref_filter {
396 const char *pattern;
397 const char *prefix;
398 each_ref_fn *fn;
399 void *cb_data;
402 int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags)
404 struct ref_store *refs = get_main_ref_store(the_repository);
406 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags,
407 oid, flags))
408 return 0;
409 return -1;
412 int read_ref(const char *refname, struct object_id *oid)
414 return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
417 int refs_ref_exists(struct ref_store *refs, const char *refname)
419 return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING,
420 NULL, NULL);
423 int ref_exists(const char *refname)
425 return refs_ref_exists(get_main_ref_store(the_repository), refname);
428 static int for_each_filter_refs(const char *refname,
429 const struct object_id *oid,
430 int flags, void *data)
432 struct for_each_ref_filter *filter = data;
434 if (wildmatch(filter->pattern, refname, 0))
435 return 0;
436 if (filter->prefix)
437 skip_prefix(refname, filter->prefix, &refname);
438 return filter->fn(refname, oid, flags, filter->cb_data);
441 enum peel_status peel_object(const struct object_id *name, struct object_id *oid)
443 struct object *o = lookup_unknown_object(the_repository, name);
445 if (o->type == OBJ_NONE) {
446 int type = oid_object_info(the_repository, name, NULL);
447 if (type < 0 || !object_as_type(o, type, 0))
448 return PEEL_INVALID;
451 if (o->type != OBJ_TAG)
452 return PEEL_NON_TAG;
454 o = deref_tag_noverify(o);
455 if (!o)
456 return PEEL_INVALID;
458 oidcpy(oid, &o->oid);
459 return PEEL_PEELED;
462 struct warn_if_dangling_data {
463 FILE *fp;
464 const char *refname;
465 const struct string_list *refnames;
466 const char *msg_fmt;
469 static int warn_if_dangling_symref(const char *refname,
470 const struct object_id *oid UNUSED,
471 int flags, void *cb_data)
473 struct warn_if_dangling_data *d = cb_data;
474 const char *resolves_to;
476 if (!(flags & REF_ISSYMREF))
477 return 0;
479 resolves_to = resolve_ref_unsafe(refname, 0, NULL, NULL);
480 if (!resolves_to
481 || (d->refname
482 ? strcmp(resolves_to, d->refname)
483 : !string_list_has_string(d->refnames, resolves_to))) {
484 return 0;
487 fprintf(d->fp, d->msg_fmt, refname);
488 fputc('\n', d->fp);
489 return 0;
492 void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
494 struct warn_if_dangling_data data;
496 data.fp = fp;
497 data.refname = refname;
498 data.refnames = NULL;
499 data.msg_fmt = msg_fmt;
500 for_each_rawref(warn_if_dangling_symref, &data);
503 void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
505 struct warn_if_dangling_data data;
507 data.fp = fp;
508 data.refname = NULL;
509 data.refnames = refnames;
510 data.msg_fmt = msg_fmt;
511 for_each_rawref(warn_if_dangling_symref, &data);
514 int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
516 return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
519 int for_each_tag_ref(each_ref_fn fn, void *cb_data)
521 return refs_for_each_tag_ref(get_main_ref_store(the_repository), fn, cb_data);
524 int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
526 return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
529 int for_each_branch_ref(each_ref_fn fn, void *cb_data)
531 return refs_for_each_branch_ref(get_main_ref_store(the_repository), fn, cb_data);
534 int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
536 return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
539 int for_each_remote_ref(each_ref_fn fn, void *cb_data)
541 return refs_for_each_remote_ref(get_main_ref_store(the_repository), fn, cb_data);
544 int head_ref_namespaced(each_ref_fn fn, void *cb_data)
546 struct strbuf buf = STRBUF_INIT;
547 int ret = 0;
548 struct object_id oid;
549 int flag;
551 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
552 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, &oid, &flag))
553 ret = fn(buf.buf, &oid, flag, cb_data);
554 strbuf_release(&buf);
556 return ret;
559 void normalize_glob_ref(struct string_list_item *item, const char *prefix,
560 const char *pattern)
562 struct strbuf normalized_pattern = STRBUF_INIT;
564 if (*pattern == '/')
565 BUG("pattern must not start with '/'");
567 if (prefix)
568 strbuf_addstr(&normalized_pattern, prefix);
569 else if (!starts_with(pattern, "refs/") &&
570 strcmp(pattern, "HEAD"))
571 strbuf_addstr(&normalized_pattern, "refs/");
573 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
574 * MERGE_HEAD, etc.
577 strbuf_addstr(&normalized_pattern, pattern);
578 strbuf_strip_suffix(&normalized_pattern, "/");
580 item->string = strbuf_detach(&normalized_pattern, NULL);
581 item->util = has_glob_specials(pattern) ? NULL : item->string;
582 strbuf_release(&normalized_pattern);
585 int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
586 const char *prefix, void *cb_data)
588 struct strbuf real_pattern = STRBUF_INIT;
589 struct for_each_ref_filter filter;
590 int ret;
592 if (!prefix && !starts_with(pattern, "refs/"))
593 strbuf_addstr(&real_pattern, "refs/");
594 else if (prefix)
595 strbuf_addstr(&real_pattern, prefix);
596 strbuf_addstr(&real_pattern, pattern);
598 if (!has_glob_specials(pattern)) {
599 /* Append implied '/' '*' if not present. */
600 strbuf_complete(&real_pattern, '/');
601 /* No need to check for '*', there is none. */
602 strbuf_addch(&real_pattern, '*');
605 filter.pattern = real_pattern.buf;
606 filter.prefix = prefix;
607 filter.fn = fn;
608 filter.cb_data = cb_data;
609 ret = for_each_ref(for_each_filter_refs, &filter);
611 strbuf_release(&real_pattern);
612 return ret;
615 int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
617 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
620 const char *prettify_refname(const char *name)
622 if (skip_prefix(name, "refs/heads/", &name) ||
623 skip_prefix(name, "refs/tags/", &name) ||
624 skip_prefix(name, "refs/remotes/", &name))
625 ; /* nothing */
626 return name;
629 static const char *ref_rev_parse_rules[] = {
630 "%.*s",
631 "refs/%.*s",
632 "refs/tags/%.*s",
633 "refs/heads/%.*s",
634 "refs/remotes/%.*s",
635 "refs/remotes/%.*s/HEAD",
636 NULL
639 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
642 * Is it possible that the caller meant full_name with abbrev_name?
643 * If so return a non-zero value to signal "yes"; the magnitude of
644 * the returned value gives the precedence used for disambiguation.
646 * If abbrev_name cannot mean full_name, return 0.
648 int refname_match(const char *abbrev_name, const char *full_name)
650 const char **p;
651 const int abbrev_name_len = strlen(abbrev_name);
652 const int num_rules = NUM_REV_PARSE_RULES;
654 for (p = ref_rev_parse_rules; *p; p++)
655 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name)))
656 return &ref_rev_parse_rules[num_rules] - p;
658 return 0;
662 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
663 * the results to 'prefixes'
665 void expand_ref_prefix(struct strvec *prefixes, const char *prefix)
667 const char **p;
668 int len = strlen(prefix);
670 for (p = ref_rev_parse_rules; *p; p++)
671 strvec_pushf(prefixes, *p, len, prefix);
674 static const char default_branch_name_advice[] = N_(
675 "Using '%s' as the name for the initial branch. This default branch name\n"
676 "is subject to change. To configure the initial branch name to use in all\n"
677 "of your new repositories, which will suppress this warning, call:\n"
678 "\n"
679 "\tgit config --global init.defaultBranch <name>\n"
680 "\n"
681 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
682 "'development'. The just-created branch can be renamed via this command:\n"
683 "\n"
684 "\tgit branch -m <name>\n"
687 char *repo_default_branch_name(struct repository *r, int quiet)
689 const char *config_key = "init.defaultbranch";
690 const char *config_display_key = "init.defaultBranch";
691 char *ret = NULL, *full_ref;
692 const char *env = getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
694 if (env && *env)
695 ret = xstrdup(env);
696 else if (repo_config_get_string(r, config_key, &ret) < 0)
697 die(_("could not retrieve `%s`"), config_display_key);
699 if (!ret) {
700 ret = xstrdup("master");
701 if (!quiet)
702 advise(_(default_branch_name_advice), ret);
705 full_ref = xstrfmt("refs/heads/%s", ret);
706 if (check_refname_format(full_ref, 0))
707 die(_("invalid branch name: %s = %s"), config_display_key, ret);
708 free(full_ref);
710 return ret;
713 const char *git_default_branch_name(int quiet)
715 static char *ret;
717 if (!ret)
718 ret = repo_default_branch_name(the_repository, quiet);
720 return ret;
724 * *string and *len will only be substituted, and *string returned (for
725 * later free()ing) if the string passed in is a magic short-hand form
726 * to name a branch.
728 static char *substitute_branch_name(struct repository *r,
729 const char **string, int *len,
730 int nonfatal_dangling_mark)
732 struct strbuf buf = STRBUF_INIT;
733 struct interpret_branch_name_options options = {
734 .nonfatal_dangling_mark = nonfatal_dangling_mark
736 int ret = repo_interpret_branch_name(r, *string, *len, &buf, &options);
738 if (ret == *len) {
739 size_t size;
740 *string = strbuf_detach(&buf, &size);
741 *len = size;
742 return (char *)*string;
745 return NULL;
748 int repo_dwim_ref(struct repository *r, const char *str, int len,
749 struct object_id *oid, char **ref, int nonfatal_dangling_mark)
751 char *last_branch = substitute_branch_name(r, &str, &len,
752 nonfatal_dangling_mark);
753 int refs_found = expand_ref(r, str, len, oid, ref);
754 free(last_branch);
755 return refs_found;
758 int expand_ref(struct repository *repo, const char *str, int len,
759 struct object_id *oid, char **ref)
761 const char **p, *r;
762 int refs_found = 0;
763 struct strbuf fullref = STRBUF_INIT;
765 *ref = NULL;
766 for (p = ref_rev_parse_rules; *p; p++) {
767 struct object_id oid_from_ref;
768 struct object_id *this_result;
769 int flag;
770 struct ref_store *refs = get_main_ref_store(repo);
772 this_result = refs_found ? &oid_from_ref : oid;
773 strbuf_reset(&fullref);
774 strbuf_addf(&fullref, *p, len, str);
775 r = refs_resolve_ref_unsafe(refs, fullref.buf,
776 RESOLVE_REF_READING,
777 this_result, &flag);
778 if (r) {
779 if (!refs_found++)
780 *ref = xstrdup(r);
781 if (!warn_ambiguous_refs)
782 break;
783 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
784 warning(_("ignoring dangling symref %s"), fullref.buf);
785 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
786 warning(_("ignoring broken ref %s"), fullref.buf);
789 strbuf_release(&fullref);
790 return refs_found;
793 int repo_dwim_log(struct repository *r, const char *str, int len,
794 struct object_id *oid, char **log)
796 struct ref_store *refs = get_main_ref_store(r);
797 char *last_branch = substitute_branch_name(r, &str, &len, 0);
798 const char **p;
799 int logs_found = 0;
800 struct strbuf path = STRBUF_INIT;
802 *log = NULL;
803 for (p = ref_rev_parse_rules; *p; p++) {
804 struct object_id hash;
805 const char *ref, *it;
807 strbuf_reset(&path);
808 strbuf_addf(&path, *p, len, str);
809 ref = refs_resolve_ref_unsafe(refs, path.buf,
810 RESOLVE_REF_READING,
811 oid ? &hash : NULL, NULL);
812 if (!ref)
813 continue;
814 if (refs_reflog_exists(refs, path.buf))
815 it = path.buf;
816 else if (strcmp(ref, path.buf) &&
817 refs_reflog_exists(refs, ref))
818 it = ref;
819 else
820 continue;
821 if (!logs_found++) {
822 *log = xstrdup(it);
823 if (oid)
824 oidcpy(oid, &hash);
826 if (!warn_ambiguous_refs)
827 break;
829 strbuf_release(&path);
830 free(last_branch);
831 return logs_found;
834 int dwim_log(const char *str, int len, struct object_id *oid, char **log)
836 return repo_dwim_log(the_repository, str, len, oid, log);
839 int is_per_worktree_ref(const char *refname)
841 return starts_with(refname, "refs/worktree/") ||
842 starts_with(refname, "refs/bisect/") ||
843 starts_with(refname, "refs/rewritten/");
846 static int is_pseudoref_syntax(const char *refname)
848 const char *c;
850 for (c = refname; *c; c++) {
851 if (!isupper(*c) && *c != '-' && *c != '_')
852 return 0;
856 * HEAD is not a pseudoref, but it certainly uses the
857 * pseudoref syntax.
859 return 1;
862 static int is_current_worktree_ref(const char *ref) {
863 return is_pseudoref_syntax(ref) || is_per_worktree_ref(ref);
866 enum ref_worktree_type parse_worktree_ref(const char *maybe_worktree_ref,
867 const char **worktree_name, int *worktree_name_length,
868 const char **bare_refname)
870 const char *name_dummy;
871 int name_length_dummy;
872 const char *ref_dummy;
874 if (!worktree_name)
875 worktree_name = &name_dummy;
876 if (!worktree_name_length)
877 worktree_name_length = &name_length_dummy;
878 if (!bare_refname)
879 bare_refname = &ref_dummy;
881 if (skip_prefix(maybe_worktree_ref, "worktrees/", bare_refname)) {
882 const char *slash = strchr(*bare_refname, '/');
884 *worktree_name = *bare_refname;
885 if (!slash) {
886 *worktree_name_length = strlen(*worktree_name);
888 /* This is an error condition, and the caller tell because the bare_refname is "" */
889 *bare_refname = *worktree_name + *worktree_name_length;
890 return REF_WORKTREE_OTHER;
893 *worktree_name_length = slash - *bare_refname;
894 *bare_refname = slash + 1;
896 if (is_current_worktree_ref(*bare_refname))
897 return REF_WORKTREE_OTHER;
900 *worktree_name = NULL;
901 *worktree_name_length = 0;
903 if (skip_prefix(maybe_worktree_ref, "main-worktree/", bare_refname)
904 && is_current_worktree_ref(*bare_refname))
905 return REF_WORKTREE_MAIN;
907 *bare_refname = maybe_worktree_ref;
908 if (is_current_worktree_ref(maybe_worktree_ref))
909 return REF_WORKTREE_CURRENT;
911 return REF_WORKTREE_SHARED;
914 long get_files_ref_lock_timeout_ms(void)
916 static int configured = 0;
918 /* The default timeout is 100 ms: */
919 static int timeout_ms = 100;
921 if (!configured) {
922 git_config_get_int("core.filesreflocktimeout", &timeout_ms);
923 configured = 1;
926 return timeout_ms;
929 int refs_delete_ref(struct ref_store *refs, const char *msg,
930 const char *refname,
931 const struct object_id *old_oid,
932 unsigned int flags)
934 struct ref_transaction *transaction;
935 struct strbuf err = STRBUF_INIT;
937 transaction = ref_store_transaction_begin(refs, &err);
938 if (!transaction ||
939 ref_transaction_delete(transaction, refname, old_oid,
940 flags, msg, &err) ||
941 ref_transaction_commit(transaction, &err)) {
942 error("%s", err.buf);
943 ref_transaction_free(transaction);
944 strbuf_release(&err);
945 return 1;
947 ref_transaction_free(transaction);
948 strbuf_release(&err);
949 return 0;
952 int delete_ref(const char *msg, const char *refname,
953 const struct object_id *old_oid, unsigned int flags)
955 return refs_delete_ref(get_main_ref_store(the_repository), msg, refname,
956 old_oid, flags);
959 static void copy_reflog_msg(struct strbuf *sb, const char *msg)
961 char c;
962 int wasspace = 1;
964 while ((c = *msg++)) {
965 if (wasspace && isspace(c))
966 continue;
967 wasspace = isspace(c);
968 if (wasspace)
969 c = ' ';
970 strbuf_addch(sb, c);
972 strbuf_rtrim(sb);
975 static char *normalize_reflog_message(const char *msg)
977 struct strbuf sb = STRBUF_INIT;
979 if (msg && *msg)
980 copy_reflog_msg(&sb, msg);
981 return strbuf_detach(&sb, NULL);
984 int should_autocreate_reflog(const char *refname)
986 switch (log_all_ref_updates) {
987 case LOG_REFS_ALWAYS:
988 return 1;
989 case LOG_REFS_NORMAL:
990 return starts_with(refname, "refs/heads/") ||
991 starts_with(refname, "refs/remotes/") ||
992 starts_with(refname, "refs/notes/") ||
993 !strcmp(refname, "HEAD");
994 default:
995 return 0;
999 int is_branch(const char *refname)
1001 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
1004 struct read_ref_at_cb {
1005 const char *refname;
1006 timestamp_t at_time;
1007 int cnt;
1008 int reccnt;
1009 struct object_id *oid;
1010 int found_it;
1012 struct object_id ooid;
1013 struct object_id noid;
1014 int tz;
1015 timestamp_t date;
1016 char **msg;
1017 timestamp_t *cutoff_time;
1018 int *cutoff_tz;
1019 int *cutoff_cnt;
1022 static void set_read_ref_cutoffs(struct read_ref_at_cb *cb,
1023 timestamp_t timestamp, int tz, const char *message)
1025 if (cb->msg)
1026 *cb->msg = xstrdup(message);
1027 if (cb->cutoff_time)
1028 *cb->cutoff_time = timestamp;
1029 if (cb->cutoff_tz)
1030 *cb->cutoff_tz = tz;
1031 if (cb->cutoff_cnt)
1032 *cb->cutoff_cnt = cb->reccnt;
1035 static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
1036 const char *email UNUSED,
1037 timestamp_t timestamp, int tz,
1038 const char *message, void *cb_data)
1040 struct read_ref_at_cb *cb = cb_data;
1041 int reached_count;
1043 cb->tz = tz;
1044 cb->date = timestamp;
1047 * It is not possible for cb->cnt == 0 on the first iteration because
1048 * that special case is handled in read_ref_at().
1050 if (cb->cnt > 0)
1051 cb->cnt--;
1052 reached_count = cb->cnt == 0 && !is_null_oid(ooid);
1053 if (timestamp <= cb->at_time || reached_count) {
1054 set_read_ref_cutoffs(cb, timestamp, tz, message);
1056 * we have not yet updated cb->[n|o]oid so they still
1057 * hold the values for the previous record.
1059 if (!is_null_oid(&cb->ooid) && !oideq(&cb->ooid, noid))
1060 warning(_("log for ref %s has gap after %s"),
1061 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
1062 if (reached_count)
1063 oidcpy(cb->oid, ooid);
1064 else if (!is_null_oid(&cb->ooid) || cb->date == cb->at_time)
1065 oidcpy(cb->oid, noid);
1066 else if (!oideq(noid, cb->oid))
1067 warning(_("log for ref %s unexpectedly ended on %s"),
1068 cb->refname, show_date(cb->date, cb->tz,
1069 DATE_MODE(RFC2822)));
1070 cb->found_it = 1;
1072 cb->reccnt++;
1073 oidcpy(&cb->ooid, ooid);
1074 oidcpy(&cb->noid, noid);
1075 return cb->found_it;
1078 static int read_ref_at_ent_newest(struct object_id *ooid UNUSED,
1079 struct object_id *noid,
1080 const char *email UNUSED,
1081 timestamp_t timestamp, int tz,
1082 const char *message, void *cb_data)
1084 struct read_ref_at_cb *cb = cb_data;
1086 set_read_ref_cutoffs(cb, timestamp, tz, message);
1087 oidcpy(cb->oid, noid);
1088 /* We just want the first entry */
1089 return 1;
1092 static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
1093 const char *email UNUSED,
1094 timestamp_t timestamp, int tz,
1095 const char *message, void *cb_data)
1097 struct read_ref_at_cb *cb = cb_data;
1099 set_read_ref_cutoffs(cb, timestamp, tz, message);
1100 oidcpy(cb->oid, ooid);
1101 if (is_null_oid(cb->oid))
1102 oidcpy(cb->oid, noid);
1103 /* We just want the first entry */
1104 return 1;
1107 int read_ref_at(struct ref_store *refs, const char *refname,
1108 unsigned int flags, timestamp_t at_time, int cnt,
1109 struct object_id *oid, char **msg,
1110 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
1112 struct read_ref_at_cb cb;
1114 memset(&cb, 0, sizeof(cb));
1115 cb.refname = refname;
1116 cb.at_time = at_time;
1117 cb.cnt = cnt;
1118 cb.msg = msg;
1119 cb.cutoff_time = cutoff_time;
1120 cb.cutoff_tz = cutoff_tz;
1121 cb.cutoff_cnt = cutoff_cnt;
1122 cb.oid = oid;
1124 if (cb.cnt == 0) {
1125 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent_newest, &cb);
1126 return 0;
1129 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
1131 if (!cb.reccnt) {
1132 if (flags & GET_OID_QUIETLY)
1133 exit(128);
1134 else
1135 die(_("log for %s is empty"), refname);
1137 if (cb.found_it)
1138 return 0;
1140 refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
1142 return 1;
1145 struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
1146 struct strbuf *err)
1148 struct ref_transaction *tr;
1149 assert(err);
1151 CALLOC_ARRAY(tr, 1);
1152 tr->ref_store = refs;
1153 return tr;
1156 struct ref_transaction *ref_transaction_begin(struct strbuf *err)
1158 return ref_store_transaction_begin(get_main_ref_store(the_repository), err);
1161 void ref_transaction_free(struct ref_transaction *transaction)
1163 size_t i;
1165 if (!transaction)
1166 return;
1168 switch (transaction->state) {
1169 case REF_TRANSACTION_OPEN:
1170 case REF_TRANSACTION_CLOSED:
1171 /* OK */
1172 break;
1173 case REF_TRANSACTION_PREPARED:
1174 BUG("free called on a prepared reference transaction");
1175 break;
1176 default:
1177 BUG("unexpected reference transaction state");
1178 break;
1181 for (i = 0; i < transaction->nr; i++) {
1182 free(transaction->updates[i]->msg);
1183 free(transaction->updates[i]);
1185 free(transaction->updates);
1186 free(transaction);
1189 struct ref_update *ref_transaction_add_update(
1190 struct ref_transaction *transaction,
1191 const char *refname, unsigned int flags,
1192 const struct object_id *new_oid,
1193 const struct object_id *old_oid,
1194 const char *msg)
1196 struct ref_update *update;
1198 if (transaction->state != REF_TRANSACTION_OPEN)
1199 BUG("update called for transaction that is not open");
1201 FLEX_ALLOC_STR(update, refname, refname);
1202 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
1203 transaction->updates[transaction->nr++] = update;
1205 update->flags = flags;
1207 if (flags & REF_HAVE_NEW)
1208 oidcpy(&update->new_oid, new_oid);
1209 if (flags & REF_HAVE_OLD)
1210 oidcpy(&update->old_oid, old_oid);
1211 update->msg = normalize_reflog_message(msg);
1212 return update;
1215 int ref_transaction_update(struct ref_transaction *transaction,
1216 const char *refname,
1217 const struct object_id *new_oid,
1218 const struct object_id *old_oid,
1219 unsigned int flags, const char *msg,
1220 struct strbuf *err)
1222 assert(err);
1224 if (!(flags & REF_SKIP_REFNAME_VERIFICATION) &&
1225 ((new_oid && !is_null_oid(new_oid)) ?
1226 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
1227 !refname_is_safe(refname))) {
1228 strbuf_addf(err, _("refusing to update ref with bad name '%s'"),
1229 refname);
1230 return -1;
1233 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
1234 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
1237 * Clear flags outside the allowed set; this should be a noop because
1238 * of the BUG() check above, but it works around a -Wnonnull warning
1239 * with some versions of "gcc -O3".
1241 flags &= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS;
1243 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
1245 ref_transaction_add_update(transaction, refname, flags,
1246 new_oid, old_oid, msg);
1247 return 0;
1250 int ref_transaction_create(struct ref_transaction *transaction,
1251 const char *refname,
1252 const struct object_id *new_oid,
1253 unsigned int flags, const char *msg,
1254 struct strbuf *err)
1256 if (!new_oid || is_null_oid(new_oid)) {
1257 strbuf_addf(err, "'%s' has a null OID", refname);
1258 return 1;
1260 return ref_transaction_update(transaction, refname, new_oid,
1261 null_oid(), flags, msg, err);
1264 int ref_transaction_delete(struct ref_transaction *transaction,
1265 const char *refname,
1266 const struct object_id *old_oid,
1267 unsigned int flags, const char *msg,
1268 struct strbuf *err)
1270 if (old_oid && is_null_oid(old_oid))
1271 BUG("delete called with old_oid set to zeros");
1272 return ref_transaction_update(transaction, refname,
1273 null_oid(), old_oid,
1274 flags, msg, err);
1277 int ref_transaction_verify(struct ref_transaction *transaction,
1278 const char *refname,
1279 const struct object_id *old_oid,
1280 unsigned int flags,
1281 struct strbuf *err)
1283 if (!old_oid)
1284 BUG("verify called with old_oid set to NULL");
1285 return ref_transaction_update(transaction, refname,
1286 NULL, old_oid,
1287 flags, NULL, err);
1290 int refs_update_ref(struct ref_store *refs, const char *msg,
1291 const char *refname, const struct object_id *new_oid,
1292 const struct object_id *old_oid, unsigned int flags,
1293 enum action_on_err onerr)
1295 struct ref_transaction *t = NULL;
1296 struct strbuf err = STRBUF_INIT;
1297 int ret = 0;
1299 t = ref_store_transaction_begin(refs, &err);
1300 if (!t ||
1301 ref_transaction_update(t, refname, new_oid, old_oid, flags, msg,
1302 &err) ||
1303 ref_transaction_commit(t, &err)) {
1304 ret = 1;
1305 ref_transaction_free(t);
1307 if (ret) {
1308 const char *str = _("update_ref failed for ref '%s': %s");
1310 switch (onerr) {
1311 case UPDATE_REFS_MSG_ON_ERR:
1312 error(str, refname, err.buf);
1313 break;
1314 case UPDATE_REFS_DIE_ON_ERR:
1315 die(str, refname, err.buf);
1316 break;
1317 case UPDATE_REFS_QUIET_ON_ERR:
1318 break;
1320 strbuf_release(&err);
1321 return 1;
1323 strbuf_release(&err);
1324 if (t)
1325 ref_transaction_free(t);
1326 return 0;
1329 int update_ref(const char *msg, const char *refname,
1330 const struct object_id *new_oid,
1331 const struct object_id *old_oid,
1332 unsigned int flags, enum action_on_err onerr)
1334 return refs_update_ref(get_main_ref_store(the_repository), msg, refname, new_oid,
1335 old_oid, flags, onerr);
1339 * Check that the string refname matches a rule of the form
1340 * "{prefix}%.*s{suffix}". So "foo/bar/baz" would match the rule
1341 * "foo/%.*s/baz", and return the string "bar".
1343 static const char *match_parse_rule(const char *refname, const char *rule,
1344 size_t *len)
1347 * Check that rule matches refname up to the first percent in the rule.
1348 * We can bail immediately if not, but otherwise we leave "rule" at the
1349 * %-placeholder, and "refname" at the start of the potential matched
1350 * name.
1352 while (*rule != '%') {
1353 if (!*rule)
1354 BUG("rev-parse rule did not have percent");
1355 if (*refname++ != *rule++)
1356 return NULL;
1360 * Check that our "%" is the expected placeholder. This assumes there
1361 * are no other percents (placeholder or quoted) in the string, but
1362 * that is sufficient for our rev-parse rules.
1364 if (!skip_prefix(rule, "%.*s", &rule))
1365 return NULL;
1368 * And now check that our suffix (if any) matches.
1370 if (!strip_suffix(refname, rule, len))
1371 return NULL;
1373 return refname; /* len set by strip_suffix() */
1376 char *refs_shorten_unambiguous_ref(struct ref_store *refs,
1377 const char *refname, int strict)
1379 int i;
1380 struct strbuf resolved_buf = STRBUF_INIT;
1382 /* skip first rule, it will always match */
1383 for (i = NUM_REV_PARSE_RULES - 1; i > 0 ; --i) {
1384 int j;
1385 int rules_to_fail = i;
1386 const char *short_name;
1387 size_t short_name_len;
1389 short_name = match_parse_rule(refname, ref_rev_parse_rules[i],
1390 &short_name_len);
1391 if (!short_name)
1392 continue;
1395 * in strict mode, all (except the matched one) rules
1396 * must fail to resolve to a valid non-ambiguous ref
1398 if (strict)
1399 rules_to_fail = NUM_REV_PARSE_RULES;
1402 * check if the short name resolves to a valid ref,
1403 * but use only rules prior to the matched one
1405 for (j = 0; j < rules_to_fail; j++) {
1406 const char *rule = ref_rev_parse_rules[j];
1408 /* skip matched rule */
1409 if (i == j)
1410 continue;
1413 * the short name is ambiguous, if it resolves
1414 * (with this previous rule) to a valid ref
1415 * read_ref() returns 0 on success
1417 strbuf_reset(&resolved_buf);
1418 strbuf_addf(&resolved_buf, rule,
1419 cast_size_t_to_int(short_name_len),
1420 short_name);
1421 if (refs_ref_exists(refs, resolved_buf.buf))
1422 break;
1426 * short name is non-ambiguous if all previous rules
1427 * haven't resolved to a valid ref
1429 if (j == rules_to_fail) {
1430 strbuf_release(&resolved_buf);
1431 return xmemdupz(short_name, short_name_len);
1435 strbuf_release(&resolved_buf);
1436 return xstrdup(refname);
1439 char *shorten_unambiguous_ref(const char *refname, int strict)
1441 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
1442 refname, strict);
1445 int parse_hide_refs_config(const char *var, const char *value, const char *section,
1446 struct strvec *hide_refs)
1448 const char *key;
1449 if (!strcmp("transfer.hiderefs", var) ||
1450 (!parse_config_key(var, section, NULL, NULL, &key) &&
1451 !strcmp(key, "hiderefs"))) {
1452 char *ref;
1453 int len;
1455 if (!value)
1456 return config_error_nonbool(var);
1458 /* drop const to remove trailing '/' characters */
1459 ref = (char *)strvec_push(hide_refs, value);
1460 len = strlen(ref);
1461 while (len && ref[len - 1] == '/')
1462 ref[--len] = '\0';
1464 return 0;
1467 int ref_is_hidden(const char *refname, const char *refname_full,
1468 const struct strvec *hide_refs)
1470 int i;
1472 for (i = hide_refs->nr - 1; i >= 0; i--) {
1473 const char *match = hide_refs->v[i];
1474 const char *subject;
1475 int neg = 0;
1476 const char *p;
1478 if (*match == '!') {
1479 neg = 1;
1480 match++;
1483 if (*match == '^') {
1484 subject = refname_full;
1485 match++;
1486 } else {
1487 subject = refname;
1490 /* refname can be NULL when namespaces are used. */
1491 if (subject &&
1492 skip_prefix(subject, match, &p) &&
1493 (!*p || *p == '/'))
1494 return !neg;
1496 return 0;
1499 const char **hidden_refs_to_excludes(const struct strvec *hide_refs)
1501 const char **pattern;
1502 for (pattern = hide_refs->v; *pattern; pattern++) {
1504 * We can't feed any excludes from hidden refs config
1505 * sections, since later rules may override previous
1506 * ones. For example, with rules "refs/foo" and
1507 * "!refs/foo/bar", we should show "refs/foo/bar" (and
1508 * everything underneath it), but the earlier exclusion
1509 * would cause us to skip all of "refs/foo". We
1510 * likewise don't implement the namespace stripping
1511 * required for '^' rules.
1513 * Both are possible to do, but complicated, so avoid
1514 * populating the jump list at all if we see either of
1515 * these patterns.
1517 if (**pattern == '!' || **pattern == '^')
1518 return NULL;
1520 return hide_refs->v;
1523 const char *find_descendant_ref(const char *dirname,
1524 const struct string_list *extras,
1525 const struct string_list *skip)
1527 int pos;
1529 if (!extras)
1530 return NULL;
1533 * Look at the place where dirname would be inserted into
1534 * extras. If there is an entry at that position that starts
1535 * with dirname (remember, dirname includes the trailing
1536 * slash) and is not in skip, then we have a conflict.
1538 for (pos = string_list_find_insert_index(extras, dirname, 0);
1539 pos < extras->nr; pos++) {
1540 const char *extra_refname = extras->items[pos].string;
1542 if (!starts_with(extra_refname, dirname))
1543 break;
1545 if (!skip || !string_list_has_string(skip, extra_refname))
1546 return extra_refname;
1548 return NULL;
1551 int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1553 struct object_id oid;
1554 int flag;
1556 if (refs_resolve_ref_unsafe(refs, "HEAD", RESOLVE_REF_READING,
1557 &oid, &flag))
1558 return fn("HEAD", &oid, flag, cb_data);
1560 return 0;
1563 int head_ref(each_ref_fn fn, void *cb_data)
1565 return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
1568 struct ref_iterator *refs_ref_iterator_begin(
1569 struct ref_store *refs,
1570 const char *prefix,
1571 const char **exclude_patterns,
1572 int trim,
1573 enum do_for_each_ref_flags flags)
1575 struct ref_iterator *iter;
1577 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
1578 static int ref_paranoia = -1;
1580 if (ref_paranoia < 0)
1581 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 1);
1582 if (ref_paranoia) {
1583 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1584 flags |= DO_FOR_EACH_OMIT_DANGLING_SYMREFS;
1588 iter = refs->be->iterator_begin(refs, prefix, exclude_patterns, flags);
1590 * `iterator_begin()` already takes care of prefix, but we
1591 * might need to do some trimming:
1593 if (trim)
1594 iter = prefix_ref_iterator_begin(iter, "", trim);
1596 /* Sanity check for subclasses: */
1597 if (!iter->ordered)
1598 BUG("reference iterator is not ordered");
1600 return iter;
1604 * Call fn for each reference in the specified submodule for which the
1605 * refname begins with prefix. If trim is non-zero, then trim that
1606 * many characters off the beginning of each refname before passing
1607 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1608 * include broken references in the iteration. If fn ever returns a
1609 * non-zero value, stop the iteration and return that value;
1610 * otherwise, return 0.
1612 static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1613 each_repo_ref_fn fn, int trim, int flags,
1614 void *cb_data)
1616 struct ref_iterator *iter;
1617 struct ref_store *refs = get_main_ref_store(r);
1619 if (!refs)
1620 return 0;
1622 iter = refs_ref_iterator_begin(refs, prefix, NULL, trim, flags);
1624 return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1627 struct do_for_each_ref_help {
1628 each_ref_fn *fn;
1629 void *cb_data;
1632 static int do_for_each_ref_helper(struct repository *r UNUSED,
1633 const char *refname,
1634 const struct object_id *oid,
1635 int flags,
1636 void *cb_data)
1638 struct do_for_each_ref_help *hp = cb_data;
1640 return hp->fn(refname, oid, flags, hp->cb_data);
1643 static int do_for_each_ref(struct ref_store *refs, const char *prefix,
1644 const char **exclude_patterns,
1645 each_ref_fn fn, int trim,
1646 enum do_for_each_ref_flags flags, void *cb_data)
1648 struct ref_iterator *iter;
1649 struct do_for_each_ref_help hp = { fn, cb_data };
1651 if (!refs)
1652 return 0;
1654 iter = refs_ref_iterator_begin(refs, prefix, exclude_patterns, trim,
1655 flags);
1657 return do_for_each_repo_ref_iterator(the_repository, iter,
1658 do_for_each_ref_helper, &hp);
1661 int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1663 return do_for_each_ref(refs, "", NULL, fn, 0, 0, cb_data);
1666 int for_each_ref(each_ref_fn fn, void *cb_data)
1668 return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
1671 int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1672 each_ref_fn fn, void *cb_data)
1674 return do_for_each_ref(refs, prefix, NULL, fn, strlen(prefix), 0, cb_data);
1677 int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1679 return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
1682 int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1684 return do_for_each_ref(get_main_ref_store(the_repository),
1685 prefix, NULL, fn, 0, 0, cb_data);
1688 int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
1689 const char **exclude_patterns,
1690 each_ref_fn fn, void *cb_data)
1692 return do_for_each_ref(refs, prefix, exclude_patterns, fn, 0, 0, cb_data);
1695 int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
1697 const char *git_replace_ref_base = ref_namespace[NAMESPACE_REPLACE].ref;
1698 return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1699 strlen(git_replace_ref_base),
1700 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1703 int for_each_namespaced_ref(const char **exclude_patterns,
1704 each_ref_fn fn, void *cb_data)
1706 struct strbuf buf = STRBUF_INIT;
1707 int ret;
1708 strbuf_addf(&buf, "%srefs/", get_git_namespace());
1709 ret = do_for_each_ref(get_main_ref_store(the_repository),
1710 buf.buf, exclude_patterns, fn, 0, 0, cb_data);
1711 strbuf_release(&buf);
1712 return ret;
1715 int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1717 return do_for_each_ref(refs, "", NULL, fn, 0,
1718 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1721 int for_each_rawref(each_ref_fn fn, void *cb_data)
1723 return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
1726 static int qsort_strcmp(const void *va, const void *vb)
1728 const char *a = *(const char **)va;
1729 const char *b = *(const char **)vb;
1731 return strcmp(a, b);
1734 static void find_longest_prefixes_1(struct string_list *out,
1735 struct strbuf *prefix,
1736 const char **patterns, size_t nr)
1738 size_t i;
1740 for (i = 0; i < nr; i++) {
1741 char c = patterns[i][prefix->len];
1742 if (!c || is_glob_special(c)) {
1743 string_list_append(out, prefix->buf);
1744 return;
1748 i = 0;
1749 while (i < nr) {
1750 size_t end;
1753 * Set "end" to the index of the element _after_ the last one
1754 * in our group.
1756 for (end = i + 1; end < nr; end++) {
1757 if (patterns[i][prefix->len] != patterns[end][prefix->len])
1758 break;
1761 strbuf_addch(prefix, patterns[i][prefix->len]);
1762 find_longest_prefixes_1(out, prefix, patterns + i, end - i);
1763 strbuf_setlen(prefix, prefix->len - 1);
1765 i = end;
1769 static void find_longest_prefixes(struct string_list *out,
1770 const char **patterns)
1772 struct strvec sorted = STRVEC_INIT;
1773 struct strbuf prefix = STRBUF_INIT;
1775 strvec_pushv(&sorted, patterns);
1776 QSORT(sorted.v, sorted.nr, qsort_strcmp);
1778 find_longest_prefixes_1(out, &prefix, sorted.v, sorted.nr);
1780 strvec_clear(&sorted);
1781 strbuf_release(&prefix);
1784 int refs_for_each_fullref_in_prefixes(struct ref_store *ref_store,
1785 const char *namespace,
1786 const char **patterns,
1787 const char **exclude_patterns,
1788 each_ref_fn fn, void *cb_data)
1790 struct string_list prefixes = STRING_LIST_INIT_DUP;
1791 struct string_list_item *prefix;
1792 struct strbuf buf = STRBUF_INIT;
1793 int ret = 0, namespace_len;
1795 find_longest_prefixes(&prefixes, patterns);
1797 if (namespace)
1798 strbuf_addstr(&buf, namespace);
1799 namespace_len = buf.len;
1801 for_each_string_list_item(prefix, &prefixes) {
1802 strbuf_addstr(&buf, prefix->string);
1803 ret = refs_for_each_fullref_in(ref_store, buf.buf,
1804 exclude_patterns, fn, cb_data);
1805 if (ret)
1806 break;
1807 strbuf_setlen(&buf, namespace_len);
1810 string_list_clear(&prefixes, 0);
1811 strbuf_release(&buf);
1812 return ret;
1815 static int refs_read_special_head(struct ref_store *ref_store,
1816 const char *refname, struct object_id *oid,
1817 struct strbuf *referent, unsigned int *type,
1818 int *failure_errno)
1820 struct strbuf full_path = STRBUF_INIT;
1821 struct strbuf content = STRBUF_INIT;
1822 int result = -1;
1823 strbuf_addf(&full_path, "%s/%s", ref_store->gitdir, refname);
1825 if (strbuf_read_file(&content, full_path.buf, 0) < 0) {
1826 *failure_errno = errno;
1827 goto done;
1830 result = parse_loose_ref_contents(content.buf, oid, referent, type,
1831 failure_errno);
1833 done:
1834 strbuf_release(&full_path);
1835 strbuf_release(&content);
1836 return result;
1839 static int is_special_ref(const char *refname)
1842 * Special references are refs that have different semantics compared
1843 * to "normal" refs. These refs can thus not be stored in the ref
1844 * backend, but must always be accessed via the filesystem. The
1845 * following refs are special:
1847 * - FETCH_HEAD may contain multiple object IDs, and each one of them
1848 * carries additional metadata like where it came from.
1850 * - MERGE_HEAD may contain multiple object IDs when merging multiple
1851 * heads.
1853 * Reading, writing or deleting references must consistently go either
1854 * through the filesystem (special refs) or through the reference
1855 * backend (normal ones).
1857 static const char * const special_refs[] = {
1858 "FETCH_HEAD",
1859 "MERGE_HEAD",
1861 size_t i;
1863 for (i = 0; i < ARRAY_SIZE(special_refs); i++)
1864 if (!strcmp(refname, special_refs[i]))
1865 return 1;
1867 return 0;
1870 int refs_read_raw_ref(struct ref_store *ref_store, const char *refname,
1871 struct object_id *oid, struct strbuf *referent,
1872 unsigned int *type, int *failure_errno)
1874 assert(failure_errno);
1875 if (is_special_ref(refname))
1876 return refs_read_special_head(ref_store, refname, oid, referent,
1877 type, failure_errno);
1879 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent,
1880 type, failure_errno);
1883 int refs_read_symbolic_ref(struct ref_store *ref_store, const char *refname,
1884 struct strbuf *referent)
1886 return ref_store->be->read_symbolic_ref(ref_store, refname, referent);
1889 const char *refs_resolve_ref_unsafe(struct ref_store *refs,
1890 const char *refname,
1891 int resolve_flags,
1892 struct object_id *oid,
1893 int *flags)
1895 static struct strbuf sb_refname = STRBUF_INIT;
1896 struct object_id unused_oid;
1897 int unused_flags;
1898 int symref_count;
1900 if (!oid)
1901 oid = &unused_oid;
1902 if (!flags)
1903 flags = &unused_flags;
1905 *flags = 0;
1907 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1908 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1909 !refname_is_safe(refname))
1910 return NULL;
1913 * repo_dwim_ref() uses REF_ISBROKEN to distinguish between
1914 * missing refs and refs that were present but invalid,
1915 * to complain about the latter to stderr.
1917 * We don't know whether the ref exists, so don't set
1918 * REF_ISBROKEN yet.
1920 *flags |= REF_BAD_NAME;
1923 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1924 unsigned int read_flags = 0;
1925 int failure_errno;
1927 if (refs_read_raw_ref(refs, refname, oid, &sb_refname,
1928 &read_flags, &failure_errno)) {
1929 *flags |= read_flags;
1931 /* In reading mode, refs must eventually resolve */
1932 if (resolve_flags & RESOLVE_REF_READING)
1933 return NULL;
1936 * Otherwise a missing ref is OK. But the files backend
1937 * may show errors besides ENOENT if there are
1938 * similarly-named refs.
1940 if (failure_errno != ENOENT &&
1941 failure_errno != EISDIR &&
1942 failure_errno != ENOTDIR)
1943 return NULL;
1945 oidclr(oid);
1946 if (*flags & REF_BAD_NAME)
1947 *flags |= REF_ISBROKEN;
1948 return refname;
1951 *flags |= read_flags;
1953 if (!(read_flags & REF_ISSYMREF)) {
1954 if (*flags & REF_BAD_NAME) {
1955 oidclr(oid);
1956 *flags |= REF_ISBROKEN;
1958 return refname;
1961 refname = sb_refname.buf;
1962 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1963 oidclr(oid);
1964 return refname;
1966 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1967 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1968 !refname_is_safe(refname))
1969 return NULL;
1971 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1975 return NULL;
1978 /* backend functions */
1979 int refs_init_db(struct ref_store *refs, int flags, struct strbuf *err)
1981 return refs->be->init_db(refs, flags, err);
1984 const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1985 struct object_id *oid, int *flags)
1987 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
1988 resolve_flags, oid, flags);
1991 int resolve_gitlink_ref(const char *submodule, const char *refname,
1992 struct object_id *oid)
1994 struct ref_store *refs;
1995 int flags;
1997 refs = get_submodule_ref_store(submodule);
1999 if (!refs)
2000 return -1;
2002 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
2003 is_null_oid(oid))
2004 return -1;
2005 return 0;
2008 struct ref_store_hash_entry
2010 struct hashmap_entry ent;
2012 struct ref_store *refs;
2014 /* NUL-terminated identifier of the ref store: */
2015 char name[FLEX_ARRAY];
2018 static int ref_store_hash_cmp(const void *cmp_data UNUSED,
2019 const struct hashmap_entry *eptr,
2020 const struct hashmap_entry *entry_or_key,
2021 const void *keydata)
2023 const struct ref_store_hash_entry *e1, *e2;
2024 const char *name;
2026 e1 = container_of(eptr, const struct ref_store_hash_entry, ent);
2027 e2 = container_of(entry_or_key, const struct ref_store_hash_entry, ent);
2028 name = keydata ? keydata : e2->name;
2030 return strcmp(e1->name, name);
2033 static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
2034 const char *name, struct ref_store *refs)
2036 struct ref_store_hash_entry *entry;
2038 FLEX_ALLOC_STR(entry, name, name);
2039 hashmap_entry_init(&entry->ent, strhash(name));
2040 entry->refs = refs;
2041 return entry;
2044 /* A hashmap of ref_stores, stored by submodule name: */
2045 static struct hashmap submodule_ref_stores;
2047 /* A hashmap of ref_stores, stored by worktree id: */
2048 static struct hashmap worktree_ref_stores;
2051 * Look up a ref store by name. If that ref_store hasn't been
2052 * registered yet, return NULL.
2054 static struct ref_store *lookup_ref_store_map(struct hashmap *map,
2055 const char *name)
2057 struct ref_store_hash_entry *entry;
2058 unsigned int hash;
2060 if (!map->tablesize)
2061 /* It's initialized on demand in register_ref_store(). */
2062 return NULL;
2064 hash = strhash(name);
2065 entry = hashmap_get_entry_from_hash(map, hash, name,
2066 struct ref_store_hash_entry, ent);
2067 return entry ? entry->refs : NULL;
2071 * Create, record, and return a ref_store instance for the specified
2072 * gitdir.
2074 static struct ref_store *ref_store_init(struct repository *repo,
2075 const char *gitdir,
2076 unsigned int flags)
2078 const struct ref_storage_be *be;
2079 struct ref_store *refs;
2081 be = find_ref_storage_backend(repo->ref_storage_format);
2082 if (!be)
2083 BUG("reference backend is unknown");
2085 refs = be->init(repo, gitdir, flags);
2086 return refs;
2089 struct ref_store *get_main_ref_store(struct repository *r)
2091 if (r->refs_private)
2092 return r->refs_private;
2094 if (!r->gitdir)
2095 BUG("attempting to get main_ref_store outside of repository");
2097 r->refs_private = ref_store_init(r, r->gitdir, REF_STORE_ALL_CAPS);
2098 r->refs_private = maybe_debug_wrap_ref_store(r->gitdir, r->refs_private);
2099 return r->refs_private;
2103 * Associate a ref store with a name. It is a fatal error to call this
2104 * function twice for the same name.
2106 static void register_ref_store_map(struct hashmap *map,
2107 const char *type,
2108 struct ref_store *refs,
2109 const char *name)
2111 struct ref_store_hash_entry *entry;
2113 if (!map->tablesize)
2114 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
2116 entry = alloc_ref_store_hash_entry(name, refs);
2117 if (hashmap_put(map, &entry->ent))
2118 BUG("%s ref_store '%s' initialized twice", type, name);
2121 struct ref_store *get_submodule_ref_store(const char *submodule)
2123 struct strbuf submodule_sb = STRBUF_INIT;
2124 struct ref_store *refs;
2125 char *to_free = NULL;
2126 size_t len;
2127 struct repository *subrepo;
2129 if (!submodule)
2130 return NULL;
2132 len = strlen(submodule);
2133 while (len && is_dir_sep(submodule[len - 1]))
2134 len--;
2135 if (!len)
2136 return NULL;
2138 if (submodule[len])
2139 /* We need to strip off one or more trailing slashes */
2140 submodule = to_free = xmemdupz(submodule, len);
2142 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
2143 if (refs)
2144 goto done;
2146 strbuf_addstr(&submodule_sb, submodule);
2147 if (!is_nonbare_repository_dir(&submodule_sb))
2148 goto done;
2150 if (submodule_to_gitdir(&submodule_sb, submodule))
2151 goto done;
2153 subrepo = xmalloc(sizeof(*subrepo));
2155 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2156 * superprojects other than the_repository. This probably should be
2157 * done by making it take a struct repository * parameter instead of a
2158 * submodule path.
2160 if (repo_submodule_init(subrepo, the_repository, submodule,
2161 null_oid())) {
2162 free(subrepo);
2163 goto done;
2165 refs = ref_store_init(subrepo, submodule_sb.buf,
2166 REF_STORE_READ | REF_STORE_ODB);
2167 register_ref_store_map(&submodule_ref_stores, "submodule",
2168 refs, submodule);
2170 done:
2171 strbuf_release(&submodule_sb);
2172 free(to_free);
2174 return refs;
2177 struct ref_store *get_worktree_ref_store(const struct worktree *wt)
2179 struct ref_store *refs;
2180 const char *id;
2182 if (wt->is_current)
2183 return get_main_ref_store(the_repository);
2185 id = wt->id ? wt->id : "/";
2186 refs = lookup_ref_store_map(&worktree_ref_stores, id);
2187 if (refs)
2188 return refs;
2190 if (wt->id)
2191 refs = ref_store_init(the_repository,
2192 git_common_path("worktrees/%s", wt->id),
2193 REF_STORE_ALL_CAPS);
2194 else
2195 refs = ref_store_init(the_repository,
2196 get_git_common_dir(),
2197 REF_STORE_ALL_CAPS);
2199 if (refs)
2200 register_ref_store_map(&worktree_ref_stores, "worktree",
2201 refs, id);
2202 return refs;
2205 void base_ref_store_init(struct ref_store *refs, struct repository *repo,
2206 const char *path, const struct ref_storage_be *be)
2208 refs->be = be;
2209 refs->repo = repo;
2210 refs->gitdir = xstrdup(path);
2213 /* backend functions */
2214 int refs_pack_refs(struct ref_store *refs, struct pack_refs_opts *opts)
2216 return refs->be->pack_refs(refs, opts);
2219 int peel_iterated_oid(const struct object_id *base, struct object_id *peeled)
2221 if (current_ref_iter &&
2222 (current_ref_iter->oid == base ||
2223 oideq(current_ref_iter->oid, base)))
2224 return ref_iterator_peel(current_ref_iter, peeled);
2226 return peel_object(base, peeled) ? -1 : 0;
2229 int refs_create_symref(struct ref_store *refs,
2230 const char *ref_target,
2231 const char *refs_heads_master,
2232 const char *logmsg)
2234 char *msg;
2235 int retval;
2237 msg = normalize_reflog_message(logmsg);
2238 retval = refs->be->create_symref(refs, ref_target, refs_heads_master,
2239 msg);
2240 free(msg);
2241 return retval;
2244 int create_symref(const char *ref_target, const char *refs_heads_master,
2245 const char *logmsg)
2247 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
2248 refs_heads_master, logmsg);
2251 int ref_update_reject_duplicates(struct string_list *refnames,
2252 struct strbuf *err)
2254 size_t i, n = refnames->nr;
2256 assert(err);
2258 for (i = 1; i < n; i++) {
2259 int cmp = strcmp(refnames->items[i - 1].string,
2260 refnames->items[i].string);
2262 if (!cmp) {
2263 strbuf_addf(err,
2264 _("multiple updates for ref '%s' not allowed"),
2265 refnames->items[i].string);
2266 return 1;
2267 } else if (cmp > 0) {
2268 BUG("ref_update_reject_duplicates() received unsorted list");
2271 return 0;
2274 static int run_transaction_hook(struct ref_transaction *transaction,
2275 const char *state)
2277 struct child_process proc = CHILD_PROCESS_INIT;
2278 struct strbuf buf = STRBUF_INIT;
2279 const char *hook;
2280 int ret = 0, i;
2282 hook = find_hook("reference-transaction");
2283 if (!hook)
2284 return ret;
2286 strvec_pushl(&proc.args, hook, state, NULL);
2287 proc.in = -1;
2288 proc.stdout_to_stderr = 1;
2289 proc.trace2_hook_name = "reference-transaction";
2291 ret = start_command(&proc);
2292 if (ret)
2293 return ret;
2295 sigchain_push(SIGPIPE, SIG_IGN);
2297 for (i = 0; i < transaction->nr; i++) {
2298 struct ref_update *update = transaction->updates[i];
2300 strbuf_reset(&buf);
2301 strbuf_addf(&buf, "%s %s %s\n",
2302 oid_to_hex(&update->old_oid),
2303 oid_to_hex(&update->new_oid),
2304 update->refname);
2306 if (write_in_full(proc.in, buf.buf, buf.len) < 0) {
2307 if (errno != EPIPE) {
2308 /* Don't leak errno outside this API */
2309 errno = 0;
2310 ret = -1;
2312 break;
2316 close(proc.in);
2317 sigchain_pop(SIGPIPE);
2318 strbuf_release(&buf);
2320 ret |= finish_command(&proc);
2321 return ret;
2324 int ref_transaction_prepare(struct ref_transaction *transaction,
2325 struct strbuf *err)
2327 struct ref_store *refs = transaction->ref_store;
2328 int ret;
2330 switch (transaction->state) {
2331 case REF_TRANSACTION_OPEN:
2332 /* Good. */
2333 break;
2334 case REF_TRANSACTION_PREPARED:
2335 BUG("prepare called twice on reference transaction");
2336 break;
2337 case REF_TRANSACTION_CLOSED:
2338 BUG("prepare called on a closed reference transaction");
2339 break;
2340 default:
2341 BUG("unexpected reference transaction state");
2342 break;
2345 if (refs->repo->objects->odb->disable_ref_updates) {
2346 strbuf_addstr(err,
2347 _("ref updates forbidden inside quarantine environment"));
2348 return -1;
2351 ret = refs->be->transaction_prepare(refs, transaction, err);
2352 if (ret)
2353 return ret;
2355 ret = run_transaction_hook(transaction, "prepared");
2356 if (ret) {
2357 ref_transaction_abort(transaction, err);
2358 die(_("ref updates aborted by hook"));
2361 return 0;
2364 int ref_transaction_abort(struct ref_transaction *transaction,
2365 struct strbuf *err)
2367 struct ref_store *refs = transaction->ref_store;
2368 int ret = 0;
2370 switch (transaction->state) {
2371 case REF_TRANSACTION_OPEN:
2372 /* No need to abort explicitly. */
2373 break;
2374 case REF_TRANSACTION_PREPARED:
2375 ret = refs->be->transaction_abort(refs, transaction, err);
2376 break;
2377 case REF_TRANSACTION_CLOSED:
2378 BUG("abort called on a closed reference transaction");
2379 break;
2380 default:
2381 BUG("unexpected reference transaction state");
2382 break;
2385 run_transaction_hook(transaction, "aborted");
2387 ref_transaction_free(transaction);
2388 return ret;
2391 int ref_transaction_commit(struct ref_transaction *transaction,
2392 struct strbuf *err)
2394 struct ref_store *refs = transaction->ref_store;
2395 int ret;
2397 switch (transaction->state) {
2398 case REF_TRANSACTION_OPEN:
2399 /* Need to prepare first. */
2400 ret = ref_transaction_prepare(transaction, err);
2401 if (ret)
2402 return ret;
2403 break;
2404 case REF_TRANSACTION_PREPARED:
2405 /* Fall through to finish. */
2406 break;
2407 case REF_TRANSACTION_CLOSED:
2408 BUG("commit called on a closed reference transaction");
2409 break;
2410 default:
2411 BUG("unexpected reference transaction state");
2412 break;
2415 ret = refs->be->transaction_finish(refs, transaction, err);
2416 if (!ret)
2417 run_transaction_hook(transaction, "committed");
2418 return ret;
2421 int refs_verify_refname_available(struct ref_store *refs,
2422 const char *refname,
2423 const struct string_list *extras,
2424 const struct string_list *skip,
2425 struct strbuf *err)
2427 const char *slash;
2428 const char *extra_refname;
2429 struct strbuf dirname = STRBUF_INIT;
2430 struct strbuf referent = STRBUF_INIT;
2431 struct object_id oid;
2432 unsigned int type;
2433 struct ref_iterator *iter;
2434 int ok;
2435 int ret = -1;
2438 * For the sake of comments in this function, suppose that
2439 * refname is "refs/foo/bar".
2442 assert(err);
2444 strbuf_grow(&dirname, strlen(refname) + 1);
2445 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
2447 * Just saying "Is a directory" when we e.g. can't
2448 * lock some multi-level ref isn't very informative,
2449 * the user won't be told *what* is a directory, so
2450 * let's not use strerror() below.
2452 int ignore_errno;
2453 /* Expand dirname to the new prefix, not including the trailing slash: */
2454 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2457 * We are still at a leading dir of the refname (e.g.,
2458 * "refs/foo"; if there is a reference with that name,
2459 * it is a conflict, *unless* it is in skip.
2461 if (skip && string_list_has_string(skip, dirname.buf))
2462 continue;
2464 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent,
2465 &type, &ignore_errno)) {
2466 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2467 dirname.buf, refname);
2468 goto cleanup;
2471 if (extras && string_list_has_string(extras, dirname.buf)) {
2472 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2473 refname, dirname.buf);
2474 goto cleanup;
2479 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2480 * There is no point in searching for a reference with that
2481 * name, because a refname isn't considered to conflict with
2482 * itself. But we still need to check for references whose
2483 * names are in the "refs/foo/bar/" namespace, because they
2484 * *do* conflict.
2486 strbuf_addstr(&dirname, refname + dirname.len);
2487 strbuf_addch(&dirname, '/');
2489 iter = refs_ref_iterator_begin(refs, dirname.buf, NULL, 0,
2490 DO_FOR_EACH_INCLUDE_BROKEN);
2491 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2492 if (skip &&
2493 string_list_has_string(skip, iter->refname))
2494 continue;
2496 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2497 iter->refname, refname);
2498 ref_iterator_abort(iter);
2499 goto cleanup;
2502 if (ok != ITER_DONE)
2503 BUG("error while iterating over references");
2505 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2506 if (extra_refname)
2507 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2508 refname, extra_refname);
2509 else
2510 ret = 0;
2512 cleanup:
2513 strbuf_release(&referent);
2514 strbuf_release(&dirname);
2515 return ret;
2518 int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2520 struct ref_iterator *iter;
2521 struct do_for_each_ref_help hp = { fn, cb_data };
2523 iter = refs->be->reflog_iterator_begin(refs);
2525 return do_for_each_repo_ref_iterator(the_repository, iter,
2526 do_for_each_ref_helper, &hp);
2529 int for_each_reflog(each_ref_fn fn, void *cb_data)
2531 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
2534 int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2535 const char *refname,
2536 each_reflog_ent_fn fn,
2537 void *cb_data)
2539 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2540 fn, cb_data);
2543 int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2544 void *cb_data)
2546 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
2547 refname, fn, cb_data);
2550 int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2551 each_reflog_ent_fn fn, void *cb_data)
2553 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2556 int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2557 void *cb_data)
2559 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
2560 fn, cb_data);
2563 int refs_reflog_exists(struct ref_store *refs, const char *refname)
2565 return refs->be->reflog_exists(refs, refname);
2568 int reflog_exists(const char *refname)
2570 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
2573 int refs_create_reflog(struct ref_store *refs, const char *refname,
2574 struct strbuf *err)
2576 return refs->be->create_reflog(refs, refname, err);
2579 int safe_create_reflog(const char *refname, struct strbuf *err)
2581 return refs_create_reflog(get_main_ref_store(the_repository), refname,
2582 err);
2585 int refs_delete_reflog(struct ref_store *refs, const char *refname)
2587 return refs->be->delete_reflog(refs, refname);
2590 int delete_reflog(const char *refname)
2592 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
2595 int refs_reflog_expire(struct ref_store *refs,
2596 const char *refname,
2597 unsigned int flags,
2598 reflog_expiry_prepare_fn prepare_fn,
2599 reflog_expiry_should_prune_fn should_prune_fn,
2600 reflog_expiry_cleanup_fn cleanup_fn,
2601 void *policy_cb_data)
2603 return refs->be->reflog_expire(refs, refname, flags,
2604 prepare_fn, should_prune_fn,
2605 cleanup_fn, policy_cb_data);
2608 int reflog_expire(const char *refname,
2609 unsigned int flags,
2610 reflog_expiry_prepare_fn prepare_fn,
2611 reflog_expiry_should_prune_fn should_prune_fn,
2612 reflog_expiry_cleanup_fn cleanup_fn,
2613 void *policy_cb_data)
2615 return refs_reflog_expire(get_main_ref_store(the_repository),
2616 refname, flags,
2617 prepare_fn, should_prune_fn,
2618 cleanup_fn, policy_cb_data);
2621 int initial_ref_transaction_commit(struct ref_transaction *transaction,
2622 struct strbuf *err)
2624 struct ref_store *refs = transaction->ref_store;
2626 return refs->be->initial_transaction_commit(refs, transaction, err);
2629 void ref_transaction_for_each_queued_update(struct ref_transaction *transaction,
2630 ref_transaction_for_each_queued_update_fn cb,
2631 void *cb_data)
2633 int i;
2635 for (i = 0; i < transaction->nr; i++) {
2636 struct ref_update *update = transaction->updates[i];
2638 cb(update->refname,
2639 (update->flags & REF_HAVE_OLD) ? &update->old_oid : NULL,
2640 (update->flags & REF_HAVE_NEW) ? &update->new_oid : NULL,
2641 cb_data);
2645 int refs_delete_refs(struct ref_store *refs, const char *logmsg,
2646 struct string_list *refnames, unsigned int flags)
2648 struct ref_transaction *transaction;
2649 struct strbuf err = STRBUF_INIT;
2650 struct string_list_item *item;
2651 int ret = 0, failures = 0;
2652 char *msg;
2654 if (!refnames->nr)
2655 return 0;
2657 msg = normalize_reflog_message(logmsg);
2660 * Since we don't check the references' old_oids, the
2661 * individual updates can't fail, so we can pack all of the
2662 * updates into a single transaction.
2664 transaction = ref_store_transaction_begin(refs, &err);
2665 if (!transaction) {
2666 ret = error("%s", err.buf);
2667 goto out;
2670 for_each_string_list_item(item, refnames) {
2671 ret = ref_transaction_delete(transaction, item->string,
2672 NULL, flags, msg, &err);
2673 if (ret) {
2674 warning(_("could not delete reference %s: %s"),
2675 item->string, err.buf);
2676 strbuf_reset(&err);
2677 failures = 1;
2681 ret = ref_transaction_commit(transaction, &err);
2682 if (ret) {
2683 if (refnames->nr == 1)
2684 error(_("could not delete reference %s: %s"),
2685 refnames->items[0].string, err.buf);
2686 else
2687 error(_("could not delete references: %s"), err.buf);
2690 out:
2691 if (!ret && failures)
2692 ret = -1;
2693 ref_transaction_free(transaction);
2694 strbuf_release(&err);
2695 free(msg);
2696 return ret;
2699 int delete_refs(const char *msg, struct string_list *refnames,
2700 unsigned int flags)
2702 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
2705 int refs_rename_ref(struct ref_store *refs, const char *oldref,
2706 const char *newref, const char *logmsg)
2708 char *msg;
2709 int retval;
2711 msg = normalize_reflog_message(logmsg);
2712 retval = refs->be->rename_ref(refs, oldref, newref, msg);
2713 free(msg);
2714 return retval;
2717 int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2719 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
2722 int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2723 const char *newref, const char *logmsg)
2725 char *msg;
2726 int retval;
2728 msg = normalize_reflog_message(logmsg);
2729 retval = refs->be->copy_ref(refs, oldref, newref, msg);
2730 free(msg);
2731 return retval;
2734 int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2736 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);