remote: move static variables into per-repository struct
[git/debian.git] / refs.c
blob2166f37399d846c5d1cd6bcc31bc9c9077714bfe
1 /*
2 * The backend-independent part of the reference module.
3 */
5 #include "cache.h"
6 #include "config.h"
7 #include "hashmap.h"
8 #include "lockfile.h"
9 #include "iterator.h"
10 #include "refs.h"
11 #include "refs/refs-internal.h"
12 #include "run-command.h"
13 #include "object-store.h"
14 #include "object.h"
15 #include "tag.h"
16 #include "submodule.h"
17 #include "worktree.h"
18 #include "strvec.h"
19 #include "repository.h"
20 #include "sigchain.h"
23 * List of all available backends
25 static struct ref_storage_be *refs_backends = &refs_be_files;
27 static struct ref_storage_be *find_ref_storage_backend(const char *name)
29 struct ref_storage_be *be;
30 for (be = refs_backends; be; be = be->next)
31 if (!strcmp(be->name, name))
32 return be;
33 return NULL;
37 * How to handle various characters in refnames:
38 * 0: An acceptable character for refs
39 * 1: End-of-component
40 * 2: ., look for a preceding . to reject .. in refs
41 * 3: {, look for a preceding @ to reject @{ in refs
42 * 4: A bad character: ASCII control characters, and
43 * ":", "?", "[", "\", "^", "~", SP, or TAB
44 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
46 static unsigned char refname_disposition[256] = {
47 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
48 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
49 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
50 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
51 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
58 * Try to read one refname component from the front of refname.
59 * Return the length of the component found, or -1 if the component is
60 * not legal. It is legal if it is something reasonable to have under
61 * ".git/refs/"; We do not like it if:
63 * - it begins with ".", or
64 * - it has double dots "..", or
65 * - it has ASCII control characters, or
66 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
67 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
68 * - it ends with a "/", or
69 * - it ends with ".lock", or
70 * - it contains a "@{" portion
72 * When sanitized is not NULL, instead of rejecting the input refname
73 * as an error, try to come up with a usable replacement for the input
74 * refname in it.
76 static int check_refname_component(const char *refname, int *flags,
77 struct strbuf *sanitized)
79 const char *cp;
80 char last = '\0';
81 size_t component_start = 0; /* garbage - not a reasonable initial value */
83 if (sanitized)
84 component_start = sanitized->len;
86 for (cp = refname; ; cp++) {
87 int ch = *cp & 255;
88 unsigned char disp = refname_disposition[ch];
90 if (sanitized && disp != 1)
91 strbuf_addch(sanitized, ch);
93 switch (disp) {
94 case 1:
95 goto out;
96 case 2:
97 if (last == '.') { /* Refname contains "..". */
98 if (sanitized)
99 /* collapse ".." to single "." */
100 strbuf_setlen(sanitized, sanitized->len - 1);
101 else
102 return -1;
104 break;
105 case 3:
106 if (last == '@') { /* Refname contains "@{". */
107 if (sanitized)
108 sanitized->buf[sanitized->len-1] = '-';
109 else
110 return -1;
112 break;
113 case 4:
114 /* forbidden char */
115 if (sanitized)
116 sanitized->buf[sanitized->len-1] = '-';
117 else
118 return -1;
119 break;
120 case 5:
121 if (!(*flags & REFNAME_REFSPEC_PATTERN)) {
122 /* refspec can't be a pattern */
123 if (sanitized)
124 sanitized->buf[sanitized->len-1] = '-';
125 else
126 return -1;
130 * Unset the pattern flag so that we only accept
131 * a single asterisk for one side of refspec.
133 *flags &= ~ REFNAME_REFSPEC_PATTERN;
134 break;
136 last = ch;
138 out:
139 if (cp == refname)
140 return 0; /* Component has zero length. */
142 if (refname[0] == '.') { /* Component starts with '.'. */
143 if (sanitized)
144 sanitized->buf[component_start] = '-';
145 else
146 return -1;
148 if (cp - refname >= LOCK_SUFFIX_LEN &&
149 !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN)) {
150 if (!sanitized)
151 return -1;
152 /* Refname ends with ".lock". */
153 while (strbuf_strip_suffix(sanitized, LOCK_SUFFIX)) {
154 /* try again in case we have .lock.lock */
157 return cp - refname;
160 static int check_or_sanitize_refname(const char *refname, int flags,
161 struct strbuf *sanitized)
163 int component_len, component_count = 0;
165 if (!strcmp(refname, "@")) {
166 /* Refname is a single character '@'. */
167 if (sanitized)
168 strbuf_addch(sanitized, '-');
169 else
170 return -1;
173 while (1) {
174 if (sanitized && sanitized->len)
175 strbuf_complete(sanitized, '/');
177 /* We are at the start of a path component. */
178 component_len = check_refname_component(refname, &flags,
179 sanitized);
180 if (sanitized && component_len == 0)
181 ; /* OK, omit empty component */
182 else if (component_len <= 0)
183 return -1;
185 component_count++;
186 if (refname[component_len] == '\0')
187 break;
188 /* Skip to next component. */
189 refname += component_len + 1;
192 if (refname[component_len - 1] == '.') {
193 /* Refname ends with '.'. */
194 if (sanitized)
195 ; /* omit ending dot */
196 else
197 return -1;
199 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
200 return -1; /* Refname has only one component. */
201 return 0;
204 int check_refname_format(const char *refname, int flags)
206 return check_or_sanitize_refname(refname, flags, NULL);
209 void sanitize_refname_component(const char *refname, struct strbuf *out)
211 if (check_or_sanitize_refname(refname, REFNAME_ALLOW_ONELEVEL, out))
212 BUG("sanitizing refname '%s' check returned error", refname);
215 int refname_is_safe(const char *refname)
217 const char *rest;
219 if (skip_prefix(refname, "refs/", &rest)) {
220 char *buf;
221 int result;
222 size_t restlen = strlen(rest);
224 /* rest must not be empty, or start or end with "/" */
225 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
226 return 0;
229 * Does the refname try to escape refs/?
230 * For example: refs/foo/../bar is safe but refs/foo/../../bar
231 * is not.
233 buf = xmallocz(restlen);
234 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
235 free(buf);
236 return result;
239 do {
240 if (!isupper(*refname) && *refname != '_')
241 return 0;
242 refname++;
243 } while (*refname);
244 return 1;
248 * Return true if refname, which has the specified oid and flags, can
249 * be resolved to an object in the database. If the referred-to object
250 * does not exist, emit a warning and return false.
252 int ref_resolves_to_object(const char *refname,
253 const struct object_id *oid,
254 unsigned int flags)
256 if (flags & REF_ISBROKEN)
257 return 0;
258 if (!has_object_file(oid)) {
259 error(_("%s does not point to a valid object!"), refname);
260 return 0;
262 return 1;
265 char *refs_resolve_refdup(struct ref_store *refs,
266 const char *refname, int resolve_flags,
267 struct object_id *oid, int *flags)
269 const char *result;
271 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
272 oid, flags);
273 return xstrdup_or_null(result);
276 char *resolve_refdup(const char *refname, int resolve_flags,
277 struct object_id *oid, int *flags)
279 return refs_resolve_refdup(get_main_ref_store(the_repository),
280 refname, resolve_flags,
281 oid, flags);
284 /* The argument to filter_refs */
285 struct ref_filter {
286 const char *pattern;
287 const char *prefix;
288 each_ref_fn *fn;
289 void *cb_data;
292 int refs_read_ref_full(struct ref_store *refs, const char *refname,
293 int resolve_flags, struct object_id *oid, int *flags)
295 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags))
296 return 0;
297 return -1;
300 int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags)
302 return refs_read_ref_full(get_main_ref_store(the_repository), refname,
303 resolve_flags, oid, flags);
306 int read_ref(const char *refname, struct object_id *oid)
308 return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
311 int refs_ref_exists(struct ref_store *refs, const char *refname)
313 return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING, NULL, NULL);
316 int ref_exists(const char *refname)
318 return refs_ref_exists(get_main_ref_store(the_repository), refname);
321 static int filter_refs(const char *refname, const struct object_id *oid,
322 int flags, void *data)
324 struct ref_filter *filter = (struct ref_filter *)data;
326 if (wildmatch(filter->pattern, refname, 0))
327 return 0;
328 if (filter->prefix)
329 skip_prefix(refname, filter->prefix, &refname);
330 return filter->fn(refname, oid, flags, filter->cb_data);
333 enum peel_status peel_object(const struct object_id *name, struct object_id *oid)
335 struct object *o = lookup_unknown_object(the_repository, name);
337 if (o->type == OBJ_NONE) {
338 int type = oid_object_info(the_repository, name, NULL);
339 if (type < 0 || !object_as_type(o, type, 0))
340 return PEEL_INVALID;
343 if (o->type != OBJ_TAG)
344 return PEEL_NON_TAG;
346 o = deref_tag_noverify(o);
347 if (!o)
348 return PEEL_INVALID;
350 oidcpy(oid, &o->oid);
351 return PEEL_PEELED;
354 struct warn_if_dangling_data {
355 FILE *fp;
356 const char *refname;
357 const struct string_list *refnames;
358 const char *msg_fmt;
361 static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
362 int flags, void *cb_data)
364 struct warn_if_dangling_data *d = cb_data;
365 const char *resolves_to;
367 if (!(flags & REF_ISSYMREF))
368 return 0;
370 resolves_to = resolve_ref_unsafe(refname, 0, NULL, NULL);
371 if (!resolves_to
372 || (d->refname
373 ? strcmp(resolves_to, d->refname)
374 : !string_list_has_string(d->refnames, resolves_to))) {
375 return 0;
378 fprintf(d->fp, d->msg_fmt, refname);
379 fputc('\n', d->fp);
380 return 0;
383 void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
385 struct warn_if_dangling_data data;
387 data.fp = fp;
388 data.refname = refname;
389 data.refnames = NULL;
390 data.msg_fmt = msg_fmt;
391 for_each_rawref(warn_if_dangling_symref, &data);
394 void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
396 struct warn_if_dangling_data data;
398 data.fp = fp;
399 data.refname = NULL;
400 data.refnames = refnames;
401 data.msg_fmt = msg_fmt;
402 for_each_rawref(warn_if_dangling_symref, &data);
405 int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
407 return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
410 int for_each_tag_ref(each_ref_fn fn, void *cb_data)
412 return refs_for_each_tag_ref(get_main_ref_store(the_repository), fn, cb_data);
415 int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
417 return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
420 int for_each_branch_ref(each_ref_fn fn, void *cb_data)
422 return refs_for_each_branch_ref(get_main_ref_store(the_repository), fn, cb_data);
425 int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
427 return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
430 int for_each_remote_ref(each_ref_fn fn, void *cb_data)
432 return refs_for_each_remote_ref(get_main_ref_store(the_repository), fn, cb_data);
435 int head_ref_namespaced(each_ref_fn fn, void *cb_data)
437 struct strbuf buf = STRBUF_INIT;
438 int ret = 0;
439 struct object_id oid;
440 int flag;
442 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
443 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, &oid, &flag))
444 ret = fn(buf.buf, &oid, flag, cb_data);
445 strbuf_release(&buf);
447 return ret;
450 void normalize_glob_ref(struct string_list_item *item, const char *prefix,
451 const char *pattern)
453 struct strbuf normalized_pattern = STRBUF_INIT;
455 if (*pattern == '/')
456 BUG("pattern must not start with '/'");
458 if (prefix) {
459 strbuf_addstr(&normalized_pattern, prefix);
461 else if (!starts_with(pattern, "refs/"))
462 strbuf_addstr(&normalized_pattern, "refs/");
463 strbuf_addstr(&normalized_pattern, pattern);
464 strbuf_strip_suffix(&normalized_pattern, "/");
466 item->string = strbuf_detach(&normalized_pattern, NULL);
467 item->util = has_glob_specials(pattern) ? NULL : item->string;
468 strbuf_release(&normalized_pattern);
471 int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
472 const char *prefix, void *cb_data)
474 struct strbuf real_pattern = STRBUF_INIT;
475 struct ref_filter filter;
476 int ret;
478 if (!prefix && !starts_with(pattern, "refs/"))
479 strbuf_addstr(&real_pattern, "refs/");
480 else if (prefix)
481 strbuf_addstr(&real_pattern, prefix);
482 strbuf_addstr(&real_pattern, pattern);
484 if (!has_glob_specials(pattern)) {
485 /* Append implied '/' '*' if not present. */
486 strbuf_complete(&real_pattern, '/');
487 /* No need to check for '*', there is none. */
488 strbuf_addch(&real_pattern, '*');
491 filter.pattern = real_pattern.buf;
492 filter.prefix = prefix;
493 filter.fn = fn;
494 filter.cb_data = cb_data;
495 ret = for_each_ref(filter_refs, &filter);
497 strbuf_release(&real_pattern);
498 return ret;
501 int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
503 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
506 const char *prettify_refname(const char *name)
508 if (skip_prefix(name, "refs/heads/", &name) ||
509 skip_prefix(name, "refs/tags/", &name) ||
510 skip_prefix(name, "refs/remotes/", &name))
511 ; /* nothing */
512 return name;
515 static const char *ref_rev_parse_rules[] = {
516 "%.*s",
517 "refs/%.*s",
518 "refs/tags/%.*s",
519 "refs/heads/%.*s",
520 "refs/remotes/%.*s",
521 "refs/remotes/%.*s/HEAD",
522 NULL
525 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
528 * Is it possible that the caller meant full_name with abbrev_name?
529 * If so return a non-zero value to signal "yes"; the magnitude of
530 * the returned value gives the precedence used for disambiguation.
532 * If abbrev_name cannot mean full_name, return 0.
534 int refname_match(const char *abbrev_name, const char *full_name)
536 const char **p;
537 const int abbrev_name_len = strlen(abbrev_name);
538 const int num_rules = NUM_REV_PARSE_RULES;
540 for (p = ref_rev_parse_rules; *p; p++)
541 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name)))
542 return &ref_rev_parse_rules[num_rules] - p;
544 return 0;
548 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
549 * the results to 'prefixes'
551 void expand_ref_prefix(struct strvec *prefixes, const char *prefix)
553 const char **p;
554 int len = strlen(prefix);
556 for (p = ref_rev_parse_rules; *p; p++)
557 strvec_pushf(prefixes, *p, len, prefix);
560 static const char default_branch_name_advice[] = N_(
561 "Using '%s' as the name for the initial branch. This default branch name\n"
562 "is subject to change. To configure the initial branch name to use in all\n"
563 "of your new repositories, which will suppress this warning, call:\n"
564 "\n"
565 "\tgit config --global init.defaultBranch <name>\n"
566 "\n"
567 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
568 "'development'. The just-created branch can be renamed via this command:\n"
569 "\n"
570 "\tgit branch -m <name>\n"
573 char *repo_default_branch_name(struct repository *r, int quiet)
575 const char *config_key = "init.defaultbranch";
576 const char *config_display_key = "init.defaultBranch";
577 char *ret = NULL, *full_ref;
578 const char *env = getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
580 if (env && *env)
581 ret = xstrdup(env);
582 else if (repo_config_get_string(r, config_key, &ret) < 0)
583 die(_("could not retrieve `%s`"), config_display_key);
585 if (!ret) {
586 ret = xstrdup("master");
587 if (!quiet)
588 advise(_(default_branch_name_advice), ret);
591 full_ref = xstrfmt("refs/heads/%s", ret);
592 if (check_refname_format(full_ref, 0))
593 die(_("invalid branch name: %s = %s"), config_display_key, ret);
594 free(full_ref);
596 return ret;
599 const char *git_default_branch_name(int quiet)
601 static char *ret;
603 if (!ret)
604 ret = repo_default_branch_name(the_repository, quiet);
606 return ret;
610 * *string and *len will only be substituted, and *string returned (for
611 * later free()ing) if the string passed in is a magic short-hand form
612 * to name a branch.
614 static char *substitute_branch_name(struct repository *r,
615 const char **string, int *len,
616 int nonfatal_dangling_mark)
618 struct strbuf buf = STRBUF_INIT;
619 struct interpret_branch_name_options options = {
620 .nonfatal_dangling_mark = nonfatal_dangling_mark
622 int ret = repo_interpret_branch_name(r, *string, *len, &buf, &options);
624 if (ret == *len) {
625 size_t size;
626 *string = strbuf_detach(&buf, &size);
627 *len = size;
628 return (char *)*string;
631 return NULL;
634 int repo_dwim_ref(struct repository *r, const char *str, int len,
635 struct object_id *oid, char **ref, int nonfatal_dangling_mark)
637 char *last_branch = substitute_branch_name(r, &str, &len,
638 nonfatal_dangling_mark);
639 int refs_found = expand_ref(r, str, len, oid, ref);
640 free(last_branch);
641 return refs_found;
644 int expand_ref(struct repository *repo, const char *str, int len,
645 struct object_id *oid, char **ref)
647 const char **p, *r;
648 int refs_found = 0;
649 struct strbuf fullref = STRBUF_INIT;
651 *ref = NULL;
652 for (p = ref_rev_parse_rules; *p; p++) {
653 struct object_id oid_from_ref;
654 struct object_id *this_result;
655 int flag;
657 this_result = refs_found ? &oid_from_ref : oid;
658 strbuf_reset(&fullref);
659 strbuf_addf(&fullref, *p, len, str);
660 r = refs_resolve_ref_unsafe(get_main_ref_store(repo),
661 fullref.buf, RESOLVE_REF_READING,
662 this_result, &flag);
663 if (r) {
664 if (!refs_found++)
665 *ref = xstrdup(r);
666 if (!warn_ambiguous_refs)
667 break;
668 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
669 warning(_("ignoring dangling symref %s"), fullref.buf);
670 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
671 warning(_("ignoring broken ref %s"), fullref.buf);
674 strbuf_release(&fullref);
675 return refs_found;
678 int repo_dwim_log(struct repository *r, const char *str, int len,
679 struct object_id *oid, char **log)
681 struct ref_store *refs = get_main_ref_store(r);
682 char *last_branch = substitute_branch_name(r, &str, &len, 0);
683 const char **p;
684 int logs_found = 0;
685 struct strbuf path = STRBUF_INIT;
687 *log = NULL;
688 for (p = ref_rev_parse_rules; *p; p++) {
689 struct object_id hash;
690 const char *ref, *it;
692 strbuf_reset(&path);
693 strbuf_addf(&path, *p, len, str);
694 ref = refs_resolve_ref_unsafe(refs, path.buf,
695 RESOLVE_REF_READING,
696 oid ? &hash : NULL, NULL);
697 if (!ref)
698 continue;
699 if (refs_reflog_exists(refs, path.buf))
700 it = path.buf;
701 else if (strcmp(ref, path.buf) &&
702 refs_reflog_exists(refs, ref))
703 it = ref;
704 else
705 continue;
706 if (!logs_found++) {
707 *log = xstrdup(it);
708 if (oid)
709 oidcpy(oid, &hash);
711 if (!warn_ambiguous_refs)
712 break;
714 strbuf_release(&path);
715 free(last_branch);
716 return logs_found;
719 int dwim_log(const char *str, int len, struct object_id *oid, char **log)
721 return repo_dwim_log(the_repository, str, len, oid, log);
724 static int is_per_worktree_ref(const char *refname)
726 return starts_with(refname, "refs/worktree/") ||
727 starts_with(refname, "refs/bisect/") ||
728 starts_with(refname, "refs/rewritten/");
731 static int is_pseudoref_syntax(const char *refname)
733 const char *c;
735 for (c = refname; *c; c++) {
736 if (!isupper(*c) && *c != '-' && *c != '_')
737 return 0;
740 return 1;
743 static int is_main_pseudoref_syntax(const char *refname)
745 return skip_prefix(refname, "main-worktree/", &refname) &&
746 *refname &&
747 is_pseudoref_syntax(refname);
750 static int is_other_pseudoref_syntax(const char *refname)
752 if (!skip_prefix(refname, "worktrees/", &refname))
753 return 0;
754 refname = strchr(refname, '/');
755 if (!refname || !refname[1])
756 return 0;
757 return is_pseudoref_syntax(refname + 1);
760 enum ref_type ref_type(const char *refname)
762 if (is_per_worktree_ref(refname))
763 return REF_TYPE_PER_WORKTREE;
764 if (is_pseudoref_syntax(refname))
765 return REF_TYPE_PSEUDOREF;
766 if (is_main_pseudoref_syntax(refname))
767 return REF_TYPE_MAIN_PSEUDOREF;
768 if (is_other_pseudoref_syntax(refname))
769 return REF_TYPE_OTHER_PSEUDOREF;
770 return REF_TYPE_NORMAL;
773 long get_files_ref_lock_timeout_ms(void)
775 static int configured = 0;
777 /* The default timeout is 100 ms: */
778 static int timeout_ms = 100;
780 if (!configured) {
781 git_config_get_int("core.filesreflocktimeout", &timeout_ms);
782 configured = 1;
785 return timeout_ms;
788 int refs_delete_ref(struct ref_store *refs, const char *msg,
789 const char *refname,
790 const struct object_id *old_oid,
791 unsigned int flags)
793 struct ref_transaction *transaction;
794 struct strbuf err = STRBUF_INIT;
796 transaction = ref_store_transaction_begin(refs, &err);
797 if (!transaction ||
798 ref_transaction_delete(transaction, refname, old_oid,
799 flags, msg, &err) ||
800 ref_transaction_commit(transaction, &err)) {
801 error("%s", err.buf);
802 ref_transaction_free(transaction);
803 strbuf_release(&err);
804 return 1;
806 ref_transaction_free(transaction);
807 strbuf_release(&err);
808 return 0;
811 int delete_ref(const char *msg, const char *refname,
812 const struct object_id *old_oid, unsigned int flags)
814 return refs_delete_ref(get_main_ref_store(the_repository), msg, refname,
815 old_oid, flags);
818 static void copy_reflog_msg(struct strbuf *sb, const char *msg)
820 char c;
821 int wasspace = 1;
823 while ((c = *msg++)) {
824 if (wasspace && isspace(c))
825 continue;
826 wasspace = isspace(c);
827 if (wasspace)
828 c = ' ';
829 strbuf_addch(sb, c);
831 strbuf_rtrim(sb);
834 static char *normalize_reflog_message(const char *msg)
836 struct strbuf sb = STRBUF_INIT;
838 if (msg && *msg)
839 copy_reflog_msg(&sb, msg);
840 return strbuf_detach(&sb, NULL);
843 int should_autocreate_reflog(const char *refname)
845 switch (log_all_ref_updates) {
846 case LOG_REFS_ALWAYS:
847 return 1;
848 case LOG_REFS_NORMAL:
849 return starts_with(refname, "refs/heads/") ||
850 starts_with(refname, "refs/remotes/") ||
851 starts_with(refname, "refs/notes/") ||
852 !strcmp(refname, "HEAD");
853 default:
854 return 0;
858 int is_branch(const char *refname)
860 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
863 struct read_ref_at_cb {
864 const char *refname;
865 timestamp_t at_time;
866 int cnt;
867 int reccnt;
868 struct object_id *oid;
869 int found_it;
871 struct object_id ooid;
872 struct object_id noid;
873 int tz;
874 timestamp_t date;
875 char **msg;
876 timestamp_t *cutoff_time;
877 int *cutoff_tz;
878 int *cutoff_cnt;
881 static void set_read_ref_cutoffs(struct read_ref_at_cb *cb,
882 timestamp_t timestamp, int tz, const char *message)
884 if (cb->msg)
885 *cb->msg = xstrdup(message);
886 if (cb->cutoff_time)
887 *cb->cutoff_time = timestamp;
888 if (cb->cutoff_tz)
889 *cb->cutoff_tz = tz;
890 if (cb->cutoff_cnt)
891 *cb->cutoff_cnt = cb->reccnt;
894 static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
895 const char *email, timestamp_t timestamp, int tz,
896 const char *message, void *cb_data)
898 struct read_ref_at_cb *cb = cb_data;
899 int reached_count;
901 cb->tz = tz;
902 cb->date = timestamp;
905 * It is not possible for cb->cnt == 0 on the first iteration because
906 * that special case is handled in read_ref_at().
908 if (cb->cnt > 0)
909 cb->cnt--;
910 reached_count = cb->cnt == 0 && !is_null_oid(ooid);
911 if (timestamp <= cb->at_time || reached_count) {
912 set_read_ref_cutoffs(cb, timestamp, tz, message);
914 * we have not yet updated cb->[n|o]oid so they still
915 * hold the values for the previous record.
917 if (!is_null_oid(&cb->ooid) && !oideq(&cb->ooid, noid))
918 warning(_("log for ref %s has gap after %s"),
919 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
920 if (reached_count)
921 oidcpy(cb->oid, ooid);
922 else if (!is_null_oid(&cb->ooid) || cb->date == cb->at_time)
923 oidcpy(cb->oid, noid);
924 else if (!oideq(noid, cb->oid))
925 warning(_("log for ref %s unexpectedly ended on %s"),
926 cb->refname, show_date(cb->date, cb->tz,
927 DATE_MODE(RFC2822)));
928 cb->found_it = 1;
930 cb->reccnt++;
931 oidcpy(&cb->ooid, ooid);
932 oidcpy(&cb->noid, noid);
933 return cb->found_it;
936 static int read_ref_at_ent_newest(struct object_id *ooid, struct object_id *noid,
937 const char *email, timestamp_t timestamp,
938 int tz, const char *message, void *cb_data)
940 struct read_ref_at_cb *cb = cb_data;
942 set_read_ref_cutoffs(cb, timestamp, tz, message);
943 oidcpy(cb->oid, noid);
944 /* We just want the first entry */
945 return 1;
948 static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
949 const char *email, timestamp_t timestamp,
950 int tz, const char *message, void *cb_data)
952 struct read_ref_at_cb *cb = cb_data;
954 set_read_ref_cutoffs(cb, timestamp, tz, message);
955 oidcpy(cb->oid, ooid);
956 if (is_null_oid(cb->oid))
957 oidcpy(cb->oid, noid);
958 /* We just want the first entry */
959 return 1;
962 int read_ref_at(struct ref_store *refs, const char *refname,
963 unsigned int flags, timestamp_t at_time, int cnt,
964 struct object_id *oid, char **msg,
965 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
967 struct read_ref_at_cb cb;
969 memset(&cb, 0, sizeof(cb));
970 cb.refname = refname;
971 cb.at_time = at_time;
972 cb.cnt = cnt;
973 cb.msg = msg;
974 cb.cutoff_time = cutoff_time;
975 cb.cutoff_tz = cutoff_tz;
976 cb.cutoff_cnt = cutoff_cnt;
977 cb.oid = oid;
979 if (cb.cnt == 0) {
980 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent_newest, &cb);
981 return 0;
984 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
986 if (!cb.reccnt) {
987 if (flags & GET_OID_QUIETLY)
988 exit(128);
989 else
990 die(_("log for %s is empty"), refname);
992 if (cb.found_it)
993 return 0;
995 refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
997 return 1;
1000 struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
1001 struct strbuf *err)
1003 struct ref_transaction *tr;
1004 assert(err);
1006 CALLOC_ARRAY(tr, 1);
1007 tr->ref_store = refs;
1008 return tr;
1011 struct ref_transaction *ref_transaction_begin(struct strbuf *err)
1013 return ref_store_transaction_begin(get_main_ref_store(the_repository), err);
1016 void ref_transaction_free(struct ref_transaction *transaction)
1018 size_t i;
1020 if (!transaction)
1021 return;
1023 switch (transaction->state) {
1024 case REF_TRANSACTION_OPEN:
1025 case REF_TRANSACTION_CLOSED:
1026 /* OK */
1027 break;
1028 case REF_TRANSACTION_PREPARED:
1029 BUG("free called on a prepared reference transaction");
1030 break;
1031 default:
1032 BUG("unexpected reference transaction state");
1033 break;
1036 for (i = 0; i < transaction->nr; i++) {
1037 free(transaction->updates[i]->msg);
1038 free(transaction->updates[i]);
1040 free(transaction->updates);
1041 free(transaction);
1044 struct ref_update *ref_transaction_add_update(
1045 struct ref_transaction *transaction,
1046 const char *refname, unsigned int flags,
1047 const struct object_id *new_oid,
1048 const struct object_id *old_oid,
1049 const char *msg)
1051 struct ref_update *update;
1053 if (transaction->state != REF_TRANSACTION_OPEN)
1054 BUG("update called for transaction that is not open");
1056 FLEX_ALLOC_STR(update, refname, refname);
1057 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
1058 transaction->updates[transaction->nr++] = update;
1060 update->flags = flags;
1062 if (flags & REF_HAVE_NEW)
1063 oidcpy(&update->new_oid, new_oid);
1064 if (flags & REF_HAVE_OLD)
1065 oidcpy(&update->old_oid, old_oid);
1066 update->msg = normalize_reflog_message(msg);
1067 return update;
1070 int ref_transaction_update(struct ref_transaction *transaction,
1071 const char *refname,
1072 const struct object_id *new_oid,
1073 const struct object_id *old_oid,
1074 unsigned int flags, const char *msg,
1075 struct strbuf *err)
1077 assert(err);
1079 if ((new_oid && !is_null_oid(new_oid)) ?
1080 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
1081 !refname_is_safe(refname)) {
1082 strbuf_addf(err, _("refusing to update ref with bad name '%s'"),
1083 refname);
1084 return -1;
1087 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
1088 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
1090 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
1092 ref_transaction_add_update(transaction, refname, flags,
1093 new_oid, old_oid, msg);
1094 return 0;
1097 int ref_transaction_create(struct ref_transaction *transaction,
1098 const char *refname,
1099 const struct object_id *new_oid,
1100 unsigned int flags, const char *msg,
1101 struct strbuf *err)
1103 if (!new_oid || is_null_oid(new_oid))
1104 BUG("create called without valid new_oid");
1105 return ref_transaction_update(transaction, refname, new_oid,
1106 null_oid(), flags, msg, err);
1109 int ref_transaction_delete(struct ref_transaction *transaction,
1110 const char *refname,
1111 const struct object_id *old_oid,
1112 unsigned int flags, const char *msg,
1113 struct strbuf *err)
1115 if (old_oid && is_null_oid(old_oid))
1116 BUG("delete called with old_oid set to zeros");
1117 return ref_transaction_update(transaction, refname,
1118 null_oid(), old_oid,
1119 flags, msg, err);
1122 int ref_transaction_verify(struct ref_transaction *transaction,
1123 const char *refname,
1124 const struct object_id *old_oid,
1125 unsigned int flags,
1126 struct strbuf *err)
1128 if (!old_oid)
1129 BUG("verify called with old_oid set to NULL");
1130 return ref_transaction_update(transaction, refname,
1131 NULL, old_oid,
1132 flags, NULL, err);
1135 int refs_update_ref(struct ref_store *refs, const char *msg,
1136 const char *refname, const struct object_id *new_oid,
1137 const struct object_id *old_oid, unsigned int flags,
1138 enum action_on_err onerr)
1140 struct ref_transaction *t = NULL;
1141 struct strbuf err = STRBUF_INIT;
1142 int ret = 0;
1144 t = ref_store_transaction_begin(refs, &err);
1145 if (!t ||
1146 ref_transaction_update(t, refname, new_oid, old_oid, flags, msg,
1147 &err) ||
1148 ref_transaction_commit(t, &err)) {
1149 ret = 1;
1150 ref_transaction_free(t);
1152 if (ret) {
1153 const char *str = _("update_ref failed for ref '%s': %s");
1155 switch (onerr) {
1156 case UPDATE_REFS_MSG_ON_ERR:
1157 error(str, refname, err.buf);
1158 break;
1159 case UPDATE_REFS_DIE_ON_ERR:
1160 die(str, refname, err.buf);
1161 break;
1162 case UPDATE_REFS_QUIET_ON_ERR:
1163 break;
1165 strbuf_release(&err);
1166 return 1;
1168 strbuf_release(&err);
1169 if (t)
1170 ref_transaction_free(t);
1171 return 0;
1174 int update_ref(const char *msg, const char *refname,
1175 const struct object_id *new_oid,
1176 const struct object_id *old_oid,
1177 unsigned int flags, enum action_on_err onerr)
1179 return refs_update_ref(get_main_ref_store(the_repository), msg, refname, new_oid,
1180 old_oid, flags, onerr);
1183 char *refs_shorten_unambiguous_ref(struct ref_store *refs,
1184 const char *refname, int strict)
1186 int i;
1187 static char **scanf_fmts;
1188 static int nr_rules;
1189 char *short_name;
1190 struct strbuf resolved_buf = STRBUF_INIT;
1192 if (!nr_rules) {
1194 * Pre-generate scanf formats from ref_rev_parse_rules[].
1195 * Generate a format suitable for scanf from a
1196 * ref_rev_parse_rules rule by interpolating "%s" at the
1197 * location of the "%.*s".
1199 size_t total_len = 0;
1200 size_t offset = 0;
1202 /* the rule list is NULL terminated, count them first */
1203 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
1204 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1205 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
1207 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
1209 offset = 0;
1210 for (i = 0; i < nr_rules; i++) {
1211 assert(offset < total_len);
1212 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
1213 offset += xsnprintf(scanf_fmts[i], total_len - offset,
1214 ref_rev_parse_rules[i], 2, "%s") + 1;
1218 /* bail out if there are no rules */
1219 if (!nr_rules)
1220 return xstrdup(refname);
1222 /* buffer for scanf result, at most refname must fit */
1223 short_name = xstrdup(refname);
1225 /* skip first rule, it will always match */
1226 for (i = nr_rules - 1; i > 0 ; --i) {
1227 int j;
1228 int rules_to_fail = i;
1229 int short_name_len;
1231 if (1 != sscanf(refname, scanf_fmts[i], short_name))
1232 continue;
1234 short_name_len = strlen(short_name);
1237 * in strict mode, all (except the matched one) rules
1238 * must fail to resolve to a valid non-ambiguous ref
1240 if (strict)
1241 rules_to_fail = nr_rules;
1244 * check if the short name resolves to a valid ref,
1245 * but use only rules prior to the matched one
1247 for (j = 0; j < rules_to_fail; j++) {
1248 const char *rule = ref_rev_parse_rules[j];
1250 /* skip matched rule */
1251 if (i == j)
1252 continue;
1255 * the short name is ambiguous, if it resolves
1256 * (with this previous rule) to a valid ref
1257 * read_ref() returns 0 on success
1259 strbuf_reset(&resolved_buf);
1260 strbuf_addf(&resolved_buf, rule,
1261 short_name_len, short_name);
1262 if (refs_ref_exists(refs, resolved_buf.buf))
1263 break;
1267 * short name is non-ambiguous if all previous rules
1268 * haven't resolved to a valid ref
1270 if (j == rules_to_fail) {
1271 strbuf_release(&resolved_buf);
1272 return short_name;
1276 strbuf_release(&resolved_buf);
1277 free(short_name);
1278 return xstrdup(refname);
1281 char *shorten_unambiguous_ref(const char *refname, int strict)
1283 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
1284 refname, strict);
1287 static struct string_list *hide_refs;
1289 int parse_hide_refs_config(const char *var, const char *value, const char *section)
1291 const char *key;
1292 if (!strcmp("transfer.hiderefs", var) ||
1293 (!parse_config_key(var, section, NULL, NULL, &key) &&
1294 !strcmp(key, "hiderefs"))) {
1295 char *ref;
1296 int len;
1298 if (!value)
1299 return config_error_nonbool(var);
1300 ref = xstrdup(value);
1301 len = strlen(ref);
1302 while (len && ref[len - 1] == '/')
1303 ref[--len] = '\0';
1304 if (!hide_refs) {
1305 CALLOC_ARRAY(hide_refs, 1);
1306 hide_refs->strdup_strings = 1;
1308 string_list_append(hide_refs, ref);
1310 return 0;
1313 int ref_is_hidden(const char *refname, const char *refname_full)
1315 int i;
1317 if (!hide_refs)
1318 return 0;
1319 for (i = hide_refs->nr - 1; i >= 0; i--) {
1320 const char *match = hide_refs->items[i].string;
1321 const char *subject;
1322 int neg = 0;
1323 const char *p;
1325 if (*match == '!') {
1326 neg = 1;
1327 match++;
1330 if (*match == '^') {
1331 subject = refname_full;
1332 match++;
1333 } else {
1334 subject = refname;
1337 /* refname can be NULL when namespaces are used. */
1338 if (subject &&
1339 skip_prefix(subject, match, &p) &&
1340 (!*p || *p == '/'))
1341 return !neg;
1343 return 0;
1346 const char *find_descendant_ref(const char *dirname,
1347 const struct string_list *extras,
1348 const struct string_list *skip)
1350 int pos;
1352 if (!extras)
1353 return NULL;
1356 * Look at the place where dirname would be inserted into
1357 * extras. If there is an entry at that position that starts
1358 * with dirname (remember, dirname includes the trailing
1359 * slash) and is not in skip, then we have a conflict.
1361 for (pos = string_list_find_insert_index(extras, dirname, 0);
1362 pos < extras->nr; pos++) {
1363 const char *extra_refname = extras->items[pos].string;
1365 if (!starts_with(extra_refname, dirname))
1366 break;
1368 if (!skip || !string_list_has_string(skip, extra_refname))
1369 return extra_refname;
1371 return NULL;
1374 int refs_rename_ref_available(struct ref_store *refs,
1375 const char *old_refname,
1376 const char *new_refname)
1378 struct string_list skip = STRING_LIST_INIT_NODUP;
1379 struct strbuf err = STRBUF_INIT;
1380 int ok;
1382 string_list_insert(&skip, old_refname);
1383 ok = !refs_verify_refname_available(refs, new_refname,
1384 NULL, &skip, &err);
1385 if (!ok)
1386 error("%s", err.buf);
1388 string_list_clear(&skip, 0);
1389 strbuf_release(&err);
1390 return ok;
1393 int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1395 struct object_id oid;
1396 int flag;
1398 if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING,
1399 &oid, &flag))
1400 return fn("HEAD", &oid, flag, cb_data);
1402 return 0;
1405 int head_ref(each_ref_fn fn, void *cb_data)
1407 return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
1410 struct ref_iterator *refs_ref_iterator_begin(
1411 struct ref_store *refs,
1412 const char *prefix, int trim,
1413 enum do_for_each_ref_flags flags)
1415 struct ref_iterator *iter;
1417 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
1418 static int ref_paranoia = -1;
1420 if (ref_paranoia < 0)
1421 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 1);
1422 if (ref_paranoia) {
1423 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1424 flags |= DO_FOR_EACH_OMIT_DANGLING_SYMREFS;
1428 iter = refs->be->iterator_begin(refs, prefix, flags);
1431 * `iterator_begin()` already takes care of prefix, but we
1432 * might need to do some trimming:
1434 if (trim)
1435 iter = prefix_ref_iterator_begin(iter, "", trim);
1437 /* Sanity check for subclasses: */
1438 if (!iter->ordered)
1439 BUG("reference iterator is not ordered");
1441 return iter;
1445 * Call fn for each reference in the specified submodule for which the
1446 * refname begins with prefix. If trim is non-zero, then trim that
1447 * many characters off the beginning of each refname before passing
1448 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1449 * include broken references in the iteration. If fn ever returns a
1450 * non-zero value, stop the iteration and return that value;
1451 * otherwise, return 0.
1453 static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1454 each_repo_ref_fn fn, int trim, int flags,
1455 void *cb_data)
1457 struct ref_iterator *iter;
1458 struct ref_store *refs = get_main_ref_store(r);
1460 if (!refs)
1461 return 0;
1463 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1465 return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1468 struct do_for_each_ref_help {
1469 each_ref_fn *fn;
1470 void *cb_data;
1473 static int do_for_each_ref_helper(struct repository *r,
1474 const char *refname,
1475 const struct object_id *oid,
1476 int flags,
1477 void *cb_data)
1479 struct do_for_each_ref_help *hp = cb_data;
1481 return hp->fn(refname, oid, flags, hp->cb_data);
1484 static int do_for_each_ref(struct ref_store *refs, const char *prefix,
1485 each_ref_fn fn, int trim,
1486 enum do_for_each_ref_flags flags, void *cb_data)
1488 struct ref_iterator *iter;
1489 struct do_for_each_ref_help hp = { fn, cb_data };
1491 if (!refs)
1492 return 0;
1494 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1496 return do_for_each_repo_ref_iterator(the_repository, iter,
1497 do_for_each_ref_helper, &hp);
1500 int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1502 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1505 int for_each_ref(each_ref_fn fn, void *cb_data)
1507 return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
1510 int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1511 each_ref_fn fn, void *cb_data)
1513 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
1516 int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1518 return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
1521 int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1523 return do_for_each_ref(get_main_ref_store(the_repository),
1524 prefix, fn, 0, 0, cb_data);
1527 int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
1528 each_ref_fn fn, void *cb_data)
1530 return do_for_each_ref(refs, prefix, fn, 0, 0, cb_data);
1533 int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
1535 return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1536 strlen(git_replace_ref_base),
1537 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1540 int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1542 struct strbuf buf = STRBUF_INIT;
1543 int ret;
1544 strbuf_addf(&buf, "%srefs/", get_git_namespace());
1545 ret = do_for_each_ref(get_main_ref_store(the_repository),
1546 buf.buf, fn, 0, 0, cb_data);
1547 strbuf_release(&buf);
1548 return ret;
1551 int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1553 return do_for_each_ref(refs, "", fn, 0,
1554 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1557 int for_each_rawref(each_ref_fn fn, void *cb_data)
1559 return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
1562 static int qsort_strcmp(const void *va, const void *vb)
1564 const char *a = *(const char **)va;
1565 const char *b = *(const char **)vb;
1567 return strcmp(a, b);
1570 static void find_longest_prefixes_1(struct string_list *out,
1571 struct strbuf *prefix,
1572 const char **patterns, size_t nr)
1574 size_t i;
1576 for (i = 0; i < nr; i++) {
1577 char c = patterns[i][prefix->len];
1578 if (!c || is_glob_special(c)) {
1579 string_list_append(out, prefix->buf);
1580 return;
1584 i = 0;
1585 while (i < nr) {
1586 size_t end;
1589 * Set "end" to the index of the element _after_ the last one
1590 * in our group.
1592 for (end = i + 1; end < nr; end++) {
1593 if (patterns[i][prefix->len] != patterns[end][prefix->len])
1594 break;
1597 strbuf_addch(prefix, patterns[i][prefix->len]);
1598 find_longest_prefixes_1(out, prefix, patterns + i, end - i);
1599 strbuf_setlen(prefix, prefix->len - 1);
1601 i = end;
1605 static void find_longest_prefixes(struct string_list *out,
1606 const char **patterns)
1608 struct strvec sorted = STRVEC_INIT;
1609 struct strbuf prefix = STRBUF_INIT;
1611 strvec_pushv(&sorted, patterns);
1612 QSORT(sorted.v, sorted.nr, qsort_strcmp);
1614 find_longest_prefixes_1(out, &prefix, sorted.v, sorted.nr);
1616 strvec_clear(&sorted);
1617 strbuf_release(&prefix);
1620 int for_each_fullref_in_prefixes(const char *namespace,
1621 const char **patterns,
1622 each_ref_fn fn, void *cb_data)
1624 struct string_list prefixes = STRING_LIST_INIT_DUP;
1625 struct string_list_item *prefix;
1626 struct strbuf buf = STRBUF_INIT;
1627 int ret = 0, namespace_len;
1629 find_longest_prefixes(&prefixes, patterns);
1631 if (namespace)
1632 strbuf_addstr(&buf, namespace);
1633 namespace_len = buf.len;
1635 for_each_string_list_item(prefix, &prefixes) {
1636 strbuf_addstr(&buf, prefix->string);
1637 ret = for_each_fullref_in(buf.buf, fn, cb_data);
1638 if (ret)
1639 break;
1640 strbuf_setlen(&buf, namespace_len);
1643 string_list_clear(&prefixes, 0);
1644 strbuf_release(&buf);
1645 return ret;
1648 static int refs_read_special_head(struct ref_store *ref_store,
1649 const char *refname, struct object_id *oid,
1650 struct strbuf *referent, unsigned int *type)
1652 struct strbuf full_path = STRBUF_INIT;
1653 struct strbuf content = STRBUF_INIT;
1654 int result = -1;
1655 strbuf_addf(&full_path, "%s/%s", ref_store->gitdir, refname);
1657 if (strbuf_read_file(&content, full_path.buf, 0) < 0)
1658 goto done;
1660 result = parse_loose_ref_contents(content.buf, oid, referent, type);
1662 done:
1663 strbuf_release(&full_path);
1664 strbuf_release(&content);
1665 return result;
1668 int refs_read_raw_ref(struct ref_store *ref_store,
1669 const char *refname, struct object_id *oid,
1670 struct strbuf *referent, unsigned int *type)
1672 if (!strcmp(refname, "FETCH_HEAD") || !strcmp(refname, "MERGE_HEAD")) {
1673 return refs_read_special_head(ref_store, refname, oid, referent,
1674 type);
1677 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent,
1678 type, &errno);
1681 /* This function needs to return a meaningful errno on failure */
1682 const char *refs_resolve_ref_unsafe(struct ref_store *refs,
1683 const char *refname,
1684 int resolve_flags,
1685 struct object_id *oid, int *flags)
1687 static struct strbuf sb_refname = STRBUF_INIT;
1688 struct object_id unused_oid;
1689 int unused_flags;
1690 int symref_count;
1692 if (!oid)
1693 oid = &unused_oid;
1694 if (!flags)
1695 flags = &unused_flags;
1697 *flags = 0;
1699 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1700 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1701 !refname_is_safe(refname)) {
1702 errno = EINVAL;
1703 return NULL;
1707 * dwim_ref() uses REF_ISBROKEN to distinguish between
1708 * missing refs and refs that were present but invalid,
1709 * to complain about the latter to stderr.
1711 * We don't know whether the ref exists, so don't set
1712 * REF_ISBROKEN yet.
1714 *flags |= REF_BAD_NAME;
1717 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1718 unsigned int read_flags = 0;
1720 if (refs_read_raw_ref(refs, refname,
1721 oid, &sb_refname, &read_flags)) {
1722 *flags |= read_flags;
1724 /* In reading mode, refs must eventually resolve */
1725 if (resolve_flags & RESOLVE_REF_READING)
1726 return NULL;
1729 * Otherwise a missing ref is OK. But the files backend
1730 * may show errors besides ENOENT if there are
1731 * similarly-named refs.
1733 if (errno != ENOENT &&
1734 errno != EISDIR &&
1735 errno != ENOTDIR)
1736 return NULL;
1738 oidclr(oid);
1739 if (*flags & REF_BAD_NAME)
1740 *flags |= REF_ISBROKEN;
1741 return refname;
1744 *flags |= read_flags;
1746 if (!(read_flags & REF_ISSYMREF)) {
1747 if (*flags & REF_BAD_NAME) {
1748 oidclr(oid);
1749 *flags |= REF_ISBROKEN;
1751 return refname;
1754 refname = sb_refname.buf;
1755 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1756 oidclr(oid);
1757 return refname;
1759 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1760 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1761 !refname_is_safe(refname)) {
1762 errno = EINVAL;
1763 return NULL;
1766 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1770 errno = ELOOP;
1771 return NULL;
1774 /* backend functions */
1775 int refs_init_db(struct strbuf *err)
1777 struct ref_store *refs = get_main_ref_store(the_repository);
1779 return refs->be->init_db(refs, err);
1782 const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1783 struct object_id *oid, int *flags)
1785 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
1786 resolve_flags, oid, flags);
1789 int resolve_gitlink_ref(const char *submodule, const char *refname,
1790 struct object_id *oid)
1792 struct ref_store *refs;
1793 int flags;
1795 refs = get_submodule_ref_store(submodule);
1797 if (!refs)
1798 return -1;
1800 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
1801 is_null_oid(oid))
1802 return -1;
1803 return 0;
1806 struct ref_store_hash_entry
1808 struct hashmap_entry ent;
1810 struct ref_store *refs;
1812 /* NUL-terminated identifier of the ref store: */
1813 char name[FLEX_ARRAY];
1816 static int ref_store_hash_cmp(const void *unused_cmp_data,
1817 const struct hashmap_entry *eptr,
1818 const struct hashmap_entry *entry_or_key,
1819 const void *keydata)
1821 const struct ref_store_hash_entry *e1, *e2;
1822 const char *name;
1824 e1 = container_of(eptr, const struct ref_store_hash_entry, ent);
1825 e2 = container_of(entry_or_key, const struct ref_store_hash_entry, ent);
1826 name = keydata ? keydata : e2->name;
1828 return strcmp(e1->name, name);
1831 static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1832 const char *name, struct ref_store *refs)
1834 struct ref_store_hash_entry *entry;
1836 FLEX_ALLOC_STR(entry, name, name);
1837 hashmap_entry_init(&entry->ent, strhash(name));
1838 entry->refs = refs;
1839 return entry;
1842 /* A hashmap of ref_stores, stored by submodule name: */
1843 static struct hashmap submodule_ref_stores;
1845 /* A hashmap of ref_stores, stored by worktree id: */
1846 static struct hashmap worktree_ref_stores;
1849 * Look up a ref store by name. If that ref_store hasn't been
1850 * registered yet, return NULL.
1852 static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1853 const char *name)
1855 struct ref_store_hash_entry *entry;
1856 unsigned int hash;
1858 if (!map->tablesize)
1859 /* It's initialized on demand in register_ref_store(). */
1860 return NULL;
1862 hash = strhash(name);
1863 entry = hashmap_get_entry_from_hash(map, hash, name,
1864 struct ref_store_hash_entry, ent);
1865 return entry ? entry->refs : NULL;
1869 * Create, record, and return a ref_store instance for the specified
1870 * gitdir.
1872 static struct ref_store *ref_store_init(const char *gitdir,
1873 unsigned int flags)
1875 const char *be_name = "files";
1876 struct ref_storage_be *be = find_ref_storage_backend(be_name);
1877 struct ref_store *refs;
1879 if (!be)
1880 BUG("reference backend %s is unknown", be_name);
1882 refs = be->init(gitdir, flags);
1883 return refs;
1886 struct ref_store *get_main_ref_store(struct repository *r)
1888 if (r->refs_private)
1889 return r->refs_private;
1891 if (!r->gitdir)
1892 BUG("attempting to get main_ref_store outside of repository");
1894 r->refs_private = ref_store_init(r->gitdir, REF_STORE_ALL_CAPS);
1895 r->refs_private = maybe_debug_wrap_ref_store(r->gitdir, r->refs_private);
1896 return r->refs_private;
1900 * Associate a ref store with a name. It is a fatal error to call this
1901 * function twice for the same name.
1903 static void register_ref_store_map(struct hashmap *map,
1904 const char *type,
1905 struct ref_store *refs,
1906 const char *name)
1908 struct ref_store_hash_entry *entry;
1910 if (!map->tablesize)
1911 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
1913 entry = alloc_ref_store_hash_entry(name, refs);
1914 if (hashmap_put(map, &entry->ent))
1915 BUG("%s ref_store '%s' initialized twice", type, name);
1918 struct ref_store *get_submodule_ref_store(const char *submodule)
1920 struct strbuf submodule_sb = STRBUF_INIT;
1921 struct ref_store *refs;
1922 char *to_free = NULL;
1923 size_t len;
1925 if (!submodule)
1926 return NULL;
1928 len = strlen(submodule);
1929 while (len && is_dir_sep(submodule[len - 1]))
1930 len--;
1931 if (!len)
1932 return NULL;
1934 if (submodule[len])
1935 /* We need to strip off one or more trailing slashes */
1936 submodule = to_free = xmemdupz(submodule, len);
1938 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
1939 if (refs)
1940 goto done;
1942 strbuf_addstr(&submodule_sb, submodule);
1943 if (!is_nonbare_repository_dir(&submodule_sb))
1944 goto done;
1946 if (submodule_to_gitdir(&submodule_sb, submodule))
1947 goto done;
1949 /* assume that add_submodule_odb() has been called */
1950 refs = ref_store_init(submodule_sb.buf,
1951 REF_STORE_READ | REF_STORE_ODB);
1952 register_ref_store_map(&submodule_ref_stores, "submodule",
1953 refs, submodule);
1955 done:
1956 strbuf_release(&submodule_sb);
1957 free(to_free);
1959 return refs;
1962 struct ref_store *get_worktree_ref_store(const struct worktree *wt)
1964 struct ref_store *refs;
1965 const char *id;
1967 if (wt->is_current)
1968 return get_main_ref_store(the_repository);
1970 id = wt->id ? wt->id : "/";
1971 refs = lookup_ref_store_map(&worktree_ref_stores, id);
1972 if (refs)
1973 return refs;
1975 if (wt->id)
1976 refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
1977 REF_STORE_ALL_CAPS);
1978 else
1979 refs = ref_store_init(get_git_common_dir(),
1980 REF_STORE_ALL_CAPS);
1982 if (refs)
1983 register_ref_store_map(&worktree_ref_stores, "worktree",
1984 refs, id);
1985 return refs;
1988 void base_ref_store_init(struct ref_store *refs,
1989 const struct ref_storage_be *be)
1991 refs->be = be;
1994 /* backend functions */
1995 int refs_pack_refs(struct ref_store *refs, unsigned int flags)
1997 return refs->be->pack_refs(refs, flags);
2000 int peel_iterated_oid(const struct object_id *base, struct object_id *peeled)
2002 if (current_ref_iter &&
2003 (current_ref_iter->oid == base ||
2004 oideq(current_ref_iter->oid, base)))
2005 return ref_iterator_peel(current_ref_iter, peeled);
2007 return peel_object(base, peeled) ? -1 : 0;
2010 int refs_create_symref(struct ref_store *refs,
2011 const char *ref_target,
2012 const char *refs_heads_master,
2013 const char *logmsg)
2015 char *msg;
2016 int retval;
2018 msg = normalize_reflog_message(logmsg);
2019 retval = refs->be->create_symref(refs, ref_target, refs_heads_master,
2020 msg);
2021 free(msg);
2022 return retval;
2025 int create_symref(const char *ref_target, const char *refs_heads_master,
2026 const char *logmsg)
2028 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
2029 refs_heads_master, logmsg);
2032 int ref_update_reject_duplicates(struct string_list *refnames,
2033 struct strbuf *err)
2035 size_t i, n = refnames->nr;
2037 assert(err);
2039 for (i = 1; i < n; i++) {
2040 int cmp = strcmp(refnames->items[i - 1].string,
2041 refnames->items[i].string);
2043 if (!cmp) {
2044 strbuf_addf(err,
2045 _("multiple updates for ref '%s' not allowed"),
2046 refnames->items[i].string);
2047 return 1;
2048 } else if (cmp > 0) {
2049 BUG("ref_update_reject_duplicates() received unsorted list");
2052 return 0;
2055 static int run_transaction_hook(struct ref_transaction *transaction,
2056 const char *state)
2058 struct child_process proc = CHILD_PROCESS_INIT;
2059 struct strbuf buf = STRBUF_INIT;
2060 const char *hook;
2061 int ret = 0, i;
2063 hook = find_hook("reference-transaction");
2064 if (!hook)
2065 return ret;
2067 strvec_pushl(&proc.args, hook, state, NULL);
2068 proc.in = -1;
2069 proc.stdout_to_stderr = 1;
2070 proc.trace2_hook_name = "reference-transaction";
2072 ret = start_command(&proc);
2073 if (ret)
2074 return ret;
2076 sigchain_push(SIGPIPE, SIG_IGN);
2078 for (i = 0; i < transaction->nr; i++) {
2079 struct ref_update *update = transaction->updates[i];
2081 strbuf_reset(&buf);
2082 strbuf_addf(&buf, "%s %s %s\n",
2083 oid_to_hex(&update->old_oid),
2084 oid_to_hex(&update->new_oid),
2085 update->refname);
2087 if (write_in_full(proc.in, buf.buf, buf.len) < 0) {
2088 if (errno != EPIPE)
2089 ret = -1;
2090 break;
2094 close(proc.in);
2095 sigchain_pop(SIGPIPE);
2096 strbuf_release(&buf);
2098 ret |= finish_command(&proc);
2099 return ret;
2102 int ref_transaction_prepare(struct ref_transaction *transaction,
2103 struct strbuf *err)
2105 struct ref_store *refs = transaction->ref_store;
2106 int ret;
2108 switch (transaction->state) {
2109 case REF_TRANSACTION_OPEN:
2110 /* Good. */
2111 break;
2112 case REF_TRANSACTION_PREPARED:
2113 BUG("prepare called twice on reference transaction");
2114 break;
2115 case REF_TRANSACTION_CLOSED:
2116 BUG("prepare called on a closed reference transaction");
2117 break;
2118 default:
2119 BUG("unexpected reference transaction state");
2120 break;
2123 if (getenv(GIT_QUARANTINE_ENVIRONMENT)) {
2124 strbuf_addstr(err,
2125 _("ref updates forbidden inside quarantine environment"));
2126 return -1;
2129 ret = refs->be->transaction_prepare(refs, transaction, err);
2130 if (ret)
2131 return ret;
2133 ret = run_transaction_hook(transaction, "prepared");
2134 if (ret) {
2135 ref_transaction_abort(transaction, err);
2136 die(_("ref updates aborted by hook"));
2139 return 0;
2142 int ref_transaction_abort(struct ref_transaction *transaction,
2143 struct strbuf *err)
2145 struct ref_store *refs = transaction->ref_store;
2146 int ret = 0;
2148 switch (transaction->state) {
2149 case REF_TRANSACTION_OPEN:
2150 /* No need to abort explicitly. */
2151 break;
2152 case REF_TRANSACTION_PREPARED:
2153 ret = refs->be->transaction_abort(refs, transaction, err);
2154 break;
2155 case REF_TRANSACTION_CLOSED:
2156 BUG("abort called on a closed reference transaction");
2157 break;
2158 default:
2159 BUG("unexpected reference transaction state");
2160 break;
2163 run_transaction_hook(transaction, "aborted");
2165 ref_transaction_free(transaction);
2166 return ret;
2169 int ref_transaction_commit(struct ref_transaction *transaction,
2170 struct strbuf *err)
2172 struct ref_store *refs = transaction->ref_store;
2173 int ret;
2175 switch (transaction->state) {
2176 case REF_TRANSACTION_OPEN:
2177 /* Need to prepare first. */
2178 ret = ref_transaction_prepare(transaction, err);
2179 if (ret)
2180 return ret;
2181 break;
2182 case REF_TRANSACTION_PREPARED:
2183 /* Fall through to finish. */
2184 break;
2185 case REF_TRANSACTION_CLOSED:
2186 BUG("commit called on a closed reference transaction");
2187 break;
2188 default:
2189 BUG("unexpected reference transaction state");
2190 break;
2193 ret = refs->be->transaction_finish(refs, transaction, err);
2194 if (!ret)
2195 run_transaction_hook(transaction, "committed");
2196 return ret;
2199 int refs_verify_refname_available(struct ref_store *refs,
2200 const char *refname,
2201 const struct string_list *extras,
2202 const struct string_list *skip,
2203 struct strbuf *err)
2205 const char *slash;
2206 const char *extra_refname;
2207 struct strbuf dirname = STRBUF_INIT;
2208 struct strbuf referent = STRBUF_INIT;
2209 struct object_id oid;
2210 unsigned int type;
2211 struct ref_iterator *iter;
2212 int ok;
2213 int ret = -1;
2216 * For the sake of comments in this function, suppose that
2217 * refname is "refs/foo/bar".
2220 assert(err);
2222 strbuf_grow(&dirname, strlen(refname) + 1);
2223 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
2224 /* Expand dirname to the new prefix, not including the trailing slash: */
2225 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2228 * We are still at a leading dir of the refname (e.g.,
2229 * "refs/foo"; if there is a reference with that name,
2230 * it is a conflict, *unless* it is in skip.
2232 if (skip && string_list_has_string(skip, dirname.buf))
2233 continue;
2235 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) {
2236 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2237 dirname.buf, refname);
2238 goto cleanup;
2241 if (extras && string_list_has_string(extras, dirname.buf)) {
2242 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2243 refname, dirname.buf);
2244 goto cleanup;
2249 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2250 * There is no point in searching for a reference with that
2251 * name, because a refname isn't considered to conflict with
2252 * itself. But we still need to check for references whose
2253 * names are in the "refs/foo/bar/" namespace, because they
2254 * *do* conflict.
2256 strbuf_addstr(&dirname, refname + dirname.len);
2257 strbuf_addch(&dirname, '/');
2259 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
2260 DO_FOR_EACH_INCLUDE_BROKEN);
2261 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2262 if (skip &&
2263 string_list_has_string(skip, iter->refname))
2264 continue;
2266 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2267 iter->refname, refname);
2268 ref_iterator_abort(iter);
2269 goto cleanup;
2272 if (ok != ITER_DONE)
2273 BUG("error while iterating over references");
2275 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2276 if (extra_refname)
2277 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2278 refname, extra_refname);
2279 else
2280 ret = 0;
2282 cleanup:
2283 strbuf_release(&referent);
2284 strbuf_release(&dirname);
2285 return ret;
2288 int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2290 struct ref_iterator *iter;
2291 struct do_for_each_ref_help hp = { fn, cb_data };
2293 iter = refs->be->reflog_iterator_begin(refs);
2295 return do_for_each_repo_ref_iterator(the_repository, iter,
2296 do_for_each_ref_helper, &hp);
2299 int for_each_reflog(each_ref_fn fn, void *cb_data)
2301 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
2304 int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2305 const char *refname,
2306 each_reflog_ent_fn fn,
2307 void *cb_data)
2309 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2310 fn, cb_data);
2313 int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2314 void *cb_data)
2316 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
2317 refname, fn, cb_data);
2320 int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2321 each_reflog_ent_fn fn, void *cb_data)
2323 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2326 int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2327 void *cb_data)
2329 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
2330 fn, cb_data);
2333 int refs_reflog_exists(struct ref_store *refs, const char *refname)
2335 return refs->be->reflog_exists(refs, refname);
2338 int reflog_exists(const char *refname)
2340 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
2343 int refs_create_reflog(struct ref_store *refs, const char *refname,
2344 int force_create, struct strbuf *err)
2346 return refs->be->create_reflog(refs, refname, force_create, err);
2349 int safe_create_reflog(const char *refname, int force_create,
2350 struct strbuf *err)
2352 return refs_create_reflog(get_main_ref_store(the_repository), refname,
2353 force_create, err);
2356 int refs_delete_reflog(struct ref_store *refs, const char *refname)
2358 return refs->be->delete_reflog(refs, refname);
2361 int delete_reflog(const char *refname)
2363 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
2366 int refs_reflog_expire(struct ref_store *refs,
2367 const char *refname,
2368 unsigned int flags,
2369 reflog_expiry_prepare_fn prepare_fn,
2370 reflog_expiry_should_prune_fn should_prune_fn,
2371 reflog_expiry_cleanup_fn cleanup_fn,
2372 void *policy_cb_data)
2374 return refs->be->reflog_expire(refs, refname, flags,
2375 prepare_fn, should_prune_fn,
2376 cleanup_fn, policy_cb_data);
2379 int reflog_expire(const char *refname,
2380 unsigned int flags,
2381 reflog_expiry_prepare_fn prepare_fn,
2382 reflog_expiry_should_prune_fn should_prune_fn,
2383 reflog_expiry_cleanup_fn cleanup_fn,
2384 void *policy_cb_data)
2386 return refs_reflog_expire(get_main_ref_store(the_repository),
2387 refname, flags,
2388 prepare_fn, should_prune_fn,
2389 cleanup_fn, policy_cb_data);
2392 int initial_ref_transaction_commit(struct ref_transaction *transaction,
2393 struct strbuf *err)
2395 struct ref_store *refs = transaction->ref_store;
2397 return refs->be->initial_transaction_commit(refs, transaction, err);
2400 int refs_delete_refs(struct ref_store *refs, const char *logmsg,
2401 struct string_list *refnames, unsigned int flags)
2403 char *msg;
2404 int retval;
2406 msg = normalize_reflog_message(logmsg);
2407 retval = refs->be->delete_refs(refs, msg, refnames, flags);
2408 free(msg);
2409 return retval;
2412 int delete_refs(const char *msg, struct string_list *refnames,
2413 unsigned int flags)
2415 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
2418 int refs_rename_ref(struct ref_store *refs, const char *oldref,
2419 const char *newref, const char *logmsg)
2421 char *msg;
2422 int retval;
2424 msg = normalize_reflog_message(logmsg);
2425 retval = refs->be->rename_ref(refs, oldref, newref, msg);
2426 free(msg);
2427 return retval;
2430 int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2432 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
2435 int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2436 const char *newref, const char *logmsg)
2438 char *msg;
2439 int retval;
2441 msg = normalize_reflog_message(logmsg);
2442 retval = refs->be->copy_ref(refs, oldref, newref, msg);
2443 free(msg);
2444 return retval;
2447 int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2449 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);