The eleventh (aka "ort") batch
[git.git] / refs.c
blob261fd82beb98fdfcfc641fa7605d37b86aac2184
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;
36 int ref_storage_backend_exists(const char *name)
38 return find_ref_storage_backend(name) != NULL;
42 * How to handle various characters in refnames:
43 * 0: An acceptable character for refs
44 * 1: End-of-component
45 * 2: ., look for a preceding . to reject .. in refs
46 * 3: {, look for a preceding @ to reject @{ in refs
47 * 4: A bad character: ASCII control characters, and
48 * ":", "?", "[", "\", "^", "~", SP, or TAB
49 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
51 static unsigned char refname_disposition[256] = {
52 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
53 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
54 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
56 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
57 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
58 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
59 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
63 * Try to read one refname component from the front of refname.
64 * Return the length of the component found, or -1 if the component is
65 * not legal. It is legal if it is something reasonable to have under
66 * ".git/refs/"; We do not like it if:
68 * - it begins with ".", or
69 * - it has double dots "..", or
70 * - it has ASCII control characters, or
71 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
72 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
73 * - it ends with a "/", or
74 * - it ends with ".lock", or
75 * - it contains a "@{" portion
77 * When sanitized is not NULL, instead of rejecting the input refname
78 * as an error, try to come up with a usable replacement for the input
79 * refname in it.
81 static int check_refname_component(const char *refname, int *flags,
82 struct strbuf *sanitized)
84 const char *cp;
85 char last = '\0';
86 size_t component_start = 0; /* garbage - not a reasonable initial value */
88 if (sanitized)
89 component_start = sanitized->len;
91 for (cp = refname; ; cp++) {
92 int ch = *cp & 255;
93 unsigned char disp = refname_disposition[ch];
95 if (sanitized && disp != 1)
96 strbuf_addch(sanitized, ch);
98 switch (disp) {
99 case 1:
100 goto out;
101 case 2:
102 if (last == '.') { /* Refname contains "..". */
103 if (sanitized)
104 /* collapse ".." to single "." */
105 strbuf_setlen(sanitized, sanitized->len - 1);
106 else
107 return -1;
109 break;
110 case 3:
111 if (last == '@') { /* Refname contains "@{". */
112 if (sanitized)
113 sanitized->buf[sanitized->len-1] = '-';
114 else
115 return -1;
117 break;
118 case 4:
119 /* forbidden char */
120 if (sanitized)
121 sanitized->buf[sanitized->len-1] = '-';
122 else
123 return -1;
124 break;
125 case 5:
126 if (!(*flags & REFNAME_REFSPEC_PATTERN)) {
127 /* refspec can't be a pattern */
128 if (sanitized)
129 sanitized->buf[sanitized->len-1] = '-';
130 else
131 return -1;
135 * Unset the pattern flag so that we only accept
136 * a single asterisk for one side of refspec.
138 *flags &= ~ REFNAME_REFSPEC_PATTERN;
139 break;
141 last = ch;
143 out:
144 if (cp == refname)
145 return 0; /* Component has zero length. */
147 if (refname[0] == '.') { /* Component starts with '.'. */
148 if (sanitized)
149 sanitized->buf[component_start] = '-';
150 else
151 return -1;
153 if (cp - refname >= LOCK_SUFFIX_LEN &&
154 !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN)) {
155 if (!sanitized)
156 return -1;
157 /* Refname ends with ".lock". */
158 while (strbuf_strip_suffix(sanitized, LOCK_SUFFIX)) {
159 /* try again in case we have .lock.lock */
162 return cp - refname;
165 static int check_or_sanitize_refname(const char *refname, int flags,
166 struct strbuf *sanitized)
168 int component_len, component_count = 0;
170 if (!strcmp(refname, "@")) {
171 /* Refname is a single character '@'. */
172 if (sanitized)
173 strbuf_addch(sanitized, '-');
174 else
175 return -1;
178 while (1) {
179 if (sanitized && sanitized->len)
180 strbuf_complete(sanitized, '/');
182 /* We are at the start of a path component. */
183 component_len = check_refname_component(refname, &flags,
184 sanitized);
185 if (sanitized && component_len == 0)
186 ; /* OK, omit empty component */
187 else if (component_len <= 0)
188 return -1;
190 component_count++;
191 if (refname[component_len] == '\0')
192 break;
193 /* Skip to next component. */
194 refname += component_len + 1;
197 if (refname[component_len - 1] == '.') {
198 /* Refname ends with '.'. */
199 if (sanitized)
200 ; /* omit ending dot */
201 else
202 return -1;
204 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
205 return -1; /* Refname has only one component. */
206 return 0;
209 int check_refname_format(const char *refname, int flags)
211 return check_or_sanitize_refname(refname, flags, NULL);
214 void sanitize_refname_component(const char *refname, struct strbuf *out)
216 if (check_or_sanitize_refname(refname, REFNAME_ALLOW_ONELEVEL, out))
217 BUG("sanitizing refname '%s' check returned error", refname);
220 int refname_is_safe(const char *refname)
222 const char *rest;
224 if (skip_prefix(refname, "refs/", &rest)) {
225 char *buf;
226 int result;
227 size_t restlen = strlen(rest);
229 /* rest must not be empty, or start or end with "/" */
230 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
231 return 0;
234 * Does the refname try to escape refs/?
235 * For example: refs/foo/../bar is safe but refs/foo/../../bar
236 * is not.
238 buf = xmallocz(restlen);
239 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
240 free(buf);
241 return result;
244 do {
245 if (!isupper(*refname) && *refname != '_')
246 return 0;
247 refname++;
248 } while (*refname);
249 return 1;
253 * Return true if refname, which has the specified oid and flags, can
254 * be resolved to an object in the database. If the referred-to object
255 * does not exist, emit a warning and return false.
257 int ref_resolves_to_object(const char *refname,
258 const struct object_id *oid,
259 unsigned int flags)
261 if (flags & REF_ISBROKEN)
262 return 0;
263 if (!has_object_file(oid)) {
264 error(_("%s does not point to a valid object!"), refname);
265 return 0;
267 return 1;
270 char *refs_resolve_refdup(struct ref_store *refs,
271 const char *refname, int resolve_flags,
272 struct object_id *oid, int *flags)
274 const char *result;
276 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
277 oid, flags);
278 return xstrdup_or_null(result);
281 char *resolve_refdup(const char *refname, int resolve_flags,
282 struct object_id *oid, int *flags)
284 return refs_resolve_refdup(get_main_ref_store(the_repository),
285 refname, resolve_flags,
286 oid, flags);
289 /* The argument to filter_refs */
290 struct ref_filter {
291 const char *pattern;
292 const char *prefix;
293 each_ref_fn *fn;
294 void *cb_data;
297 int refs_read_ref_full(struct ref_store *refs, const char *refname,
298 int resolve_flags, struct object_id *oid, int *flags)
300 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags))
301 return 0;
302 return -1;
305 int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags)
307 return refs_read_ref_full(get_main_ref_store(the_repository), refname,
308 resolve_flags, oid, flags);
311 int read_ref(const char *refname, struct object_id *oid)
313 return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
316 int refs_ref_exists(struct ref_store *refs, const char *refname)
318 return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING, NULL, NULL);
321 int ref_exists(const char *refname)
323 return refs_ref_exists(get_main_ref_store(the_repository), refname);
326 static int filter_refs(const char *refname, const struct object_id *oid,
327 int flags, void *data)
329 struct ref_filter *filter = (struct ref_filter *)data;
331 if (wildmatch(filter->pattern, refname, 0))
332 return 0;
333 if (filter->prefix)
334 skip_prefix(refname, filter->prefix, &refname);
335 return filter->fn(refname, oid, flags, filter->cb_data);
338 enum peel_status peel_object(const struct object_id *name, struct object_id *oid)
340 struct object *o = lookup_unknown_object(name);
342 if (o->type == OBJ_NONE) {
343 int type = oid_object_info(the_repository, name, NULL);
344 if (type < 0 || !object_as_type(o, type, 0))
345 return PEEL_INVALID;
348 if (o->type != OBJ_TAG)
349 return PEEL_NON_TAG;
351 o = deref_tag_noverify(o);
352 if (!o)
353 return PEEL_INVALID;
355 oidcpy(oid, &o->oid);
356 return PEEL_PEELED;
359 struct warn_if_dangling_data {
360 FILE *fp;
361 const char *refname;
362 const struct string_list *refnames;
363 const char *msg_fmt;
366 static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
367 int flags, void *cb_data)
369 struct warn_if_dangling_data *d = cb_data;
370 const char *resolves_to;
372 if (!(flags & REF_ISSYMREF))
373 return 0;
375 resolves_to = resolve_ref_unsafe(refname, 0, NULL, NULL);
376 if (!resolves_to
377 || (d->refname
378 ? strcmp(resolves_to, d->refname)
379 : !string_list_has_string(d->refnames, resolves_to))) {
380 return 0;
383 fprintf(d->fp, d->msg_fmt, refname);
384 fputc('\n', d->fp);
385 return 0;
388 void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
390 struct warn_if_dangling_data data;
392 data.fp = fp;
393 data.refname = refname;
394 data.refnames = NULL;
395 data.msg_fmt = msg_fmt;
396 for_each_rawref(warn_if_dangling_symref, &data);
399 void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
401 struct warn_if_dangling_data data;
403 data.fp = fp;
404 data.refname = NULL;
405 data.refnames = refnames;
406 data.msg_fmt = msg_fmt;
407 for_each_rawref(warn_if_dangling_symref, &data);
410 int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
412 return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
415 int for_each_tag_ref(each_ref_fn fn, void *cb_data)
417 return refs_for_each_tag_ref(get_main_ref_store(the_repository), fn, cb_data);
420 int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
422 return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
425 int for_each_branch_ref(each_ref_fn fn, void *cb_data)
427 return refs_for_each_branch_ref(get_main_ref_store(the_repository), fn, cb_data);
430 int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
432 return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
435 int for_each_remote_ref(each_ref_fn fn, void *cb_data)
437 return refs_for_each_remote_ref(get_main_ref_store(the_repository), fn, cb_data);
440 int head_ref_namespaced(each_ref_fn fn, void *cb_data)
442 struct strbuf buf = STRBUF_INIT;
443 int ret = 0;
444 struct object_id oid;
445 int flag;
447 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
448 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, &oid, &flag))
449 ret = fn(buf.buf, &oid, flag, cb_data);
450 strbuf_release(&buf);
452 return ret;
455 void normalize_glob_ref(struct string_list_item *item, const char *prefix,
456 const char *pattern)
458 struct strbuf normalized_pattern = STRBUF_INIT;
460 if (*pattern == '/')
461 BUG("pattern must not start with '/'");
463 if (prefix) {
464 strbuf_addstr(&normalized_pattern, prefix);
466 else if (!starts_with(pattern, "refs/"))
467 strbuf_addstr(&normalized_pattern, "refs/");
468 strbuf_addstr(&normalized_pattern, pattern);
469 strbuf_strip_suffix(&normalized_pattern, "/");
471 item->string = strbuf_detach(&normalized_pattern, NULL);
472 item->util = has_glob_specials(pattern) ? NULL : item->string;
473 strbuf_release(&normalized_pattern);
476 int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
477 const char *prefix, void *cb_data)
479 struct strbuf real_pattern = STRBUF_INIT;
480 struct ref_filter filter;
481 int ret;
483 if (!prefix && !starts_with(pattern, "refs/"))
484 strbuf_addstr(&real_pattern, "refs/");
485 else if (prefix)
486 strbuf_addstr(&real_pattern, prefix);
487 strbuf_addstr(&real_pattern, pattern);
489 if (!has_glob_specials(pattern)) {
490 /* Append implied '/' '*' if not present. */
491 strbuf_complete(&real_pattern, '/');
492 /* No need to check for '*', there is none. */
493 strbuf_addch(&real_pattern, '*');
496 filter.pattern = real_pattern.buf;
497 filter.prefix = prefix;
498 filter.fn = fn;
499 filter.cb_data = cb_data;
500 ret = for_each_ref(filter_refs, &filter);
502 strbuf_release(&real_pattern);
503 return ret;
506 int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
508 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
511 const char *prettify_refname(const char *name)
513 if (skip_prefix(name, "refs/heads/", &name) ||
514 skip_prefix(name, "refs/tags/", &name) ||
515 skip_prefix(name, "refs/remotes/", &name))
516 ; /* nothing */
517 return name;
520 static const char *ref_rev_parse_rules[] = {
521 "%.*s",
522 "refs/%.*s",
523 "refs/tags/%.*s",
524 "refs/heads/%.*s",
525 "refs/remotes/%.*s",
526 "refs/remotes/%.*s/HEAD",
527 NULL
530 #define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
533 * Is it possible that the caller meant full_name with abbrev_name?
534 * If so return a non-zero value to signal "yes"; the magnitude of
535 * the returned value gives the precedence used for disambiguation.
537 * If abbrev_name cannot mean full_name, return 0.
539 int refname_match(const char *abbrev_name, const char *full_name)
541 const char **p;
542 const int abbrev_name_len = strlen(abbrev_name);
543 const int num_rules = NUM_REV_PARSE_RULES;
545 for (p = ref_rev_parse_rules; *p; p++)
546 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name)))
547 return &ref_rev_parse_rules[num_rules] - p;
549 return 0;
553 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
554 * the results to 'prefixes'
556 void expand_ref_prefix(struct strvec *prefixes, const char *prefix)
558 const char **p;
559 int len = strlen(prefix);
561 for (p = ref_rev_parse_rules; *p; p++)
562 strvec_pushf(prefixes, *p, len, prefix);
565 static const char default_branch_name_advice[] = N_(
566 "Using '%s' as the name for the initial branch. This default branch name\n"
567 "is subject to change. To configure the initial branch name to use in all\n"
568 "of your new repositories, which will suppress this warning, call:\n"
569 "\n"
570 "\tgit config --global init.defaultBranch <name>\n"
571 "\n"
572 "Names commonly chosen instead of 'master' are 'main', 'trunk' and\n"
573 "'development'. The just-created branch can be renamed via this command:\n"
574 "\n"
575 "\tgit branch -m <name>\n"
578 char *repo_default_branch_name(struct repository *r, int quiet)
580 const char *config_key = "init.defaultbranch";
581 const char *config_display_key = "init.defaultBranch";
582 char *ret = NULL, *full_ref;
583 const char *env = getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
585 if (env && *env)
586 ret = xstrdup(env);
587 else if (repo_config_get_string(r, config_key, &ret) < 0)
588 die(_("could not retrieve `%s`"), config_display_key);
590 if (!ret) {
591 ret = xstrdup("master");
592 if (!quiet)
593 advise(_(default_branch_name_advice), ret);
596 full_ref = xstrfmt("refs/heads/%s", ret);
597 if (check_refname_format(full_ref, 0))
598 die(_("invalid branch name: %s = %s"), config_display_key, ret);
599 free(full_ref);
601 return ret;
604 const char *git_default_branch_name(int quiet)
606 static char *ret;
608 if (!ret)
609 ret = repo_default_branch_name(the_repository, quiet);
611 return ret;
615 * *string and *len will only be substituted, and *string returned (for
616 * later free()ing) if the string passed in is a magic short-hand form
617 * to name a branch.
619 static char *substitute_branch_name(struct repository *r,
620 const char **string, int *len,
621 int nonfatal_dangling_mark)
623 struct strbuf buf = STRBUF_INIT;
624 struct interpret_branch_name_options options = {
625 .nonfatal_dangling_mark = nonfatal_dangling_mark
627 int ret = repo_interpret_branch_name(r, *string, *len, &buf, &options);
629 if (ret == *len) {
630 size_t size;
631 *string = strbuf_detach(&buf, &size);
632 *len = size;
633 return (char *)*string;
636 return NULL;
639 int repo_dwim_ref(struct repository *r, const char *str, int len,
640 struct object_id *oid, char **ref, int nonfatal_dangling_mark)
642 char *last_branch = substitute_branch_name(r, &str, &len,
643 nonfatal_dangling_mark);
644 int refs_found = expand_ref(r, str, len, oid, ref);
645 free(last_branch);
646 return refs_found;
649 int expand_ref(struct repository *repo, const char *str, int len,
650 struct object_id *oid, char **ref)
652 const char **p, *r;
653 int refs_found = 0;
654 struct strbuf fullref = STRBUF_INIT;
656 *ref = NULL;
657 for (p = ref_rev_parse_rules; *p; p++) {
658 struct object_id oid_from_ref;
659 struct object_id *this_result;
660 int flag;
662 this_result = refs_found ? &oid_from_ref : oid;
663 strbuf_reset(&fullref);
664 strbuf_addf(&fullref, *p, len, str);
665 r = refs_resolve_ref_unsafe(get_main_ref_store(repo),
666 fullref.buf, RESOLVE_REF_READING,
667 this_result, &flag);
668 if (r) {
669 if (!refs_found++)
670 *ref = xstrdup(r);
671 if (!warn_ambiguous_refs)
672 break;
673 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
674 warning(_("ignoring dangling symref %s"), fullref.buf);
675 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
676 warning(_("ignoring broken ref %s"), fullref.buf);
679 strbuf_release(&fullref);
680 return refs_found;
683 int repo_dwim_log(struct repository *r, const char *str, int len,
684 struct object_id *oid, char **log)
686 struct ref_store *refs = get_main_ref_store(r);
687 char *last_branch = substitute_branch_name(r, &str, &len, 0);
688 const char **p;
689 int logs_found = 0;
690 struct strbuf path = STRBUF_INIT;
692 *log = NULL;
693 for (p = ref_rev_parse_rules; *p; p++) {
694 struct object_id hash;
695 const char *ref, *it;
697 strbuf_reset(&path);
698 strbuf_addf(&path, *p, len, str);
699 ref = refs_resolve_ref_unsafe(refs, path.buf,
700 RESOLVE_REF_READING,
701 &hash, NULL);
702 if (!ref)
703 continue;
704 if (refs_reflog_exists(refs, path.buf))
705 it = path.buf;
706 else if (strcmp(ref, path.buf) &&
707 refs_reflog_exists(refs, ref))
708 it = ref;
709 else
710 continue;
711 if (!logs_found++) {
712 *log = xstrdup(it);
713 oidcpy(oid, &hash);
715 if (!warn_ambiguous_refs)
716 break;
718 strbuf_release(&path);
719 free(last_branch);
720 return logs_found;
723 int dwim_log(const char *str, int len, struct object_id *oid, char **log)
725 return repo_dwim_log(the_repository, str, len, oid, log);
728 static int is_per_worktree_ref(const char *refname)
730 return starts_with(refname, "refs/worktree/") ||
731 starts_with(refname, "refs/bisect/") ||
732 starts_with(refname, "refs/rewritten/");
735 static int is_pseudoref_syntax(const char *refname)
737 const char *c;
739 for (c = refname; *c; c++) {
740 if (!isupper(*c) && *c != '-' && *c != '_')
741 return 0;
744 return 1;
747 static int is_main_pseudoref_syntax(const char *refname)
749 return skip_prefix(refname, "main-worktree/", &refname) &&
750 *refname &&
751 is_pseudoref_syntax(refname);
754 static int is_other_pseudoref_syntax(const char *refname)
756 if (!skip_prefix(refname, "worktrees/", &refname))
757 return 0;
758 refname = strchr(refname, '/');
759 if (!refname || !refname[1])
760 return 0;
761 return is_pseudoref_syntax(refname + 1);
764 enum ref_type ref_type(const char *refname)
766 if (is_per_worktree_ref(refname))
767 return REF_TYPE_PER_WORKTREE;
768 if (is_pseudoref_syntax(refname))
769 return REF_TYPE_PSEUDOREF;
770 if (is_main_pseudoref_syntax(refname))
771 return REF_TYPE_MAIN_PSEUDOREF;
772 if (is_other_pseudoref_syntax(refname))
773 return REF_TYPE_OTHER_PSEUDOREF;
774 return REF_TYPE_NORMAL;
777 long get_files_ref_lock_timeout_ms(void)
779 static int configured = 0;
781 /* The default timeout is 100 ms: */
782 static int timeout_ms = 100;
784 if (!configured) {
785 git_config_get_int("core.filesreflocktimeout", &timeout_ms);
786 configured = 1;
789 return timeout_ms;
792 int refs_delete_ref(struct ref_store *refs, const char *msg,
793 const char *refname,
794 const struct object_id *old_oid,
795 unsigned int flags)
797 struct ref_transaction *transaction;
798 struct strbuf err = STRBUF_INIT;
800 transaction = ref_store_transaction_begin(refs, &err);
801 if (!transaction ||
802 ref_transaction_delete(transaction, refname, old_oid,
803 flags, msg, &err) ||
804 ref_transaction_commit(transaction, &err)) {
805 error("%s", err.buf);
806 ref_transaction_free(transaction);
807 strbuf_release(&err);
808 return 1;
810 ref_transaction_free(transaction);
811 strbuf_release(&err);
812 return 0;
815 int delete_ref(const char *msg, const char *refname,
816 const struct object_id *old_oid, unsigned int flags)
818 return refs_delete_ref(get_main_ref_store(the_repository), msg, refname,
819 old_oid, flags);
822 static void copy_reflog_msg(struct strbuf *sb, const char *msg)
824 char c;
825 int wasspace = 1;
827 while ((c = *msg++)) {
828 if (wasspace && isspace(c))
829 continue;
830 wasspace = isspace(c);
831 if (wasspace)
832 c = ' ';
833 strbuf_addch(sb, c);
835 strbuf_rtrim(sb);
838 static char *normalize_reflog_message(const char *msg)
840 struct strbuf sb = STRBUF_INIT;
842 if (msg && *msg)
843 copy_reflog_msg(&sb, msg);
844 return strbuf_detach(&sb, NULL);
847 int should_autocreate_reflog(const char *refname)
849 switch (log_all_ref_updates) {
850 case LOG_REFS_ALWAYS:
851 return 1;
852 case LOG_REFS_NORMAL:
853 return starts_with(refname, "refs/heads/") ||
854 starts_with(refname, "refs/remotes/") ||
855 starts_with(refname, "refs/notes/") ||
856 !strcmp(refname, "HEAD");
857 default:
858 return 0;
862 int is_branch(const char *refname)
864 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
867 struct read_ref_at_cb {
868 const char *refname;
869 timestamp_t at_time;
870 int cnt;
871 int reccnt;
872 struct object_id *oid;
873 int found_it;
875 struct object_id ooid;
876 struct object_id noid;
877 int tz;
878 timestamp_t date;
879 char **msg;
880 timestamp_t *cutoff_time;
881 int *cutoff_tz;
882 int *cutoff_cnt;
885 static void set_read_ref_cutoffs(struct read_ref_at_cb *cb,
886 timestamp_t timestamp, int tz, const char *message)
888 if (cb->msg)
889 *cb->msg = xstrdup(message);
890 if (cb->cutoff_time)
891 *cb->cutoff_time = timestamp;
892 if (cb->cutoff_tz)
893 *cb->cutoff_tz = tz;
894 if (cb->cutoff_cnt)
895 *cb->cutoff_cnt = cb->reccnt;
898 static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
899 const char *email, timestamp_t timestamp, int tz,
900 const char *message, void *cb_data)
902 struct read_ref_at_cb *cb = cb_data;
903 int reached_count;
905 cb->tz = tz;
906 cb->date = timestamp;
909 * It is not possible for cb->cnt == 0 on the first iteration because
910 * that special case is handled in read_ref_at().
912 if (cb->cnt > 0)
913 cb->cnt--;
914 reached_count = cb->cnt == 0 && !is_null_oid(ooid);
915 if (timestamp <= cb->at_time || reached_count) {
916 set_read_ref_cutoffs(cb, timestamp, tz, message);
918 * we have not yet updated cb->[n|o]oid so they still
919 * hold the values for the previous record.
921 if (!is_null_oid(&cb->ooid) && !oideq(&cb->ooid, noid))
922 warning(_("log for ref %s has gap after %s"),
923 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
924 if (reached_count)
925 oidcpy(cb->oid, ooid);
926 else if (!is_null_oid(&cb->ooid) || cb->date == cb->at_time)
927 oidcpy(cb->oid, noid);
928 else if (!oideq(noid, cb->oid))
929 warning(_("log for ref %s unexpectedly ended on %s"),
930 cb->refname, show_date(cb->date, cb->tz,
931 DATE_MODE(RFC2822)));
932 cb->found_it = 1;
934 cb->reccnt++;
935 oidcpy(&cb->ooid, ooid);
936 oidcpy(&cb->noid, noid);
937 return cb->found_it;
940 static int read_ref_at_ent_newest(struct object_id *ooid, struct object_id *noid,
941 const char *email, timestamp_t timestamp,
942 int tz, const char *message, void *cb_data)
944 struct read_ref_at_cb *cb = cb_data;
946 set_read_ref_cutoffs(cb, timestamp, tz, message);
947 oidcpy(cb->oid, noid);
948 /* We just want the first entry */
949 return 1;
952 static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
953 const char *email, timestamp_t timestamp,
954 int tz, const char *message, void *cb_data)
956 struct read_ref_at_cb *cb = cb_data;
958 set_read_ref_cutoffs(cb, timestamp, tz, message);
959 oidcpy(cb->oid, ooid);
960 if (is_null_oid(cb->oid))
961 oidcpy(cb->oid, noid);
962 /* We just want the first entry */
963 return 1;
966 int read_ref_at(struct ref_store *refs, const char *refname,
967 unsigned int flags, timestamp_t at_time, int cnt,
968 struct object_id *oid, char **msg,
969 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
971 struct read_ref_at_cb cb;
973 memset(&cb, 0, sizeof(cb));
974 cb.refname = refname;
975 cb.at_time = at_time;
976 cb.cnt = cnt;
977 cb.msg = msg;
978 cb.cutoff_time = cutoff_time;
979 cb.cutoff_tz = cutoff_tz;
980 cb.cutoff_cnt = cutoff_cnt;
981 cb.oid = oid;
983 if (cb.cnt == 0) {
984 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent_newest, &cb);
985 return 0;
988 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
990 if (!cb.reccnt) {
991 if (flags & GET_OID_QUIETLY)
992 exit(128);
993 else
994 die(_("log for %s is empty"), refname);
996 if (cb.found_it)
997 return 0;
999 refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
1001 return 1;
1004 struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
1005 struct strbuf *err)
1007 struct ref_transaction *tr;
1008 assert(err);
1010 CALLOC_ARRAY(tr, 1);
1011 tr->ref_store = refs;
1012 return tr;
1015 struct ref_transaction *ref_transaction_begin(struct strbuf *err)
1017 return ref_store_transaction_begin(get_main_ref_store(the_repository), err);
1020 void ref_transaction_free(struct ref_transaction *transaction)
1022 size_t i;
1024 if (!transaction)
1025 return;
1027 switch (transaction->state) {
1028 case REF_TRANSACTION_OPEN:
1029 case REF_TRANSACTION_CLOSED:
1030 /* OK */
1031 break;
1032 case REF_TRANSACTION_PREPARED:
1033 BUG("free called on a prepared reference transaction");
1034 break;
1035 default:
1036 BUG("unexpected reference transaction state");
1037 break;
1040 for (i = 0; i < transaction->nr; i++) {
1041 free(transaction->updates[i]->msg);
1042 free(transaction->updates[i]);
1044 free(transaction->updates);
1045 free(transaction);
1048 struct ref_update *ref_transaction_add_update(
1049 struct ref_transaction *transaction,
1050 const char *refname, unsigned int flags,
1051 const struct object_id *new_oid,
1052 const struct object_id *old_oid,
1053 const char *msg)
1055 struct ref_update *update;
1057 if (transaction->state != REF_TRANSACTION_OPEN)
1058 BUG("update called for transaction that is not open");
1060 FLEX_ALLOC_STR(update, refname, refname);
1061 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
1062 transaction->updates[transaction->nr++] = update;
1064 update->flags = flags;
1066 if (flags & REF_HAVE_NEW)
1067 oidcpy(&update->new_oid, new_oid);
1068 if (flags & REF_HAVE_OLD)
1069 oidcpy(&update->old_oid, old_oid);
1070 update->msg = normalize_reflog_message(msg);
1071 return update;
1074 int ref_transaction_update(struct ref_transaction *transaction,
1075 const char *refname,
1076 const struct object_id *new_oid,
1077 const struct object_id *old_oid,
1078 unsigned int flags, const char *msg,
1079 struct strbuf *err)
1081 assert(err);
1083 if ((new_oid && !is_null_oid(new_oid)) ?
1084 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
1085 !refname_is_safe(refname)) {
1086 strbuf_addf(err, _("refusing to update ref with bad name '%s'"),
1087 refname);
1088 return -1;
1091 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
1092 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
1094 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
1096 ref_transaction_add_update(transaction, refname, flags,
1097 new_oid, old_oid, msg);
1098 return 0;
1101 int ref_transaction_create(struct ref_transaction *transaction,
1102 const char *refname,
1103 const struct object_id *new_oid,
1104 unsigned int flags, const char *msg,
1105 struct strbuf *err)
1107 if (!new_oid || is_null_oid(new_oid))
1108 BUG("create called without valid new_oid");
1109 return ref_transaction_update(transaction, refname, new_oid,
1110 &null_oid, flags, msg, err);
1113 int ref_transaction_delete(struct ref_transaction *transaction,
1114 const char *refname,
1115 const struct object_id *old_oid,
1116 unsigned int flags, const char *msg,
1117 struct strbuf *err)
1119 if (old_oid && is_null_oid(old_oid))
1120 BUG("delete called with old_oid set to zeros");
1121 return ref_transaction_update(transaction, refname,
1122 &null_oid, old_oid,
1123 flags, msg, err);
1126 int ref_transaction_verify(struct ref_transaction *transaction,
1127 const char *refname,
1128 const struct object_id *old_oid,
1129 unsigned int flags,
1130 struct strbuf *err)
1132 if (!old_oid)
1133 BUG("verify called with old_oid set to NULL");
1134 return ref_transaction_update(transaction, refname,
1135 NULL, old_oid,
1136 flags, NULL, err);
1139 int refs_update_ref(struct ref_store *refs, const char *msg,
1140 const char *refname, const struct object_id *new_oid,
1141 const struct object_id *old_oid, unsigned int flags,
1142 enum action_on_err onerr)
1144 struct ref_transaction *t = NULL;
1145 struct strbuf err = STRBUF_INIT;
1146 int ret = 0;
1148 t = ref_store_transaction_begin(refs, &err);
1149 if (!t ||
1150 ref_transaction_update(t, refname, new_oid, old_oid, flags, msg,
1151 &err) ||
1152 ref_transaction_commit(t, &err)) {
1153 ret = 1;
1154 ref_transaction_free(t);
1156 if (ret) {
1157 const char *str = _("update_ref failed for ref '%s': %s");
1159 switch (onerr) {
1160 case UPDATE_REFS_MSG_ON_ERR:
1161 error(str, refname, err.buf);
1162 break;
1163 case UPDATE_REFS_DIE_ON_ERR:
1164 die(str, refname, err.buf);
1165 break;
1166 case UPDATE_REFS_QUIET_ON_ERR:
1167 break;
1169 strbuf_release(&err);
1170 return 1;
1172 strbuf_release(&err);
1173 if (t)
1174 ref_transaction_free(t);
1175 return 0;
1178 int update_ref(const char *msg, const char *refname,
1179 const struct object_id *new_oid,
1180 const struct object_id *old_oid,
1181 unsigned int flags, enum action_on_err onerr)
1183 return refs_update_ref(get_main_ref_store(the_repository), msg, refname, new_oid,
1184 old_oid, flags, onerr);
1187 char *refs_shorten_unambiguous_ref(struct ref_store *refs,
1188 const char *refname, int strict)
1190 int i;
1191 static char **scanf_fmts;
1192 static int nr_rules;
1193 char *short_name;
1194 struct strbuf resolved_buf = STRBUF_INIT;
1196 if (!nr_rules) {
1198 * Pre-generate scanf formats from ref_rev_parse_rules[].
1199 * Generate a format suitable for scanf from a
1200 * ref_rev_parse_rules rule by interpolating "%s" at the
1201 * location of the "%.*s".
1203 size_t total_len = 0;
1204 size_t offset = 0;
1206 /* the rule list is NULL terminated, count them first */
1207 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
1208 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1209 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
1211 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
1213 offset = 0;
1214 for (i = 0; i < nr_rules; i++) {
1215 assert(offset < total_len);
1216 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
1217 offset += xsnprintf(scanf_fmts[i], total_len - offset,
1218 ref_rev_parse_rules[i], 2, "%s") + 1;
1222 /* bail out if there are no rules */
1223 if (!nr_rules)
1224 return xstrdup(refname);
1226 /* buffer for scanf result, at most refname must fit */
1227 short_name = xstrdup(refname);
1229 /* skip first rule, it will always match */
1230 for (i = nr_rules - 1; i > 0 ; --i) {
1231 int j;
1232 int rules_to_fail = i;
1233 int short_name_len;
1235 if (1 != sscanf(refname, scanf_fmts[i], short_name))
1236 continue;
1238 short_name_len = strlen(short_name);
1241 * in strict mode, all (except the matched one) rules
1242 * must fail to resolve to a valid non-ambiguous ref
1244 if (strict)
1245 rules_to_fail = nr_rules;
1248 * check if the short name resolves to a valid ref,
1249 * but use only rules prior to the matched one
1251 for (j = 0; j < rules_to_fail; j++) {
1252 const char *rule = ref_rev_parse_rules[j];
1254 /* skip matched rule */
1255 if (i == j)
1256 continue;
1259 * the short name is ambiguous, if it resolves
1260 * (with this previous rule) to a valid ref
1261 * read_ref() returns 0 on success
1263 strbuf_reset(&resolved_buf);
1264 strbuf_addf(&resolved_buf, rule,
1265 short_name_len, short_name);
1266 if (refs_ref_exists(refs, resolved_buf.buf))
1267 break;
1271 * short name is non-ambiguous if all previous rules
1272 * haven't resolved to a valid ref
1274 if (j == rules_to_fail) {
1275 strbuf_release(&resolved_buf);
1276 return short_name;
1280 strbuf_release(&resolved_buf);
1281 free(short_name);
1282 return xstrdup(refname);
1285 char *shorten_unambiguous_ref(const char *refname, int strict)
1287 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
1288 refname, strict);
1291 static struct string_list *hide_refs;
1293 int parse_hide_refs_config(const char *var, const char *value, const char *section)
1295 const char *key;
1296 if (!strcmp("transfer.hiderefs", var) ||
1297 (!parse_config_key(var, section, NULL, NULL, &key) &&
1298 !strcmp(key, "hiderefs"))) {
1299 char *ref;
1300 int len;
1302 if (!value)
1303 return config_error_nonbool(var);
1304 ref = xstrdup(value);
1305 len = strlen(ref);
1306 while (len && ref[len - 1] == '/')
1307 ref[--len] = '\0';
1308 if (!hide_refs) {
1309 CALLOC_ARRAY(hide_refs, 1);
1310 hide_refs->strdup_strings = 1;
1312 string_list_append(hide_refs, ref);
1314 return 0;
1317 int ref_is_hidden(const char *refname, const char *refname_full)
1319 int i;
1321 if (!hide_refs)
1322 return 0;
1323 for (i = hide_refs->nr - 1; i >= 0; i--) {
1324 const char *match = hide_refs->items[i].string;
1325 const char *subject;
1326 int neg = 0;
1327 const char *p;
1329 if (*match == '!') {
1330 neg = 1;
1331 match++;
1334 if (*match == '^') {
1335 subject = refname_full;
1336 match++;
1337 } else {
1338 subject = refname;
1341 /* refname can be NULL when namespaces are used. */
1342 if (subject &&
1343 skip_prefix(subject, match, &p) &&
1344 (!*p || *p == '/'))
1345 return !neg;
1347 return 0;
1350 const char *find_descendant_ref(const char *dirname,
1351 const struct string_list *extras,
1352 const struct string_list *skip)
1354 int pos;
1356 if (!extras)
1357 return NULL;
1360 * Look at the place where dirname would be inserted into
1361 * extras. If there is an entry at that position that starts
1362 * with dirname (remember, dirname includes the trailing
1363 * slash) and is not in skip, then we have a conflict.
1365 for (pos = string_list_find_insert_index(extras, dirname, 0);
1366 pos < extras->nr; pos++) {
1367 const char *extra_refname = extras->items[pos].string;
1369 if (!starts_with(extra_refname, dirname))
1370 break;
1372 if (!skip || !string_list_has_string(skip, extra_refname))
1373 return extra_refname;
1375 return NULL;
1378 int refs_rename_ref_available(struct ref_store *refs,
1379 const char *old_refname,
1380 const char *new_refname)
1382 struct string_list skip = STRING_LIST_INIT_NODUP;
1383 struct strbuf err = STRBUF_INIT;
1384 int ok;
1386 string_list_insert(&skip, old_refname);
1387 ok = !refs_verify_refname_available(refs, new_refname,
1388 NULL, &skip, &err);
1389 if (!ok)
1390 error("%s", err.buf);
1392 string_list_clear(&skip, 0);
1393 strbuf_release(&err);
1394 return ok;
1397 int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1399 struct object_id oid;
1400 int flag;
1402 if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING,
1403 &oid, &flag))
1404 return fn("HEAD", &oid, flag, cb_data);
1406 return 0;
1409 int head_ref(each_ref_fn fn, void *cb_data)
1411 return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
1414 struct ref_iterator *refs_ref_iterator_begin(
1415 struct ref_store *refs,
1416 const char *prefix, int trim, int flags)
1418 struct ref_iterator *iter;
1420 if (ref_paranoia < 0)
1421 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);
1422 if (ref_paranoia)
1423 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1425 iter = refs->be->iterator_begin(refs, prefix, flags);
1428 * `iterator_begin()` already takes care of prefix, but we
1429 * might need to do some trimming:
1431 if (trim)
1432 iter = prefix_ref_iterator_begin(iter, "", trim);
1434 /* Sanity check for subclasses: */
1435 if (!iter->ordered)
1436 BUG("reference iterator is not ordered");
1438 return iter;
1442 * Call fn for each reference in the specified submodule for which the
1443 * refname begins with prefix. If trim is non-zero, then trim that
1444 * many characters off the beginning of each refname before passing
1445 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1446 * include broken references in the iteration. If fn ever returns a
1447 * non-zero value, stop the iteration and return that value;
1448 * otherwise, return 0.
1450 static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1451 each_repo_ref_fn fn, int trim, int flags,
1452 void *cb_data)
1454 struct ref_iterator *iter;
1455 struct ref_store *refs = get_main_ref_store(r);
1457 if (!refs)
1458 return 0;
1460 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1462 return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1465 struct do_for_each_ref_help {
1466 each_ref_fn *fn;
1467 void *cb_data;
1470 static int do_for_each_ref_helper(struct repository *r,
1471 const char *refname,
1472 const struct object_id *oid,
1473 int flags,
1474 void *cb_data)
1476 struct do_for_each_ref_help *hp = cb_data;
1478 return hp->fn(refname, oid, flags, hp->cb_data);
1481 static int do_for_each_ref(struct ref_store *refs, const char *prefix,
1482 each_ref_fn fn, int trim, int flags, void *cb_data)
1484 struct ref_iterator *iter;
1485 struct do_for_each_ref_help hp = { fn, cb_data };
1487 if (!refs)
1488 return 0;
1490 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1492 return do_for_each_repo_ref_iterator(the_repository, iter,
1493 do_for_each_ref_helper, &hp);
1496 int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1498 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1501 int for_each_ref(each_ref_fn fn, void *cb_data)
1503 return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
1506 int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1507 each_ref_fn fn, void *cb_data)
1509 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
1512 int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1514 return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
1517 int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
1519 unsigned int flag = 0;
1521 if (broken)
1522 flag = DO_FOR_EACH_INCLUDE_BROKEN;
1523 return do_for_each_ref(get_main_ref_store(the_repository),
1524 prefix, fn, 0, flag, cb_data);
1527 int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
1528 each_ref_fn fn, void *cb_data,
1529 unsigned int broken)
1531 unsigned int flag = 0;
1533 if (broken)
1534 flag = DO_FOR_EACH_INCLUDE_BROKEN;
1535 return do_for_each_ref(refs, prefix, fn, 0, flag, cb_data);
1538 int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
1540 return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1541 strlen(git_replace_ref_base),
1542 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1545 int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1547 struct strbuf buf = STRBUF_INIT;
1548 int ret;
1549 strbuf_addf(&buf, "%srefs/", get_git_namespace());
1550 ret = do_for_each_ref(get_main_ref_store(the_repository),
1551 buf.buf, fn, 0, 0, cb_data);
1552 strbuf_release(&buf);
1553 return ret;
1556 int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1558 return do_for_each_ref(refs, "", fn, 0,
1559 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1562 int for_each_rawref(each_ref_fn fn, void *cb_data)
1564 return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
1567 static int qsort_strcmp(const void *va, const void *vb)
1569 const char *a = *(const char **)va;
1570 const char *b = *(const char **)vb;
1572 return strcmp(a, b);
1575 static void find_longest_prefixes_1(struct string_list *out,
1576 struct strbuf *prefix,
1577 const char **patterns, size_t nr)
1579 size_t i;
1581 for (i = 0; i < nr; i++) {
1582 char c = patterns[i][prefix->len];
1583 if (!c || is_glob_special(c)) {
1584 string_list_append(out, prefix->buf);
1585 return;
1589 i = 0;
1590 while (i < nr) {
1591 size_t end;
1594 * Set "end" to the index of the element _after_ the last one
1595 * in our group.
1597 for (end = i + 1; end < nr; end++) {
1598 if (patterns[i][prefix->len] != patterns[end][prefix->len])
1599 break;
1602 strbuf_addch(prefix, patterns[i][prefix->len]);
1603 find_longest_prefixes_1(out, prefix, patterns + i, end - i);
1604 strbuf_setlen(prefix, prefix->len - 1);
1606 i = end;
1610 static void find_longest_prefixes(struct string_list *out,
1611 const char **patterns)
1613 struct strvec sorted = STRVEC_INIT;
1614 struct strbuf prefix = STRBUF_INIT;
1616 strvec_pushv(&sorted, patterns);
1617 QSORT(sorted.v, sorted.nr, qsort_strcmp);
1619 find_longest_prefixes_1(out, &prefix, sorted.v, sorted.nr);
1621 strvec_clear(&sorted);
1622 strbuf_release(&prefix);
1625 int for_each_fullref_in_prefixes(const char *namespace,
1626 const char **patterns,
1627 each_ref_fn fn, void *cb_data,
1628 unsigned int broken)
1630 struct string_list prefixes = STRING_LIST_INIT_DUP;
1631 struct string_list_item *prefix;
1632 struct strbuf buf = STRBUF_INIT;
1633 int ret = 0, namespace_len;
1635 find_longest_prefixes(&prefixes, patterns);
1637 if (namespace)
1638 strbuf_addstr(&buf, namespace);
1639 namespace_len = buf.len;
1641 for_each_string_list_item(prefix, &prefixes) {
1642 strbuf_addstr(&buf, prefix->string);
1643 ret = for_each_fullref_in(buf.buf, fn, cb_data, broken);
1644 if (ret)
1645 break;
1646 strbuf_setlen(&buf, namespace_len);
1649 string_list_clear(&prefixes, 0);
1650 strbuf_release(&buf);
1651 return ret;
1654 static int refs_read_special_head(struct ref_store *ref_store,
1655 const char *refname, struct object_id *oid,
1656 struct strbuf *referent, unsigned int *type)
1658 struct strbuf full_path = STRBUF_INIT;
1659 struct strbuf content = STRBUF_INIT;
1660 int result = -1;
1661 strbuf_addf(&full_path, "%s/%s", ref_store->gitdir, refname);
1663 if (strbuf_read_file(&content, full_path.buf, 0) < 0)
1664 goto done;
1666 result = parse_loose_ref_contents(content.buf, oid, referent, type);
1668 done:
1669 strbuf_release(&full_path);
1670 strbuf_release(&content);
1671 return result;
1674 int refs_read_raw_ref(struct ref_store *ref_store,
1675 const char *refname, struct object_id *oid,
1676 struct strbuf *referent, unsigned int *type)
1678 if (!strcmp(refname, "FETCH_HEAD") || !strcmp(refname, "MERGE_HEAD")) {
1679 return refs_read_special_head(ref_store, refname, oid, referent,
1680 type);
1683 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent,
1684 type);
1687 /* This function needs to return a meaningful errno on failure */
1688 const char *refs_resolve_ref_unsafe(struct ref_store *refs,
1689 const char *refname,
1690 int resolve_flags,
1691 struct object_id *oid, int *flags)
1693 static struct strbuf sb_refname = STRBUF_INIT;
1694 struct object_id unused_oid;
1695 int unused_flags;
1696 int symref_count;
1698 if (!oid)
1699 oid = &unused_oid;
1700 if (!flags)
1701 flags = &unused_flags;
1703 *flags = 0;
1705 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1706 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1707 !refname_is_safe(refname)) {
1708 errno = EINVAL;
1709 return NULL;
1713 * dwim_ref() uses REF_ISBROKEN to distinguish between
1714 * missing refs and refs that were present but invalid,
1715 * to complain about the latter to stderr.
1717 * We don't know whether the ref exists, so don't set
1718 * REF_ISBROKEN yet.
1720 *flags |= REF_BAD_NAME;
1723 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1724 unsigned int read_flags = 0;
1726 if (refs_read_raw_ref(refs, refname,
1727 oid, &sb_refname, &read_flags)) {
1728 *flags |= read_flags;
1730 /* In reading mode, refs must eventually resolve */
1731 if (resolve_flags & RESOLVE_REF_READING)
1732 return NULL;
1735 * Otherwise a missing ref is OK. But the files backend
1736 * may show errors besides ENOENT if there are
1737 * similarly-named refs.
1739 if (errno != ENOENT &&
1740 errno != EISDIR &&
1741 errno != ENOTDIR)
1742 return NULL;
1744 oidclr(oid);
1745 if (*flags & REF_BAD_NAME)
1746 *flags |= REF_ISBROKEN;
1747 return refname;
1750 *flags |= read_flags;
1752 if (!(read_flags & REF_ISSYMREF)) {
1753 if (*flags & REF_BAD_NAME) {
1754 oidclr(oid);
1755 *flags |= REF_ISBROKEN;
1757 return refname;
1760 refname = sb_refname.buf;
1761 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1762 oidclr(oid);
1763 return refname;
1765 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1766 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1767 !refname_is_safe(refname)) {
1768 errno = EINVAL;
1769 return NULL;
1772 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1776 errno = ELOOP;
1777 return NULL;
1780 /* backend functions */
1781 int refs_init_db(struct strbuf *err)
1783 struct ref_store *refs = get_main_ref_store(the_repository);
1785 return refs->be->init_db(refs, err);
1788 const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1789 struct object_id *oid, int *flags)
1791 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
1792 resolve_flags, oid, flags);
1795 int resolve_gitlink_ref(const char *submodule, const char *refname,
1796 struct object_id *oid)
1798 struct ref_store *refs;
1799 int flags;
1801 refs = get_submodule_ref_store(submodule);
1803 if (!refs)
1804 return -1;
1806 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
1807 is_null_oid(oid))
1808 return -1;
1809 return 0;
1812 struct ref_store_hash_entry
1814 struct hashmap_entry ent;
1816 struct ref_store *refs;
1818 /* NUL-terminated identifier of the ref store: */
1819 char name[FLEX_ARRAY];
1822 static int ref_store_hash_cmp(const void *unused_cmp_data,
1823 const struct hashmap_entry *eptr,
1824 const struct hashmap_entry *entry_or_key,
1825 const void *keydata)
1827 const struct ref_store_hash_entry *e1, *e2;
1828 const char *name;
1830 e1 = container_of(eptr, const struct ref_store_hash_entry, ent);
1831 e2 = container_of(entry_or_key, const struct ref_store_hash_entry, ent);
1832 name = keydata ? keydata : e2->name;
1834 return strcmp(e1->name, name);
1837 static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1838 const char *name, struct ref_store *refs)
1840 struct ref_store_hash_entry *entry;
1842 FLEX_ALLOC_STR(entry, name, name);
1843 hashmap_entry_init(&entry->ent, strhash(name));
1844 entry->refs = refs;
1845 return entry;
1848 /* A hashmap of ref_stores, stored by submodule name: */
1849 static struct hashmap submodule_ref_stores;
1851 /* A hashmap of ref_stores, stored by worktree id: */
1852 static struct hashmap worktree_ref_stores;
1855 * Look up a ref store by name. If that ref_store hasn't been
1856 * registered yet, return NULL.
1858 static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1859 const char *name)
1861 struct ref_store_hash_entry *entry;
1862 unsigned int hash;
1864 if (!map->tablesize)
1865 /* It's initialized on demand in register_ref_store(). */
1866 return NULL;
1868 hash = strhash(name);
1869 entry = hashmap_get_entry_from_hash(map, hash, name,
1870 struct ref_store_hash_entry, ent);
1871 return entry ? entry->refs : NULL;
1875 * Create, record, and return a ref_store instance for the specified
1876 * gitdir.
1878 static struct ref_store *ref_store_init(const char *gitdir,
1879 unsigned int flags)
1881 const char *be_name = "files";
1882 struct ref_storage_be *be = find_ref_storage_backend(be_name);
1883 struct ref_store *refs;
1885 if (!be)
1886 BUG("reference backend %s is unknown", be_name);
1888 refs = be->init(gitdir, flags);
1889 return refs;
1892 struct ref_store *get_main_ref_store(struct repository *r)
1894 if (r->refs_private)
1895 return r->refs_private;
1897 if (!r->gitdir)
1898 BUG("attempting to get main_ref_store outside of repository");
1900 r->refs_private = ref_store_init(r->gitdir, REF_STORE_ALL_CAPS);
1901 r->refs_private = maybe_debug_wrap_ref_store(r->gitdir, r->refs_private);
1902 return r->refs_private;
1906 * Associate a ref store with a name. It is a fatal error to call this
1907 * function twice for the same name.
1909 static void register_ref_store_map(struct hashmap *map,
1910 const char *type,
1911 struct ref_store *refs,
1912 const char *name)
1914 struct ref_store_hash_entry *entry;
1916 if (!map->tablesize)
1917 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
1919 entry = alloc_ref_store_hash_entry(name, refs);
1920 if (hashmap_put(map, &entry->ent))
1921 BUG("%s ref_store '%s' initialized twice", type, name);
1924 struct ref_store *get_submodule_ref_store(const char *submodule)
1926 struct strbuf submodule_sb = STRBUF_INIT;
1927 struct ref_store *refs;
1928 char *to_free = NULL;
1929 size_t len;
1931 if (!submodule)
1932 return NULL;
1934 len = strlen(submodule);
1935 while (len && is_dir_sep(submodule[len - 1]))
1936 len--;
1937 if (!len)
1938 return NULL;
1940 if (submodule[len])
1941 /* We need to strip off one or more trailing slashes */
1942 submodule = to_free = xmemdupz(submodule, len);
1944 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
1945 if (refs)
1946 goto done;
1948 strbuf_addstr(&submodule_sb, submodule);
1949 if (!is_nonbare_repository_dir(&submodule_sb))
1950 goto done;
1952 if (submodule_to_gitdir(&submodule_sb, submodule))
1953 goto done;
1955 /* assume that add_submodule_odb() has been called */
1956 refs = ref_store_init(submodule_sb.buf,
1957 REF_STORE_READ | REF_STORE_ODB);
1958 register_ref_store_map(&submodule_ref_stores, "submodule",
1959 refs, submodule);
1961 done:
1962 strbuf_release(&submodule_sb);
1963 free(to_free);
1965 return refs;
1968 struct ref_store *get_worktree_ref_store(const struct worktree *wt)
1970 struct ref_store *refs;
1971 const char *id;
1973 if (wt->is_current)
1974 return get_main_ref_store(the_repository);
1976 id = wt->id ? wt->id : "/";
1977 refs = lookup_ref_store_map(&worktree_ref_stores, id);
1978 if (refs)
1979 return refs;
1981 if (wt->id)
1982 refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
1983 REF_STORE_ALL_CAPS);
1984 else
1985 refs = ref_store_init(get_git_common_dir(),
1986 REF_STORE_ALL_CAPS);
1988 if (refs)
1989 register_ref_store_map(&worktree_ref_stores, "worktree",
1990 refs, id);
1991 return refs;
1994 void base_ref_store_init(struct ref_store *refs,
1995 const struct ref_storage_be *be)
1997 refs->be = be;
2000 /* backend functions */
2001 int refs_pack_refs(struct ref_store *refs, unsigned int flags)
2003 return refs->be->pack_refs(refs, flags);
2006 int peel_iterated_oid(const struct object_id *base, struct object_id *peeled)
2008 if (current_ref_iter &&
2009 (current_ref_iter->oid == base ||
2010 oideq(current_ref_iter->oid, base)))
2011 return ref_iterator_peel(current_ref_iter, peeled);
2013 return peel_object(base, peeled);
2016 int refs_create_symref(struct ref_store *refs,
2017 const char *ref_target,
2018 const char *refs_heads_master,
2019 const char *logmsg)
2021 char *msg;
2022 int retval;
2024 msg = normalize_reflog_message(logmsg);
2025 retval = refs->be->create_symref(refs, ref_target, refs_heads_master,
2026 msg);
2027 free(msg);
2028 return retval;
2031 int create_symref(const char *ref_target, const char *refs_heads_master,
2032 const char *logmsg)
2034 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
2035 refs_heads_master, logmsg);
2038 int ref_update_reject_duplicates(struct string_list *refnames,
2039 struct strbuf *err)
2041 size_t i, n = refnames->nr;
2043 assert(err);
2045 for (i = 1; i < n; i++) {
2046 int cmp = strcmp(refnames->items[i - 1].string,
2047 refnames->items[i].string);
2049 if (!cmp) {
2050 strbuf_addf(err,
2051 _("multiple updates for ref '%s' not allowed"),
2052 refnames->items[i].string);
2053 return 1;
2054 } else if (cmp > 0) {
2055 BUG("ref_update_reject_duplicates() received unsorted list");
2058 return 0;
2061 static int run_transaction_hook(struct ref_transaction *transaction,
2062 const char *state)
2064 struct child_process proc = CHILD_PROCESS_INIT;
2065 struct strbuf buf = STRBUF_INIT;
2066 const char *hook;
2067 int ret = 0, i;
2069 hook = find_hook("reference-transaction");
2070 if (!hook)
2071 return ret;
2073 strvec_pushl(&proc.args, hook, state, NULL);
2074 proc.in = -1;
2075 proc.stdout_to_stderr = 1;
2076 proc.trace2_hook_name = "reference-transaction";
2078 ret = start_command(&proc);
2079 if (ret)
2080 return ret;
2082 sigchain_push(SIGPIPE, SIG_IGN);
2084 for (i = 0; i < transaction->nr; i++) {
2085 struct ref_update *update = transaction->updates[i];
2087 strbuf_reset(&buf);
2088 strbuf_addf(&buf, "%s %s %s\n",
2089 oid_to_hex(&update->old_oid),
2090 oid_to_hex(&update->new_oid),
2091 update->refname);
2093 if (write_in_full(proc.in, buf.buf, buf.len) < 0) {
2094 if (errno != EPIPE)
2095 ret = -1;
2096 break;
2100 close(proc.in);
2101 sigchain_pop(SIGPIPE);
2102 strbuf_release(&buf);
2104 ret |= finish_command(&proc);
2105 return ret;
2108 int ref_transaction_prepare(struct ref_transaction *transaction,
2109 struct strbuf *err)
2111 struct ref_store *refs = transaction->ref_store;
2112 int ret;
2114 switch (transaction->state) {
2115 case REF_TRANSACTION_OPEN:
2116 /* Good. */
2117 break;
2118 case REF_TRANSACTION_PREPARED:
2119 BUG("prepare called twice on reference transaction");
2120 break;
2121 case REF_TRANSACTION_CLOSED:
2122 BUG("prepare called on a closed reference transaction");
2123 break;
2124 default:
2125 BUG("unexpected reference transaction state");
2126 break;
2129 if (getenv(GIT_QUARANTINE_ENVIRONMENT)) {
2130 strbuf_addstr(err,
2131 _("ref updates forbidden inside quarantine environment"));
2132 return -1;
2135 ret = refs->be->transaction_prepare(refs, transaction, err);
2136 if (ret)
2137 return ret;
2139 ret = run_transaction_hook(transaction, "prepared");
2140 if (ret) {
2141 ref_transaction_abort(transaction, err);
2142 die(_("ref updates aborted by hook"));
2145 return 0;
2148 int ref_transaction_abort(struct ref_transaction *transaction,
2149 struct strbuf *err)
2151 struct ref_store *refs = transaction->ref_store;
2152 int ret = 0;
2154 switch (transaction->state) {
2155 case REF_TRANSACTION_OPEN:
2156 /* No need to abort explicitly. */
2157 break;
2158 case REF_TRANSACTION_PREPARED:
2159 ret = refs->be->transaction_abort(refs, transaction, err);
2160 break;
2161 case REF_TRANSACTION_CLOSED:
2162 BUG("abort called on a closed reference transaction");
2163 break;
2164 default:
2165 BUG("unexpected reference transaction state");
2166 break;
2169 run_transaction_hook(transaction, "aborted");
2171 ref_transaction_free(transaction);
2172 return ret;
2175 int ref_transaction_commit(struct ref_transaction *transaction,
2176 struct strbuf *err)
2178 struct ref_store *refs = transaction->ref_store;
2179 int ret;
2181 switch (transaction->state) {
2182 case REF_TRANSACTION_OPEN:
2183 /* Need to prepare first. */
2184 ret = ref_transaction_prepare(transaction, err);
2185 if (ret)
2186 return ret;
2187 break;
2188 case REF_TRANSACTION_PREPARED:
2189 /* Fall through to finish. */
2190 break;
2191 case REF_TRANSACTION_CLOSED:
2192 BUG("commit called on a closed reference transaction");
2193 break;
2194 default:
2195 BUG("unexpected reference transaction state");
2196 break;
2199 ret = refs->be->transaction_finish(refs, transaction, err);
2200 if (!ret)
2201 run_transaction_hook(transaction, "committed");
2202 return ret;
2205 int refs_verify_refname_available(struct ref_store *refs,
2206 const char *refname,
2207 const struct string_list *extras,
2208 const struct string_list *skip,
2209 struct strbuf *err)
2211 const char *slash;
2212 const char *extra_refname;
2213 struct strbuf dirname = STRBUF_INIT;
2214 struct strbuf referent = STRBUF_INIT;
2215 struct object_id oid;
2216 unsigned int type;
2217 struct ref_iterator *iter;
2218 int ok;
2219 int ret = -1;
2222 * For the sake of comments in this function, suppose that
2223 * refname is "refs/foo/bar".
2226 assert(err);
2228 strbuf_grow(&dirname, strlen(refname) + 1);
2229 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
2230 /* Expand dirname to the new prefix, not including the trailing slash: */
2231 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2234 * We are still at a leading dir of the refname (e.g.,
2235 * "refs/foo"; if there is a reference with that name,
2236 * it is a conflict, *unless* it is in skip.
2238 if (skip && string_list_has_string(skip, dirname.buf))
2239 continue;
2241 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) {
2242 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2243 dirname.buf, refname);
2244 goto cleanup;
2247 if (extras && string_list_has_string(extras, dirname.buf)) {
2248 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2249 refname, dirname.buf);
2250 goto cleanup;
2255 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2256 * There is no point in searching for a reference with that
2257 * name, because a refname isn't considered to conflict with
2258 * itself. But we still need to check for references whose
2259 * names are in the "refs/foo/bar/" namespace, because they
2260 * *do* conflict.
2262 strbuf_addstr(&dirname, refname + dirname.len);
2263 strbuf_addch(&dirname, '/');
2265 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
2266 DO_FOR_EACH_INCLUDE_BROKEN);
2267 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2268 if (skip &&
2269 string_list_has_string(skip, iter->refname))
2270 continue;
2272 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2273 iter->refname, refname);
2274 ref_iterator_abort(iter);
2275 goto cleanup;
2278 if (ok != ITER_DONE)
2279 BUG("error while iterating over references");
2281 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2282 if (extra_refname)
2283 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2284 refname, extra_refname);
2285 else
2286 ret = 0;
2288 cleanup:
2289 strbuf_release(&referent);
2290 strbuf_release(&dirname);
2291 return ret;
2294 int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2296 struct ref_iterator *iter;
2297 struct do_for_each_ref_help hp = { fn, cb_data };
2299 iter = refs->be->reflog_iterator_begin(refs);
2301 return do_for_each_repo_ref_iterator(the_repository, iter,
2302 do_for_each_ref_helper, &hp);
2305 int for_each_reflog(each_ref_fn fn, void *cb_data)
2307 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
2310 int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2311 const char *refname,
2312 each_reflog_ent_fn fn,
2313 void *cb_data)
2315 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2316 fn, cb_data);
2319 int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2320 void *cb_data)
2322 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
2323 refname, fn, cb_data);
2326 int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2327 each_reflog_ent_fn fn, void *cb_data)
2329 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2332 int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2333 void *cb_data)
2335 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
2336 fn, cb_data);
2339 int refs_reflog_exists(struct ref_store *refs, const char *refname)
2341 return refs->be->reflog_exists(refs, refname);
2344 int reflog_exists(const char *refname)
2346 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
2349 int refs_create_reflog(struct ref_store *refs, const char *refname,
2350 int force_create, struct strbuf *err)
2352 return refs->be->create_reflog(refs, refname, force_create, err);
2355 int safe_create_reflog(const char *refname, int force_create,
2356 struct strbuf *err)
2358 return refs_create_reflog(get_main_ref_store(the_repository), refname,
2359 force_create, err);
2362 int refs_delete_reflog(struct ref_store *refs, const char *refname)
2364 return refs->be->delete_reflog(refs, refname);
2367 int delete_reflog(const char *refname)
2369 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
2372 int refs_reflog_expire(struct ref_store *refs,
2373 const char *refname, const struct object_id *oid,
2374 unsigned int flags,
2375 reflog_expiry_prepare_fn prepare_fn,
2376 reflog_expiry_should_prune_fn should_prune_fn,
2377 reflog_expiry_cleanup_fn cleanup_fn,
2378 void *policy_cb_data)
2380 return refs->be->reflog_expire(refs, refname, oid, flags,
2381 prepare_fn, should_prune_fn,
2382 cleanup_fn, policy_cb_data);
2385 int reflog_expire(const char *refname, const struct object_id *oid,
2386 unsigned int flags,
2387 reflog_expiry_prepare_fn prepare_fn,
2388 reflog_expiry_should_prune_fn should_prune_fn,
2389 reflog_expiry_cleanup_fn cleanup_fn,
2390 void *policy_cb_data)
2392 return refs_reflog_expire(get_main_ref_store(the_repository),
2393 refname, oid, flags,
2394 prepare_fn, should_prune_fn,
2395 cleanup_fn, policy_cb_data);
2398 int initial_ref_transaction_commit(struct ref_transaction *transaction,
2399 struct strbuf *err)
2401 struct ref_store *refs = transaction->ref_store;
2403 return refs->be->initial_transaction_commit(refs, transaction, err);
2406 int refs_delete_refs(struct ref_store *refs, const char *logmsg,
2407 struct string_list *refnames, unsigned int flags)
2409 char *msg;
2410 int retval;
2412 msg = normalize_reflog_message(logmsg);
2413 retval = refs->be->delete_refs(refs, msg, refnames, flags);
2414 free(msg);
2415 return retval;
2418 int delete_refs(const char *msg, struct string_list *refnames,
2419 unsigned int flags)
2421 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
2424 int refs_rename_ref(struct ref_store *refs, const char *oldref,
2425 const char *newref, const char *logmsg)
2427 char *msg;
2428 int retval;
2430 msg = normalize_reflog_message(logmsg);
2431 retval = refs->be->rename_ref(refs, oldref, newref, msg);
2432 free(msg);
2433 return retval;
2436 int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2438 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
2441 int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2442 const char *newref, const char *logmsg)
2444 char *msg;
2445 int retval;
2447 msg = normalize_reflog_message(logmsg);
2448 retval = refs->be->copy_ref(refs, oldref, newref, msg);
2449 free(msg);
2450 return retval;
2453 int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2455 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);