]> git.ipfire.org Git - thirdparty/git.git/blame - refs.c
refs: drop "broken" flag from for_each_fullref_in()
[thirdparty/git.git] / refs.c
CommitLineData
7bd9bcf3
MH
1/*
2 * The backend-independent part of the reference module.
3 */
4
95fc7512 5#include "cache.h"
b2141fc1 6#include "config.h"
7d4558c4 7#include "hashmap.h"
697cc8ef 8#include "lockfile.h"
b05855b5 9#include "iterator.h"
85023577 10#include "refs.h"
4cb77009 11#include "refs/refs-internal.h"
67541597 12#include "run-command.h"
cbd53a21 13#include "object-store.h"
cf0adba7
JH
14#include "object.h"
15#include "tag.h"
5d0bc90e 16#include "submodule.h"
17eff96b 17#include "worktree.h"
dbbcd44f 18#include "strvec.h"
23a3f0cb 19#include "repository.h"
67541597 20#include "sigchain.h"
3581d793 21
3dce444f
RS
22/*
23 * List of all available backends
24 */
25static struct ref_storage_be *refs_backends = &refs_be_files;
26
27static struct ref_storage_be *find_ref_storage_backend(const char *name)
28{
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;
34}
35
36int ref_storage_backend_exists(const char *name)
37{
38 return find_ref_storage_backend(name) != NULL;
39}
40
bc5fd6d3 41/*
dde8a902
DT
42 * How to handle various characters in refnames:
43 * 0: An acceptable character for refs
5e650228
JH
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
53a8555e 47 * 4: A bad character: ASCII control characters, and
cd377f45
JK
48 * ":", "?", "[", "\", "^", "~", SP, or TAB
49 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
dde8a902
DT
50 */
51static unsigned char refname_disposition[256] = {
5e650228
JH
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,
cd377f45 54 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
5e650228 55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
dde8a902 56 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5e650228
JH
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
dde8a902
DT
60};
61
62/*
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:
bc5fd6d3 67 *
1de16aec 68 * - it begins with ".", or
bc5fd6d3 69 * - it has double dots "..", or
53a8555e 70 * - it has ASCII control characters, or
cd377f45
JK
71 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
72 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
53a8555e
JK
73 * - it ends with a "/", or
74 * - it ends with ".lock", or
75 * - it contains a "@{" portion
1de16aec
NTND
76 *
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.
bc5fd6d3 80 */
1de16aec
NTND
81static int check_refname_component(const char *refname, int *flags,
82 struct strbuf *sanitized)
bc5fd6d3
MH
83{
84 const char *cp;
85 char last = '\0';
1de16aec
NTND
86 size_t component_start = 0; /* garbage - not a reasonable initial value */
87
88 if (sanitized)
89 component_start = sanitized->len;
bc5fd6d3
MH
90
91 for (cp = refname; ; cp++) {
dde8a902
DT
92 int ch = *cp & 255;
93 unsigned char disp = refname_disposition[ch];
1de16aec
NTND
94
95 if (sanitized && disp != 1)
96 strbuf_addch(sanitized, ch);
97
dde8a902 98 switch (disp) {
5e650228 99 case 1:
dde8a902 100 goto out;
5e650228 101 case 2:
1de16aec
NTND
102 if (last == '.') { /* Refname contains "..". */
103 if (sanitized)
104 /* collapse ".." to single "." */
105 strbuf_setlen(sanitized, sanitized->len - 1);
106 else
107 return -1;
108 }
dde8a902 109 break;
5e650228 110 case 3:
1de16aec
NTND
111 if (last == '@') { /* Refname contains "@{". */
112 if (sanitized)
113 sanitized->buf[sanitized->len-1] = '-';
114 else
115 return -1;
116 }
bc5fd6d3 117 break;
5e650228 118 case 4:
1de16aec
NTND
119 /* forbidden char */
120 if (sanitized)
121 sanitized->buf[sanitized->len-1] = '-';
122 else
123 return -1;
124 break;
cd377f45 125 case 5:
1de16aec
NTND
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;
132 }
cd377f45
JK
133
134 /*
135 * Unset the pattern flag so that we only accept
136 * a single asterisk for one side of refspec.
137 */
138 *flags &= ~ REFNAME_REFSPEC_PATTERN;
139 break;
dde8a902 140 }
bc5fd6d3
MH
141 last = ch;
142 }
dde8a902 143out:
bc5fd6d3 144 if (cp == refname)
dac529e4 145 return 0; /* Component has zero length. */
1de16aec
NTND
146
147 if (refname[0] == '.') { /* Component starts with '.'. */
148 if (sanitized)
149 sanitized->buf[component_start] = '-';
150 else
151 return -1;
152 }
7108ad23 153 if (cp - refname >= LOCK_SUFFIX_LEN &&
1de16aec
NTND
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 */
160 }
161 }
bc5fd6d3
MH
162 return cp - refname;
163}
164
1de16aec
NTND
165static int check_or_sanitize_refname(const char *refname, int flags,
166 struct strbuf *sanitized)
bc5fd6d3
MH
167{
168 int component_len, component_count = 0;
169
1de16aec 170 if (!strcmp(refname, "@")) {
9ba89f48 171 /* Refname is a single character '@'. */
1de16aec
NTND
172 if (sanitized)
173 strbuf_addch(sanitized, '-');
174 else
175 return -1;
176 }
9ba89f48 177
bc5fd6d3 178 while (1) {
1de16aec
NTND
179 if (sanitized && sanitized->len)
180 strbuf_complete(sanitized, '/');
181
bc5fd6d3 182 /* We are at the start of a path component. */
1de16aec
NTND
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)
cd377f45
JK
188 return -1;
189
bc5fd6d3
MH
190 component_count++;
191 if (refname[component_len] == '\0')
192 break;
193 /* Skip to next component. */
194 refname += component_len + 1;
195 }
196
1de16aec
NTND
197 if (refname[component_len - 1] == '.') {
198 /* Refname ends with '.'. */
199 if (sanitized)
200 ; /* omit ending dot */
201 else
202 return -1;
203 }
bc5fd6d3
MH
204 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
205 return -1; /* Refname has only one component. */
206 return 0;
207}
208
1de16aec
NTND
209int check_refname_format(const char *refname, int flags)
210{
211 return check_or_sanitize_refname(refname, flags, NULL);
212}
213
214void sanitize_refname_component(const char *refname, struct strbuf *out)
215{
216 if (check_or_sanitize_refname(refname, REFNAME_ALLOW_ONELEVEL, out))
217 BUG("sanitizing refname '%s' check returned error", refname);
218}
219
4cb77009 220int refname_is_safe(const char *refname)
d0f810f0 221{
39950fef
MH
222 const char *rest;
223
224 if (skip_prefix(refname, "refs/", &rest)) {
d0f810f0
RS
225 char *buf;
226 int result;
e40f3557
MH
227 size_t restlen = strlen(rest);
228
229 /* rest must not be empty, or start or end with "/" */
230 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
231 return 0;
d0f810f0 232
d0f810f0
RS
233 /*
234 * Does the refname try to escape refs/?
235 * For example: refs/foo/../bar is safe but refs/foo/../../bar
236 * is not.
237 */
e40f3557
MH
238 buf = xmallocz(restlen);
239 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
d0f810f0
RS
240 free(buf);
241 return result;
242 }
35db25c6
MH
243
244 do {
d0f810f0
RS
245 if (!isupper(*refname) && *refname != '_')
246 return 0;
247 refname++;
35db25c6 248 } while (*refname);
d0f810f0
RS
249 return 1;
250}
251
67be7c5a
MH
252/*
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.
256 */
257int ref_resolves_to_object(const char *refname,
258 const struct object_id *oid,
259 unsigned int flags)
260{
261 if (flags & REF_ISBROKEN)
262 return 0;
98374a07 263 if (!has_object_file(oid)) {
661558f0 264 error(_("%s does not point to a valid object!"), refname);
67be7c5a
MH
265 return 0;
266 }
267 return 1;
268}
269
7d2df051
NTND
270char *refs_resolve_refdup(struct ref_store *refs,
271 const char *refname, int resolve_flags,
0f2dc722 272 struct object_id *oid, int *flags)
7d2df051
NTND
273{
274 const char *result;
275
276 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
49e61479 277 oid, flags);
7d2df051
NTND
278 return xstrdup_or_null(result);
279}
280
7bd9bcf3 281char *resolve_refdup(const char *refname, int resolve_flags,
0f2dc722 282 struct object_id *oid, int *flags)
e1e22e37 283{
23a3f0cb 284 return refs_resolve_refdup(get_main_ref_store(the_repository),
7d2df051 285 refname, resolve_flags,
0f2dc722 286 oid, flags);
cddc4258
MH
287}
288
7bd9bcf3
MH
289/* The argument to filter_refs */
290struct ref_filter {
291 const char *pattern;
9ab9b5df 292 const char *prefix;
7bd9bcf3
MH
293 each_ref_fn *fn;
294 void *cb_data;
295};
432ad41e 296
7d2df051 297int refs_read_ref_full(struct ref_store *refs, const char *refname,
34c290a6 298 int resolve_flags, struct object_id *oid, int *flags)
732134ed 299{
49e61479 300 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags))
7bd9bcf3
MH
301 return 0;
302 return -1;
732134ed
MH
303}
304
34c290a6 305int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags)
7d2df051 306{
23a3f0cb 307 return refs_read_ref_full(get_main_ref_store(the_repository), refname,
34c290a6 308 resolve_flags, oid, flags);
7d2df051
NTND
309}
310
34c290a6 311int read_ref(const char *refname, struct object_id *oid)
cddc4258 312{
34c290a6 313 return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
c774aab9
JP
314}
315
3f9f1acc 316int refs_ref_exists(struct ref_store *refs, const char *refname)
b3cd33d0
NTND
317{
318 return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING, NULL, NULL);
319}
320
7bd9bcf3 321int ref_exists(const char *refname)
bc5fd6d3 322{
b3cd33d0 323 return refs_ref_exists(get_main_ref_store(the_repository), refname);
bc5fd6d3
MH
324}
325
7bd9bcf3
MH
326static int filter_refs(const char *refname, const struct object_id *oid,
327 int flags, void *data)
432ad41e 328{
7bd9bcf3
MH
329 struct ref_filter *filter = (struct ref_filter *)data;
330
55d34269 331 if (wildmatch(filter->pattern, refname, 0))
7bd9bcf3 332 return 0;
9ab9b5df
RA
333 if (filter->prefix)
334 skip_prefix(refname, filter->prefix, &refname);
7bd9bcf3 335 return filter->fn(refname, oid, flags, filter->cb_data);
432ad41e
MH
336}
337
ac2ed0d7 338enum peel_status peel_object(const struct object_id *name, struct object_id *oid)
c774aab9 339{
45a187cc 340 struct object *o = lookup_unknown_object(the_repository, name);
c774aab9 341
7bd9bcf3 342 if (o->type == OBJ_NONE) {
0df8e965 343 int type = oid_object_info(the_repository, name, NULL);
6da43d93 344 if (type < 0 || !object_as_type(o, type, 0))
7bd9bcf3
MH
345 return PEEL_INVALID;
346 }
bc5fd6d3 347
7bd9bcf3
MH
348 if (o->type != OBJ_TAG)
349 return PEEL_NON_TAG;
e1980c9d 350
7bd9bcf3
MH
351 o = deref_tag_noverify(o);
352 if (!o)
353 return PEEL_INVALID;
354
ac2ed0d7 355 oidcpy(oid, &o->oid);
7bd9bcf3 356 return PEEL_PEELED;
e1980c9d
JH
357}
358
7bd9bcf3
MH
359struct warn_if_dangling_data {
360 FILE *fp;
361 const char *refname;
362 const struct string_list *refnames;
363 const char *msg_fmt;
364};
bc5fd6d3 365
7bd9bcf3
MH
366static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
367 int flags, void *cb_data)
368{
369 struct warn_if_dangling_data *d = cb_data;
370 const char *resolves_to;
bc5fd6d3 371
7bd9bcf3
MH
372 if (!(flags & REF_ISSYMREF))
373 return 0;
bc5fd6d3 374
744c040b 375 resolves_to = resolve_ref_unsafe(refname, 0, NULL, NULL);
7bd9bcf3
MH
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;
381 }
bc5fd6d3 382
7bd9bcf3
MH
383 fprintf(d->fp, d->msg_fmt, refname);
384 fputc('\n', d->fp);
385 return 0;
bc5fd6d3
MH
386}
387
7bd9bcf3 388void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
f348ac92 389{
7bd9bcf3
MH
390 struct warn_if_dangling_data data;
391
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);
f348ac92
MH
397}
398
7bd9bcf3 399void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
432ad41e 400{
7bd9bcf3 401 struct warn_if_dangling_data data;
432ad41e 402
7bd9bcf3
MH
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);
432ad41e
MH
408}
409
7d2df051
NTND
410int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
411{
412 return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
413}
414
7bd9bcf3 415int for_each_tag_ref(each_ref_fn fn, void *cb_data)
432ad41e 416{
23a3f0cb 417 return refs_for_each_tag_ref(get_main_ref_store(the_repository), fn, cb_data);
432ad41e
MH
418}
419
7d2df051
NTND
420int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
421{
422 return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
432ad41e
MH
423}
424
7bd9bcf3 425int for_each_branch_ref(each_ref_fn fn, void *cb_data)
432ad41e 426{
23a3f0cb 427 return refs_for_each_branch_ref(get_main_ref_store(the_repository), fn, cb_data);
432ad41e
MH
428}
429
7d2df051
NTND
430int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
431{
432 return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
202a56a9 433}
432ad41e 434
7bd9bcf3 435int for_each_remote_ref(each_ref_fn fn, void *cb_data)
e9c4c111 436{
23a3f0cb 437 return refs_for_each_remote_ref(get_main_ref_store(the_repository), fn, cb_data);
202a56a9
MH
438}
439
7bd9bcf3
MH
440int head_ref_namespaced(each_ref_fn fn, void *cb_data)
441{
442 struct strbuf buf = STRBUF_INIT;
443 int ret = 0;
444 struct object_id oid;
445 int flag;
c774aab9 446
7bd9bcf3 447 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
34c290a6 448 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, &oid, &flag))
7bd9bcf3
MH
449 ret = fn(buf.buf, &oid, flag, cb_data);
450 strbuf_release(&buf);
c774aab9 451
7bd9bcf3 452 return ret;
e9c4c111 453}
c774aab9 454
65516f58
RA
455void normalize_glob_ref(struct string_list_item *item, const char *prefix,
456 const char *pattern)
457{
458 struct strbuf normalized_pattern = STRBUF_INIT;
459
460 if (*pattern == '/')
461 BUG("pattern must not start with '/'");
462
463 if (prefix) {
464 strbuf_addstr(&normalized_pattern, prefix);
465 }
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, "/");
470
471 item->string = strbuf_detach(&normalized_pattern, NULL);
472 item->util = has_glob_specials(pattern) ? NULL : item->string;
473 strbuf_release(&normalized_pattern);
474}
475
7bd9bcf3
MH
476int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
477 const char *prefix, void *cb_data)
662428f4 478{
7bd9bcf3
MH
479 struct strbuf real_pattern = STRBUF_INIT;
480 struct ref_filter filter;
481 int ret;
d08bae7e 482
59556548 483 if (!prefix && !starts_with(pattern, "refs/"))
d08bae7e 484 strbuf_addstr(&real_pattern, "refs/");
b09fe971
IL
485 else if (prefix)
486 strbuf_addstr(&real_pattern, prefix);
d08bae7e
IL
487 strbuf_addstr(&real_pattern, pattern);
488
894a9d33 489 if (!has_glob_specials(pattern)) {
9517e6b8 490 /* Append implied '/' '*' if not present. */
00b6c178 491 strbuf_complete(&real_pattern, '/');
d08bae7e
IL
492 /* No need to check for '*', there is none. */
493 strbuf_addch(&real_pattern, '*');
494 }
495
496 filter.pattern = real_pattern.buf;
9ab9b5df 497 filter.prefix = prefix;
d08bae7e
IL
498 filter.fn = fn;
499 filter.cb_data = cb_data;
500 ret = for_each_ref(filter_refs, &filter);
501
502 strbuf_release(&real_pattern);
503 return ret;
504}
505
b09fe971
IL
506int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
507{
508 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
509}
510
4577e483 511const char *prettify_refname(const char *name)
a9c37a72 512{
3e5b36c6
SG
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;
a9c37a72
DB
518}
519
54457fe5 520static const char *ref_rev_parse_rules[] = {
79803322
SP
521 "%.*s",
522 "refs/%.*s",
523 "refs/tags/%.*s",
524 "refs/heads/%.*s",
525 "refs/remotes/%.*s",
526 "refs/remotes/%.*s/HEAD",
527 NULL
528};
529
60650a48
JH
530#define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
531
532/*
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.
536 *
537 * If abbrev_name cannot mean full_name, return 0.
538 */
54457fe5 539int refname_match(const char *abbrev_name, const char *full_name)
79803322
SP
540{
541 const char **p;
542 const int abbrev_name_len = strlen(abbrev_name);
60650a48 543 const int num_rules = NUM_REV_PARSE_RULES;
79803322 544
60650a48
JH
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;
79803322
SP
548
549 return 0;
550}
551
b4be7410
BW
552/*
553 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
554 * the results to 'prefixes'
555 */
c972bf4c 556void expand_ref_prefix(struct strvec *prefixes, const char *prefix)
b4be7410
BW
557{
558 const char **p;
559 int len = strlen(prefix);
560
561 for (p = ref_rev_parse_rules; *p; p++)
c972bf4c 562 strvec_pushf(prefixes, *p, len, prefix);
b4be7410
BW
563}
564
675704c7
JS
565static 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"
576);
577
cc0f13c5 578char *repo_default_branch_name(struct repository *r, int quiet)
8747ebb7
DGW
579{
580 const char *config_key = "init.defaultbranch";
581 const char *config_display_key = "init.defaultBranch";
582 char *ret = NULL, *full_ref;
704fed9e 583 const char *env = getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
8747ebb7 584
704fed9e
JS
585 if (env && *env)
586 ret = xstrdup(env);
587 else if (repo_config_get_string(r, config_key, &ret) < 0)
8747ebb7
DGW
588 die(_("could not retrieve `%s`"), config_display_key);
589
675704c7 590 if (!ret) {
8747ebb7 591 ret = xstrdup("master");
675704c7
JS
592 if (!quiet)
593 advise(_(default_branch_name_advice), ret);
594 }
8747ebb7
DGW
595
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);
600
601 return ret;
602}
603
cc0f13c5 604const char *git_default_branch_name(int quiet)
8747ebb7
DGW
605{
606 static char *ret;
607
608 if (!ret)
cc0f13c5 609 ret = repo_default_branch_name(the_repository, quiet);
8747ebb7
DGW
610
611 return ret;
612}
613
ff74f7f1
JH
614/*
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.
618 */
8f56e9d4 619static char *substitute_branch_name(struct repository *r,
f24c30e0
JT
620 const char **string, int *len,
621 int nonfatal_dangling_mark)
ff74f7f1
JH
622{
623 struct strbuf buf = STRBUF_INIT;
f24c30e0
JT
624 struct interpret_branch_name_options options = {
625 .nonfatal_dangling_mark = nonfatal_dangling_mark
626 };
a4f66a78 627 int ret = repo_interpret_branch_name(r, *string, *len, &buf, &options);
ff74f7f1
JH
628
629 if (ret == *len) {
630 size_t size;
631 *string = strbuf_detach(&buf, &size);
632 *len = size;
633 return (char *)*string;
634 }
635
636 return NULL;
637}
638
d8984c53 639int repo_dwim_ref(struct repository *r, const char *str, int len,
f24c30e0 640 struct object_id *oid, char **ref, int nonfatal_dangling_mark)
ff74f7f1 641{
f24c30e0
JT
642 char *last_branch = substitute_branch_name(r, &str, &len,
643 nonfatal_dangling_mark);
d8984c53 644 int refs_found = expand_ref(r, str, len, oid, ref);
41da7111
NTND
645 free(last_branch);
646 return refs_found;
647}
648
0b1dbf53
NTND
649int expand_ref(struct repository *repo, const char *str, int len,
650 struct object_id *oid, char **ref)
41da7111 651{
ff74f7f1
JH
652 const char **p, *r;
653 int refs_found = 0;
6cd4a898 654 struct strbuf fullref = STRBUF_INIT;
ff74f7f1
JH
655
656 *ref = NULL;
657 for (p = ref_rev_parse_rules; *p; p++) {
cca5fa64 658 struct object_id oid_from_ref;
659 struct object_id *this_result;
ff74f7f1
JH
660 int flag;
661
cca5fa64 662 this_result = refs_found ? &oid_from_ref : oid;
6cd4a898
JK
663 strbuf_reset(&fullref);
664 strbuf_addf(&fullref, *p, len, str);
0b1dbf53
NTND
665 r = refs_resolve_ref_unsafe(get_main_ref_store(repo),
666 fullref.buf, RESOLVE_REF_READING,
667 this_result, &flag);
ff74f7f1
JH
668 if (r) {
669 if (!refs_found++)
670 *ref = xstrdup(r);
671 if (!warn_ambiguous_refs)
672 break;
6cd4a898 673 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
661558f0 674 warning(_("ignoring dangling symref %s"), fullref.buf);
6cd4a898 675 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
661558f0 676 warning(_("ignoring broken ref %s"), fullref.buf);
55956350 677 }
ff74f7f1 678 }
6cd4a898 679 strbuf_release(&fullref);
ff74f7f1
JH
680 return refs_found;
681}
682
56700903
NTND
683int repo_dwim_log(struct repository *r, const char *str, int len,
684 struct object_id *oid, char **log)
ff74f7f1 685{
56700903 686 struct ref_store *refs = get_main_ref_store(r);
f24c30e0 687 char *last_branch = substitute_branch_name(r, &str, &len, 0);
ff74f7f1
JH
688 const char **p;
689 int logs_found = 0;
6cd4a898 690 struct strbuf path = STRBUF_INIT;
ff74f7f1
JH
691
692 *log = NULL;
693 for (p = ref_rev_parse_rules; *p; p++) {
334dc52f 694 struct object_id hash;
ff74f7f1
JH
695 const char *ref, *it;
696
6cd4a898
JK
697 strbuf_reset(&path);
698 strbuf_addf(&path, *p, len, str);
56700903
NTND
699 ref = refs_resolve_ref_unsafe(refs, path.buf,
700 RESOLVE_REF_READING,
701 &hash, NULL);
ff74f7f1
JH
702 if (!ref)
703 continue;
56700903 704 if (refs_reflog_exists(refs, path.buf))
6cd4a898 705 it = path.buf;
56700903
NTND
706 else if (strcmp(ref, path.buf) &&
707 refs_reflog_exists(refs, ref))
ff74f7f1
JH
708 it = ref;
709 else
710 continue;
711 if (!logs_found++) {
712 *log = xstrdup(it);
334dc52f 713 oidcpy(oid, &hash);
ff74f7f1 714 }
7bd9bcf3
MH
715 if (!warn_ambiguous_refs)
716 break;
c0277d15 717 }
6cd4a898 718 strbuf_release(&path);
7bd9bcf3
MH
719 free(last_branch);
720 return logs_found;
2ddb5d17
BK
721}
722
56700903
NTND
723int dwim_log(const char *str, int len, struct object_id *oid, char **log)
724{
725 return repo_dwim_log(the_repository, str, len, oid, log);
726}
727
266b1827
DT
728static int is_per_worktree_ref(const char *refname)
729{
55dd8b91
HWN
730 return starts_with(refname, "refs/worktree/") ||
731 starts_with(refname, "refs/bisect/") ||
732 starts_with(refname, "refs/rewritten/");
266b1827
DT
733}
734
735static int is_pseudoref_syntax(const char *refname)
736{
737 const char *c;
738
739 for (c = refname; *c; c++) {
740 if (!isupper(*c) && *c != '-' && *c != '_')
741 return 0;
742 }
743
744 return 1;
745}
746
3a3b9d8c
NTND
747static int is_main_pseudoref_syntax(const char *refname)
748{
749 return skip_prefix(refname, "main-worktree/", &refname) &&
750 *refname &&
751 is_pseudoref_syntax(refname);
752}
753
754static int is_other_pseudoref_syntax(const char *refname)
755{
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);
762}
763
266b1827
DT
764enum ref_type ref_type(const char *refname)
765{
766 if (is_per_worktree_ref(refname))
767 return REF_TYPE_PER_WORKTREE;
768 if (is_pseudoref_syntax(refname))
769 return REF_TYPE_PSEUDOREF;
3a3b9d8c
NTND
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;
5c79f74f 774 return REF_TYPE_NORMAL;
266b1827
DT
775}
776
4ff0f01c
MH
777long get_files_ref_lock_timeout_ms(void)
778{
779 static int configured = 0;
780
781 /* The default timeout is 100 ms: */
782 static int timeout_ms = 100;
783
784 if (!configured) {
785 git_config_get_int("core.filesreflocktimeout", &timeout_ms);
786 configured = 1;
787 }
788
789 return timeout_ms;
790}
791
c0fe4e8b
NTND
792int refs_delete_ref(struct ref_store *refs, const char *msg,
793 const char *refname,
2616a5e5 794 const struct object_id *old_oid,
c0fe4e8b 795 unsigned int flags)
41b625b0 796{
7521cc46 797 struct ref_transaction *transaction;
a4c653df 798 struct strbuf err = STRBUF_INIT;
8b5157e4 799
c0fe4e8b 800 transaction = ref_store_transaction_begin(refs, &err);
7521cc46 801 if (!transaction ||
89f3bbdd 802 ref_transaction_delete(transaction, refname, old_oid,
755b49ae 803 flags, msg, &err) ||
db7516ab 804 ref_transaction_commit(transaction, &err)) {
7521cc46
RS
805 error("%s", err.buf);
806 ref_transaction_free(transaction);
807 strbuf_release(&err);
c0277d15 808 return 1;
41b625b0 809 }
7bd9bcf3
MH
810 ref_transaction_free(transaction);
811 strbuf_release(&err);
b531394d
BC
812 return 0;
813}
41b625b0 814
c0fe4e8b 815int delete_ref(const char *msg, const char *refname,
2616a5e5 816 const struct object_id *old_oid, unsigned int flags)
c0fe4e8b 817{
23a3f0cb 818 return refs_delete_ref(get_main_ref_store(the_repository), msg, refname,
2616a5e5 819 old_oid, flags);
c0fe4e8b
NTND
820}
821
523fa69c 822static void copy_reflog_msg(struct strbuf *sb, const char *msg)
0ec29a47 823{
0ec29a47
JH
824 char c;
825 int wasspace = 1;
8b5157e4 826
0ec29a47
JH
827 while ((c = *msg++)) {
828 if (wasspace && isspace(c))
829 continue;
830 wasspace = isspace(c);
831 if (wasspace)
832 c = ' ';
80a6c207 833 strbuf_addch(sb, c);
a4c653df 834 }
80a6c207 835 strbuf_rtrim(sb);
0ec29a47 836}
8b5157e4 837
523fa69c
JH
838static char *normalize_reflog_message(const char *msg)
839{
840 struct strbuf sb = STRBUF_INIT;
841
842 if (msg && *msg)
843 copy_reflog_msg(&sb, msg);
844 return strbuf_detach(&sb, NULL);
845}
846
4cb77009 847int should_autocreate_reflog(const char *refname)
4e2bef57 848{
341fb286
CW
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:
4e2bef57 858 return 0;
341fb286 859 }
4e2bef57
DT
860}
861
e7e0f26e 862int is_branch(const char *refname)
c3b0dec5 863{
59556548 864 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
41b625b0
NP
865}
866
4207ed28
RS
867struct read_ref_at_cb {
868 const char *refname;
dddbad72 869 timestamp_t at_time;
4207ed28
RS
870 int cnt;
871 int reccnt;
8eb36d94 872 struct object_id *oid;
4207ed28
RS
873 int found_it;
874
8eb36d94 875 struct object_id ooid;
876 struct object_id noid;
4207ed28 877 int tz;
dddbad72 878 timestamp_t date;
4207ed28 879 char **msg;
dddbad72 880 timestamp_t *cutoff_time;
4207ed28
RS
881 int *cutoff_tz;
882 int *cutoff_cnt;
883};
884
95c2a718
DL
885static void set_read_ref_cutoffs(struct read_ref_at_cb *cb,
886 timestamp_t timestamp, int tz, const char *message)
887{
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;
896}
897
9461d272 898static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
dddbad72 899 const char *email, timestamp_t timestamp, int tz,
4207ed28
RS
900 const char *message, void *cb_data)
901{
902 struct read_ref_at_cb *cb = cb_data;
6436a202 903 int reached_count;
4207ed28 904
4207ed28
RS
905 cb->tz = tz;
906 cb->date = timestamp;
907
6436a202
DL
908 /*
909 * It is not possible for cb->cnt == 0 on the first iteration because
910 * that special case is handled in read_ref_at().
911 */
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) {
95c2a718 916 set_read_ref_cutoffs(cb, timestamp, tz, message);
4207ed28 917 /*
78fb4579 918 * we have not yet updated cb->[n|o]oid so they still
4207ed28
RS
919 * hold the values for the previous record.
920 */
6436a202
DL
921 if (!is_null_oid(&cb->ooid) && !oideq(&cb->ooid, noid))
922 warning(_("log for ref %s has gap after %s"),
a5481a6c 923 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
6436a202
DL
924 if (reached_count)
925 oidcpy(cb->oid, ooid);
926 else if (!is_null_oid(&cb->ooid) || cb->date == cb->at_time)
8eb36d94 927 oidcpy(cb->oid, noid);
9001dc2a 928 else if (!oideq(noid, cb->oid))
661558f0 929 warning(_("log for ref %s unexpectedly ended on %s"),
4207ed28 930 cb->refname, show_date(cb->date, cb->tz,
a5481a6c 931 DATE_MODE(RFC2822)));
4207ed28 932 cb->found_it = 1;
4207ed28 933 }
95c2a718 934 cb->reccnt++;
8eb36d94 935 oidcpy(&cb->ooid, ooid);
936 oidcpy(&cb->noid, noid);
6436a202
DL
937 return cb->found_it;
938}
939
940static 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)
943{
944 struct read_ref_at_cb *cb = cb_data;
945
946 set_read_ref_cutoffs(cb, timestamp, tz, message);
947 oidcpy(cb->oid, noid);
948 /* We just want the first entry */
949 return 1;
4207ed28
RS
950}
951
9461d272 952static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
dddbad72 953 const char *email, timestamp_t timestamp,
4207ed28
RS
954 int tz, const char *message, void *cb_data)
955{
956 struct read_ref_at_cb *cb = cb_data;
957
95c2a718 958 set_read_ref_cutoffs(cb, timestamp, tz, message);
8eb36d94 959 oidcpy(cb->oid, ooid);
960 if (is_null_oid(cb->oid))
961 oidcpy(cb->oid, noid);
4207ed28
RS
962 /* We just want the first entry */
963 return 1;
16d7cc90
JH
964}
965
7fdff474
NTND
966int read_ref_at(struct ref_store *refs, const char *refname,
967 unsigned int flags, timestamp_t at_time, int cnt,
8eb36d94 968 struct object_id *oid, char **msg,
dddbad72 969 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
d556fae2 970{
4207ed28 971 struct read_ref_at_cb cb;
d556fae2 972
4207ed28
RS
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;
8eb36d94 981 cb.oid = oid;
4207ed28 982
6436a202
DL
983 if (cb.cnt == 0) {
984 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent_newest, &cb);
985 return 0;
986 }
987
7fdff474 988 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
4207ed28 989
c41a87dd 990 if (!cb.reccnt) {
321c89bf 991 if (flags & GET_OID_QUIETLY)
c41a87dd
DA
992 exit(128);
993 else
661558f0 994 die(_("log for %s is empty"), refname);
c41a87dd 995 }
4207ed28
RS
996 if (cb.found_it)
997 return 0;
998
7fdff474 999 refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
d556fae2 1000
16d7cc90 1001 return 1;
d556fae2 1002}
2ff81662 1003
c0fe4e8b
NTND
1004struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
1005 struct strbuf *err)
caa4046c 1006{
c0fe4e8b 1007 struct ref_transaction *tr;
5a603b04
JN
1008 assert(err);
1009
ca56dadb 1010 CALLOC_ARRAY(tr, 1);
c0fe4e8b
NTND
1011 tr->ref_store = refs;
1012 return tr;
1013}
1014
1015struct ref_transaction *ref_transaction_begin(struct strbuf *err)
1016{
23a3f0cb 1017 return ref_store_transaction_begin(get_main_ref_store(the_repository), err);
caa4046c
MH
1018}
1019
026bd1d3 1020void ref_transaction_free(struct ref_transaction *transaction)
caa4046c 1021{
43a2dfde 1022 size_t i;
caa4046c 1023
1b07255c
RS
1024 if (!transaction)
1025 return;
1026
30173b88
MH
1027 switch (transaction->state) {
1028 case REF_TRANSACTION_OPEN:
1029 case REF_TRANSACTION_CLOSED:
1030 /* OK */
1031 break;
1032 case REF_TRANSACTION_PREPARED:
033abf97 1033 BUG("free called on a prepared reference transaction");
30173b88
MH
1034 break;
1035 default:
033abf97 1036 BUG("unexpected reference transaction state");
30173b88
MH
1037 break;
1038 }
1039
db7516ab
RS
1040 for (i = 0; i < transaction->nr; i++) {
1041 free(transaction->updates[i]->msg);
88615910 1042 free(transaction->updates[i]);
db7516ab 1043 }
caa4046c
MH
1044 free(transaction->updates);
1045 free(transaction);
1046}
1047
71564516
MH
1048struct ref_update *ref_transaction_add_update(
1049 struct ref_transaction *transaction,
1050 const char *refname, unsigned int flags,
89f3bbdd 1051 const struct object_id *new_oid,
1052 const struct object_id *old_oid,
71564516 1053 const char *msg)
caa4046c 1054{
96ffc06f 1055 struct ref_update *update;
71564516
MH
1056
1057 if (transaction->state != REF_TRANSACTION_OPEN)
033abf97 1058 BUG("update called for transaction that is not open");
71564516 1059
96ffc06f 1060 FLEX_ALLOC_STR(update, refname, refname);
caa4046c
MH
1061 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
1062 transaction->updates[transaction->nr++] = update;
71564516
MH
1063
1064 update->flags = flags;
1065
1066 if (flags & REF_HAVE_NEW)
89f3bbdd 1067 oidcpy(&update->new_oid, new_oid);
71564516 1068 if (flags & REF_HAVE_OLD)
89f3bbdd 1069 oidcpy(&update->old_oid, old_oid);
523fa69c 1070 update->msg = normalize_reflog_message(msg);
caa4046c
MH
1071 return update;
1072}
1073
8e34800e
RS
1074int ref_transaction_update(struct ref_transaction *transaction,
1075 const char *refname,
89f3bbdd 1076 const struct object_id *new_oid,
1077 const struct object_id *old_oid,
1d147bdf 1078 unsigned int flags, const char *msg,
8e34800e 1079 struct strbuf *err)
caa4046c 1080{
5a603b04
JN
1081 assert(err);
1082
89f3bbdd 1083 if ((new_oid && !is_null_oid(new_oid)) ?
8a679de6
MH
1084 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
1085 !refname_is_safe(refname)) {
661558f0 1086 strbuf_addf(err, _("refusing to update ref with bad name '%s'"),
d0f810f0
RS
1087 refname);
1088 return -1;
1089 }
1090
a9bbbcec
MH
1091 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
1092 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
c788c54c 1093
89f3bbdd 1094 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
71564516
MH
1095
1096 ref_transaction_add_update(transaction, refname, flags,
89f3bbdd 1097 new_oid, old_oid, msg);
8e34800e 1098 return 0;
caa4046c
MH
1099}
1100
b416af5b
RS
1101int ref_transaction_create(struct ref_transaction *transaction,
1102 const char *refname,
89f3bbdd 1103 const struct object_id *new_oid,
fec14ec3 1104 unsigned int flags, const char *msg,
b416af5b 1105 struct strbuf *err)
caa4046c 1106{
89f3bbdd 1107 if (!new_oid || is_null_oid(new_oid))
033abf97 1108 BUG("create called without valid new_oid");
89f3bbdd 1109 return ref_transaction_update(transaction, refname, new_oid,
14228447 1110 null_oid(), flags, msg, err);
caa4046c
MH
1111}
1112
8c8bdc0d
RS
1113int ref_transaction_delete(struct ref_transaction *transaction,
1114 const char *refname,
89f3bbdd 1115 const struct object_id *old_oid,
fb5a6bb6 1116 unsigned int flags, const char *msg,
8c8bdc0d 1117 struct strbuf *err)
caa4046c 1118{
89f3bbdd 1119 if (old_oid && is_null_oid(old_oid))
033abf97 1120 BUG("delete called with old_oid set to zeros");
1d147bdf 1121 return ref_transaction_update(transaction, refname,
14228447 1122 null_oid(), old_oid,
1d147bdf 1123 flags, msg, err);
caa4046c
MH
1124}
1125
16180334
MH
1126int ref_transaction_verify(struct ref_transaction *transaction,
1127 const char *refname,
89f3bbdd 1128 const struct object_id *old_oid,
16180334
MH
1129 unsigned int flags,
1130 struct strbuf *err)
1131{
89f3bbdd 1132 if (!old_oid)
033abf97 1133 BUG("verify called with old_oid set to NULL");
16180334 1134 return ref_transaction_update(transaction, refname,
89f3bbdd 1135 NULL, old_oid,
16180334
MH
1136 flags, NULL, err);
1137}
1138
c0fe4e8b 1139int refs_update_ref(struct ref_store *refs, const char *msg,
ae077771 1140 const char *refname, const struct object_id *new_oid,
1141 const struct object_id *old_oid, unsigned int flags,
c0fe4e8b 1142 enum action_on_err onerr)
4738a333 1143{
74ec19d4 1144 struct ref_transaction *t = NULL;
b4d75ac1 1145 struct strbuf err = STRBUF_INIT;
74ec19d4 1146 int ret = 0;
b4d75ac1 1147
09743417
HWN
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);
74ec19d4
DT
1155 }
1156 if (ret) {
661558f0 1157 const char *str = _("update_ref failed for ref '%s': %s");
b4d75ac1 1158
b4d75ac1
RS
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;
1168 }
1169 strbuf_release(&err);
4738a333 1170 return 1;
b4d75ac1
RS
1171 }
1172 strbuf_release(&err);
74ec19d4
DT
1173 if (t)
1174 ref_transaction_free(t);
b4d75ac1 1175 return 0;
4738a333
BK
1176}
1177
c0fe4e8b 1178int update_ref(const char *msg, const char *refname,
ae077771 1179 const struct object_id *new_oid,
1180 const struct object_id *old_oid,
c0fe4e8b
NTND
1181 unsigned int flags, enum action_on_err onerr)
1182{
23a3f0cb 1183 return refs_update_ref(get_main_ref_store(the_repository), msg, refname, new_oid,
ae077771 1184 old_oid, flags, onerr);
c0fe4e8b
NTND
1185}
1186
546edf37
NTND
1187char *refs_shorten_unambiguous_ref(struct ref_store *refs,
1188 const char *refname, int strict)
7c2b3029
JK
1189{
1190 int i;
1191 static char **scanf_fmts;
1192 static int nr_rules;
1193 char *short_name;
6cd4a898 1194 struct strbuf resolved_buf = STRBUF_INIT;
7c2b3029 1195
7c2b3029 1196 if (!nr_rules) {
4346663a
MH
1197 /*
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".
1202 */
7c2b3029 1203 size_t total_len = 0;
84d5633f 1204 size_t offset = 0;
7c2b3029
JK
1205
1206 /* the rule list is NULL terminated, count them first */
a4165851 1207 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
7902fe03
MH
1208 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1209 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
7c2b3029 1210
50492f7b 1211 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
7c2b3029 1212
84d5633f 1213 offset = 0;
7c2b3029 1214 for (i = 0; i < nr_rules; i++) {
4346663a 1215 assert(offset < total_len);
84d5633f 1216 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
bf4baf1f
JK
1217 offset += xsnprintf(scanf_fmts[i], total_len - offset,
1218 ref_rev_parse_rules[i], 2, "%s") + 1;
7c2b3029
JK
1219 }
1220 }
1221
1222 /* bail out if there are no rules */
1223 if (!nr_rules)
dfefa935 1224 return xstrdup(refname);
7c2b3029 1225
dfefa935
MH
1226 /* buffer for scanf result, at most refname must fit */
1227 short_name = xstrdup(refname);
7c2b3029
JK
1228
1229 /* skip first rule, it will always match */
1230 for (i = nr_rules - 1; i > 0 ; --i) {
1231 int j;
6e7b3309 1232 int rules_to_fail = i;
7c2b3029
JK
1233 int short_name_len;
1234
dfefa935 1235 if (1 != sscanf(refname, scanf_fmts[i], short_name))
7c2b3029
JK
1236 continue;
1237
1238 short_name_len = strlen(short_name);
1239
6e7b3309
BW
1240 /*
1241 * in strict mode, all (except the matched one) rules
1242 * must fail to resolve to a valid non-ambiguous ref
1243 */
1244 if (strict)
1245 rules_to_fail = nr_rules;
1246
7c2b3029
JK
1247 /*
1248 * check if the short name resolves to a valid ref,
1249 * but use only rules prior to the matched one
1250 */
6e7b3309 1251 for (j = 0; j < rules_to_fail; j++) {
7c2b3029 1252 const char *rule = ref_rev_parse_rules[j];
7c2b3029 1253
6e7b3309
BW
1254 /* skip matched rule */
1255 if (i == j)
1256 continue;
1257
7c2b3029
JK
1258 /*
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
1262 */
6cd4a898
JK
1263 strbuf_reset(&resolved_buf);
1264 strbuf_addf(&resolved_buf, rule,
1265 short_name_len, short_name);
546edf37 1266 if (refs_ref_exists(refs, resolved_buf.buf))
7c2b3029
JK
1267 break;
1268 }
1269
1270 /*
1271 * short name is non-ambiguous if all previous rules
1272 * haven't resolved to a valid ref
1273 */
6cd4a898
JK
1274 if (j == rules_to_fail) {
1275 strbuf_release(&resolved_buf);
7c2b3029 1276 return short_name;
6cd4a898 1277 }
7c2b3029
JK
1278 }
1279
6cd4a898 1280 strbuf_release(&resolved_buf);
7c2b3029 1281 free(short_name);
dfefa935 1282 return xstrdup(refname);
7c2b3029 1283}
daebaa78 1284
546edf37
NTND
1285char *shorten_unambiguous_ref(const char *refname, int strict)
1286{
1287 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
1288 refname, strict);
1289}
1290
daebaa78
JH
1291static struct string_list *hide_refs;
1292
1293int parse_hide_refs_config(const char *var, const char *value, const char *section)
1294{
ad8c7cda 1295 const char *key;
daebaa78 1296 if (!strcmp("transfer.hiderefs", var) ||
ad8c7cda
JK
1297 (!parse_config_key(var, section, NULL, NULL, &key) &&
1298 !strcmp(key, "hiderefs"))) {
daebaa78
JH
1299 char *ref;
1300 int len;
1301
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) {
ca56dadb 1309 CALLOC_ARRAY(hide_refs, 1);
daebaa78
JH
1310 hide_refs->strdup_strings = 1;
1311 }
1312 string_list_append(hide_refs, ref);
1313 }
1314 return 0;
1315}
1316
78a766ab 1317int ref_is_hidden(const char *refname, const char *refname_full)
daebaa78 1318{
2bc31d16 1319 int i;
daebaa78
JH
1320
1321 if (!hide_refs)
1322 return 0;
2bc31d16
JK
1323 for (i = hide_refs->nr - 1; i >= 0; i--) {
1324 const char *match = hide_refs->items[i].string;
78a766ab 1325 const char *subject;
2bc31d16 1326 int neg = 0;
7a40a95e 1327 const char *p;
2bc31d16
JK
1328
1329 if (*match == '!') {
1330 neg = 1;
1331 match++;
1332 }
1333
78a766ab
LF
1334 if (*match == '^') {
1335 subject = refname_full;
1336 match++;
1337 } else {
1338 subject = refname;
1339 }
1340
1341 /* refname can be NULL when namespaces are used. */
7a40a95e
CC
1342 if (subject &&
1343 skip_prefix(subject, match, &p) &&
1344 (!*p || *p == '/'))
2bc31d16 1345 return !neg;
daebaa78
JH
1346 }
1347 return 0;
1348}
fa5b1830 1349
0845122c
DT
1350const char *find_descendant_ref(const char *dirname,
1351 const struct string_list *extras,
1352 const struct string_list *skip)
fa5b1830 1353{
0845122c 1354 int pos;
fa5b1830 1355
0845122c
DT
1356 if (!extras)
1357 return NULL;
fa5b1830
MH
1358
1359 /*
0845122c
DT
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.
fa5b1830 1364 */
0845122c
DT
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;
fa5b1830 1368
0845122c
DT
1369 if (!starts_with(extra_refname, dirname))
1370 break;
1371
1372 if (!skip || !string_list_has_string(skip, extra_refname))
1373 return extra_refname;
fa5b1830 1374 }
0845122c
DT
1375 return NULL;
1376}
fa5b1830 1377
7d2df051
NTND
1378int refs_rename_ref_available(struct ref_store *refs,
1379 const char *old_refname,
1380 const char *new_refname)
0845122c
DT
1381{
1382 struct string_list skip = STRING_LIST_INIT_NODUP;
1383 struct strbuf err = STRBUF_INIT;
ff3a299c 1384 int ok;
fa5b1830 1385
ff3a299c 1386 string_list_insert(&skip, old_refname);
7d2df051
NTND
1387 ok = !refs_verify_refname_available(refs, new_refname,
1388 NULL, &skip, &err);
ff3a299c 1389 if (!ok)
0845122c
DT
1390 error("%s", err.buf);
1391
1392 string_list_clear(&skip, 0);
1393 strbuf_release(&err);
ff3a299c 1394 return ok;
fa5b1830 1395}
2bf68ed5 1396
62f0b399 1397int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2bf68ed5
DT
1398{
1399 struct object_id oid;
1400 int flag;
1401
62f0b399 1402 if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING,
34c290a6 1403 &oid, &flag))
2bf68ed5
DT
1404 return fn("HEAD", &oid, flag, cb_data);
1405
1406 return 0;
1407}
1408
1409int head_ref(each_ref_fn fn, void *cb_data)
1410{
23a3f0cb 1411 return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
2bf68ed5 1412}
93770590 1413
e121b9cb
MH
1414struct ref_iterator *refs_ref_iterator_begin(
1415 struct ref_store *refs,
9aab952e
JK
1416 const char *prefix, int trim,
1417 enum do_for_each_ref_flags flags)
e121b9cb
MH
1418{
1419 struct ref_iterator *iter;
1420
6d751be4 1421 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
5d1f5b8c
JK
1422 static int ref_paranoia = -1;
1423
6d751be4 1424 if (ref_paranoia < 0)
968f12fd 1425 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 1);
6d751be4
JK
1426 if (ref_paranoia) {
1427 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1428 flags |= DO_FOR_EACH_OMIT_DANGLING_SYMREFS;
1429 }
1430 }
0a0865b8 1431
e121b9cb 1432 iter = refs->be->iterator_begin(refs, prefix, flags);
c7599718
MH
1433
1434 /*
1435 * `iterator_begin()` already takes care of prefix, but we
1436 * might need to do some trimming:
1437 */
1438 if (trim)
1439 iter = prefix_ref_iterator_begin(iter, "", trim);
e121b9cb 1440
8738a8a4
MH
1441 /* Sanity check for subclasses: */
1442 if (!iter->ordered)
1443 BUG("reference iterator is not ordered");
1444
e121b9cb
MH
1445 return iter;
1446}
1447
4c4de895
MH
1448/*
1449 * Call fn for each reference in the specified submodule for which the
1450 * refname begins with prefix. If trim is non-zero, then trim that
1451 * many characters off the beginning of each refname before passing
1452 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1453 * include broken references in the iteration. If fn ever returns a
1454 * non-zero value, stop the iteration and return that value;
1455 * otherwise, return 0.
1456 */
4a6067cd
SB
1457static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1458 each_repo_ref_fn fn, int trim, int flags,
1459 void *cb_data)
1460{
1461 struct ref_iterator *iter;
1462 struct ref_store *refs = get_main_ref_store(r);
1463
1464 if (!refs)
1465 return 0;
1466
1467 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1468
1469 return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1470}
1471
1472struct do_for_each_ref_help {
1473 each_ref_fn *fn;
1474 void *cb_data;
1475};
1476
1477static int do_for_each_ref_helper(struct repository *r,
1478 const char *refname,
1479 const struct object_id *oid,
1480 int flags,
1481 void *cb_data)
1482{
1483 struct do_for_each_ref_help *hp = cb_data;
1484
1485 return hp->fn(refname, oid, flags, hp->cb_data);
1486}
1487
7d2df051 1488static int do_for_each_ref(struct ref_store *refs, const char *prefix,
9aab952e
JK
1489 each_ref_fn fn, int trim,
1490 enum do_for_each_ref_flags flags, void *cb_data)
4c4de895
MH
1491{
1492 struct ref_iterator *iter;
4a6067cd 1493 struct do_for_each_ref_help hp = { fn, cb_data };
4c4de895 1494
00eebe35
MH
1495 if (!refs)
1496 return 0;
1497
e121b9cb 1498 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
4c4de895 1499
4a6067cd
SB
1500 return do_for_each_repo_ref_iterator(the_repository, iter,
1501 do_for_each_ref_helper, &hp);
4c4de895
MH
1502}
1503
7d2df051
NTND
1504int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1505{
1506 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1507}
1508
93770590
DT
1509int for_each_ref(each_ref_fn fn, void *cb_data)
1510{
23a3f0cb 1511 return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
93770590
DT
1512}
1513
7d2df051
NTND
1514int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1515 each_ref_fn fn, void *cb_data)
1516{
1517 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
93770590
DT
1518}
1519
1520int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1521{
23a3f0cb 1522 return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
93770590
DT
1523}
1524
67985e4e 1525int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data)
93770590 1526{
23a3f0cb 1527 return do_for_each_ref(get_main_ref_store(the_repository),
67985e4e 1528 prefix, fn, 0, 0, cb_data);
93770590
DT
1529}
1530
073cf63c 1531int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
67985e4e 1532 each_ref_fn fn, void *cb_data)
03df567f 1533{
67985e4e 1534 return do_for_each_ref(refs, prefix, fn, 0, 0, cb_data);
03df567f
MH
1535}
1536
212e0f7e 1537int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
93770590 1538{
212e0f7e
SB
1539 return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1540 strlen(git_replace_ref_base),
1541 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
93770590
DT
1542}
1543
1544int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1545{
1546 struct strbuf buf = STRBUF_INIT;
1547 int ret;
1548 strbuf_addf(&buf, "%srefs/", get_git_namespace());
23a3f0cb 1549 ret = do_for_each_ref(get_main_ref_store(the_repository),
7d2df051 1550 buf.buf, fn, 0, 0, cb_data);
93770590
DT
1551 strbuf_release(&buf);
1552 return ret;
1553}
1554
7d2df051 1555int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
93770590 1556{
7d2df051 1557 return do_for_each_ref(refs, "", fn, 0,
93770590
DT
1558 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1559}
2d0663b2 1560
7d2df051
NTND
1561int for_each_rawref(each_ref_fn fn, void *cb_data)
1562{
23a3f0cb 1563 return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
7d2df051
NTND
1564}
1565
16b1985b
TB
1566static int qsort_strcmp(const void *va, const void *vb)
1567{
1568 const char *a = *(const char **)va;
1569 const char *b = *(const char **)vb;
1570
1571 return strcmp(a, b);
1572}
1573
1574static void find_longest_prefixes_1(struct string_list *out,
1575 struct strbuf *prefix,
1576 const char **patterns, size_t nr)
1577{
1578 size_t i;
1579
1580 for (i = 0; i < nr; i++) {
1581 char c = patterns[i][prefix->len];
1582 if (!c || is_glob_special(c)) {
1583 string_list_append(out, prefix->buf);
1584 return;
1585 }
1586 }
1587
1588 i = 0;
1589 while (i < nr) {
1590 size_t end;
1591
1592 /*
1593 * Set "end" to the index of the element _after_ the last one
1594 * in our group.
1595 */
1596 for (end = i + 1; end < nr; end++) {
1597 if (patterns[i][prefix->len] != patterns[end][prefix->len])
1598 break;
1599 }
1600
1601 strbuf_addch(prefix, patterns[i][prefix->len]);
1602 find_longest_prefixes_1(out, prefix, patterns + i, end - i);
1603 strbuf_setlen(prefix, prefix->len - 1);
1604
1605 i = end;
1606 }
1607}
1608
1609static void find_longest_prefixes(struct string_list *out,
1610 const char **patterns)
1611{
1612 struct strvec sorted = STRVEC_INIT;
1613 struct strbuf prefix = STRBUF_INIT;
1614
1615 strvec_pushv(&sorted, patterns);
1616 QSORT(sorted.v, sorted.nr, qsort_strcmp);
1617
1618 find_longest_prefixes_1(out, &prefix, sorted.v, sorted.nr);
1619
1620 strvec_clear(&sorted);
1621 strbuf_release(&prefix);
1622}
1623
1624int for_each_fullref_in_prefixes(const char *namespace,
1625 const char **patterns,
67985e4e 1626 each_ref_fn fn, void *cb_data)
16b1985b
TB
1627{
1628 struct string_list prefixes = STRING_LIST_INIT_DUP;
1629 struct string_list_item *prefix;
1630 struct strbuf buf = STRBUF_INIT;
1631 int ret = 0, namespace_len;
1632
1633 find_longest_prefixes(&prefixes, patterns);
1634
1635 if (namespace)
1636 strbuf_addstr(&buf, namespace);
1637 namespace_len = buf.len;
1638
1639 for_each_string_list_item(prefix, &prefixes) {
1640 strbuf_addstr(&buf, prefix->string);
67985e4e 1641 ret = for_each_fullref_in(buf.buf, fn, cb_data);
16b1985b
TB
1642 if (ret)
1643 break;
1644 strbuf_setlen(&buf, namespace_len);
1645 }
1646
1647 string_list_clear(&prefixes, 0);
1648 strbuf_release(&buf);
1649 return ret;
1650}
1651
e8115302
HWN
1652static int refs_read_special_head(struct ref_store *ref_store,
1653 const char *refname, struct object_id *oid,
1654 struct strbuf *referent, unsigned int *type)
1655{
1656 struct strbuf full_path = STRBUF_INIT;
1657 struct strbuf content = STRBUF_INIT;
1658 int result = -1;
1659 strbuf_addf(&full_path, "%s/%s", ref_store->gitdir, refname);
1660
1661 if (strbuf_read_file(&content, full_path.buf, 0) < 0)
1662 goto done;
1663
1664 result = parse_loose_ref_contents(content.buf, oid, referent, type);
1665
1666done:
1667 strbuf_release(&full_path);
1668 strbuf_release(&content);
1669 return result;
1670}
1671
470be518 1672int refs_read_raw_ref(struct ref_store *ref_store,
99afe91a 1673 const char *refname, struct object_id *oid,
470be518
MH
1674 struct strbuf *referent, unsigned int *type)
1675{
e8115302
HWN
1676 if (!strcmp(refname, "FETCH_HEAD") || !strcmp(refname, "MERGE_HEAD")) {
1677 return refs_read_special_head(ref_store, refname, oid, referent,
1678 type);
1679 }
1680
1681 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent,
1682 type);
470be518
MH
1683}
1684
2d0663b2 1685/* This function needs to return a meaningful errno on failure */
7d2df051 1686const char *refs_resolve_ref_unsafe(struct ref_store *refs,
3c0cb0cb
MH
1687 const char *refname,
1688 int resolve_flags,
49e61479 1689 struct object_id *oid, int *flags)
2d0663b2
DT
1690{
1691 static struct strbuf sb_refname = STRBUF_INIT;
54fad661 1692 struct object_id unused_oid;
2d0663b2
DT
1693 int unused_flags;
1694 int symref_count;
1695
49e61479 1696 if (!oid)
1697 oid = &unused_oid;
2d0663b2
DT
1698 if (!flags)
1699 flags = &unused_flags;
1700
1701 *flags = 0;
1702
1703 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1704 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1705 !refname_is_safe(refname)) {
1706 errno = EINVAL;
1707 return NULL;
1708 }
1709
1710 /*
1711 * dwim_ref() uses REF_ISBROKEN to distinguish between
1712 * missing refs and refs that were present but invalid,
1713 * to complain about the latter to stderr.
1714 *
1715 * We don't know whether the ref exists, so don't set
1716 * REF_ISBROKEN yet.
1717 */
1718 *flags |= REF_BAD_NAME;
1719 }
1720
1721 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1722 unsigned int read_flags = 0;
1723
470be518 1724 if (refs_read_raw_ref(refs, refname,
99afe91a 1725 oid, &sb_refname, &read_flags)) {
2d0663b2 1726 *flags |= read_flags;
a1c1d817
JK
1727
1728 /* In reading mode, refs must eventually resolve */
1729 if (resolve_flags & RESOLVE_REF_READING)
1730 return NULL;
1731
1732 /*
1733 * Otherwise a missing ref is OK. But the files backend
1734 * may show errors besides ENOENT if there are
1735 * similarly-named refs.
1736 */
1737 if (errno != ENOENT &&
1738 errno != EISDIR &&
1739 errno != ENOTDIR)
2d0663b2 1740 return NULL;
a1c1d817 1741
49e61479 1742 oidclr(oid);
2d0663b2
DT
1743 if (*flags & REF_BAD_NAME)
1744 *flags |= REF_ISBROKEN;
1745 return refname;
1746 }
1747
1748 *flags |= read_flags;
1749
1750 if (!(read_flags & REF_ISSYMREF)) {
1751 if (*flags & REF_BAD_NAME) {
49e61479 1752 oidclr(oid);
2d0663b2
DT
1753 *flags |= REF_ISBROKEN;
1754 }
1755 return refname;
1756 }
1757
1758 refname = sb_refname.buf;
1759 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
49e61479 1760 oidclr(oid);
2d0663b2
DT
1761 return refname;
1762 }
1763 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1764 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1765 !refname_is_safe(refname)) {
1766 errno = EINVAL;
1767 return NULL;
1768 }
1769
1770 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1771 }
1772 }
1773
1774 errno = ELOOP;
1775 return NULL;
1776}
00eebe35 1777
6fb5acfd
DT
1778/* backend functions */
1779int refs_init_db(struct strbuf *err)
1780{
23a3f0cb 1781 struct ref_store *refs = get_main_ref_store(the_repository);
6fb5acfd
DT
1782
1783 return refs->be->init_db(refs, err);
1784}
1785
bd40dcda 1786const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
49e61479 1787 struct object_id *oid, int *flags)
bd40dcda 1788{
23a3f0cb 1789 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
49e61479 1790 resolve_flags, oid, flags);
bd40dcda
MH
1791}
1792
a8355bb7 1793int resolve_gitlink_ref(const char *submodule, const char *refname,
a98e6101 1794 struct object_id *oid)
424dcc76 1795{
424dcc76
MH
1796 struct ref_store *refs;
1797 int flags;
1798
29babbee 1799 refs = get_submodule_ref_store(submodule);
48a8475f 1800
424dcc76
MH
1801 if (!refs)
1802 return -1;
1803
49e61479 1804 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
a98e6101 1805 is_null_oid(oid))
424dcc76
MH
1806 return -1;
1807 return 0;
1808}
1809
0c064d90 1810struct ref_store_hash_entry
7d4558c4 1811{
e2b5038d 1812 struct hashmap_entry ent;
7d4558c4
MH
1813
1814 struct ref_store *refs;
1815
0c064d90
NTND
1816 /* NUL-terminated identifier of the ref store: */
1817 char name[FLEX_ARRAY];
7d4558c4
MH
1818};
1819
7663cdc8 1820static int ref_store_hash_cmp(const void *unused_cmp_data,
939af16e
EW
1821 const struct hashmap_entry *eptr,
1822 const struct hashmap_entry *entry_or_key,
7d4558c4
MH
1823 const void *keydata)
1824{
939af16e
EW
1825 const struct ref_store_hash_entry *e1, *e2;
1826 const char *name;
1827
1828 e1 = container_of(eptr, const struct ref_store_hash_entry, ent);
1829 e2 = container_of(entry_or_key, const struct ref_store_hash_entry, ent);
1830 name = keydata ? keydata : e2->name;
7d4558c4 1831
0c064d90 1832 return strcmp(e1->name, name);
7d4558c4
MH
1833}
1834
0c064d90
NTND
1835static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1836 const char *name, struct ref_store *refs)
7d4558c4 1837{
0c064d90 1838 struct ref_store_hash_entry *entry;
7d4558c4 1839
0c064d90 1840 FLEX_ALLOC_STR(entry, name, name);
d22245a2 1841 hashmap_entry_init(&entry->ent, strhash(name));
7d4558c4
MH
1842 entry->refs = refs;
1843 return entry;
1844}
1845
7d4558c4
MH
1846/* A hashmap of ref_stores, stored by submodule name: */
1847static struct hashmap submodule_ref_stores;
00eebe35 1848
17eff96b
NTND
1849/* A hashmap of ref_stores, stored by worktree id: */
1850static struct hashmap worktree_ref_stores;
1851
c468da4e 1852/*
0c064d90
NTND
1853 * Look up a ref store by name. If that ref_store hasn't been
1854 * registered yet, return NULL.
c468da4e 1855 */
0c064d90
NTND
1856static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1857 const char *name)
00eebe35 1858{
0c064d90 1859 struct ref_store_hash_entry *entry;
f23a4651 1860 unsigned int hash;
00eebe35 1861
0c064d90 1862 if (!map->tablesize)
7d4558c4
MH
1863 /* It's initialized on demand in register_ref_store(). */
1864 return NULL;
620a66b9 1865
f23a4651
EW
1866 hash = strhash(name);
1867 entry = hashmap_get_entry_from_hash(map, hash, name,
1868 struct ref_store_hash_entry, ent);
7d4558c4 1869 return entry ? entry->refs : NULL;
00eebe35
MH
1870}
1871
c468da4e
MH
1872/*
1873 * Create, record, and return a ref_store instance for the specified
5d0bc90e 1874 * gitdir.
c468da4e 1875 */
9e7ec634
NTND
1876static struct ref_store *ref_store_init(const char *gitdir,
1877 unsigned int flags)
00eebe35
MH
1878{
1879 const char *be_name = "files";
1880 struct ref_storage_be *be = find_ref_storage_backend(be_name);
ba88add5 1881 struct ref_store *refs;
00eebe35
MH
1882
1883 if (!be)
033abf97 1884 BUG("reference backend %s is unknown", be_name);
00eebe35 1885
9e7ec634 1886 refs = be->init(gitdir, flags);
ba88add5 1887 return refs;
00eebe35
MH
1888}
1889
64a74161 1890struct ref_store *get_main_ref_store(struct repository *r)
24c8407e 1891{
02204610
JK
1892 if (r->refs_private)
1893 return r->refs_private;
24c8407e 1894
2dc417ab
JK
1895 if (!r->gitdir)
1896 BUG("attempting to get main_ref_store outside of repository");
1897
02204610 1898 r->refs_private = ref_store_init(r->gitdir, REF_STORE_ALL_CAPS);
4441f427 1899 r->refs_private = maybe_debug_wrap_ref_store(r->gitdir, r->refs_private);
02204610 1900 return r->refs_private;
378dc910
NTND
1901}
1902
1903/*
0c064d90
NTND
1904 * Associate a ref store with a name. It is a fatal error to call this
1905 * function twice for the same name.
378dc910 1906 */
0c064d90
NTND
1907static void register_ref_store_map(struct hashmap *map,
1908 const char *type,
1909 struct ref_store *refs,
1910 const char *name)
378dc910 1911{
26b455f2
EW
1912 struct ref_store_hash_entry *entry;
1913
0c064d90 1914 if (!map->tablesize)
7663cdc8 1915 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
378dc910 1916
26b455f2
EW
1917 entry = alloc_ref_store_hash_entry(name, refs);
1918 if (hashmap_put(map, &entry->ent))
033abf97 1919 BUG("%s ref_store '%s' initialized twice", type, name);
24c8407e
NTND
1920}
1921
18d0002d 1922struct ref_store *get_submodule_ref_store(const char *submodule)
00eebe35 1923{
126c9e05 1924 struct strbuf submodule_sb = STRBUF_INIT;
00eebe35 1925 struct ref_store *refs;
29babbee
NTND
1926 char *to_free = NULL;
1927 size_t len;
00eebe35 1928
82a150f2
NTND
1929 if (!submodule)
1930 return NULL;
1931
873ea90d
NTND
1932 len = strlen(submodule);
1933 while (len && is_dir_sep(submodule[len - 1]))
1934 len--;
1935 if (!len)
1936 return NULL;
00eebe35 1937
29babbee
NTND
1938 if (submodule[len])
1939 /* We need to strip off one or more trailing slashes */
1940 submodule = to_free = xmemdupz(submodule, len);
00eebe35 1941
0c064d90 1942 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
126c9e05 1943 if (refs)
2c616c17 1944 goto done;
00eebe35 1945
126c9e05 1946 strbuf_addstr(&submodule_sb, submodule);
2c616c17
NTND
1947 if (!is_nonbare_repository_dir(&submodule_sb))
1948 goto done;
00eebe35 1949
2c616c17
NTND
1950 if (submodule_to_gitdir(&submodule_sb, submodule))
1951 goto done;
00eebe35 1952
9e7ec634
NTND
1953 /* assume that add_submodule_odb() has been called */
1954 refs = ref_store_init(submodule_sb.buf,
1955 REF_STORE_READ | REF_STORE_ODB);
0c064d90
NTND
1956 register_ref_store_map(&submodule_ref_stores, "submodule",
1957 refs, submodule);
5d0bc90e 1958
2c616c17 1959done:
5d0bc90e 1960 strbuf_release(&submodule_sb);
29babbee
NTND
1961 free(to_free);
1962
00eebe35
MH
1963 return refs;
1964}
1965
17eff96b
NTND
1966struct ref_store *get_worktree_ref_store(const struct worktree *wt)
1967{
1968 struct ref_store *refs;
1969 const char *id;
1970
1971 if (wt->is_current)
23a3f0cb 1972 return get_main_ref_store(the_repository);
17eff96b
NTND
1973
1974 id = wt->id ? wt->id : "/";
1975 refs = lookup_ref_store_map(&worktree_ref_stores, id);
1976 if (refs)
1977 return refs;
1978
1979 if (wt->id)
1980 refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
1981 REF_STORE_ALL_CAPS);
1982 else
1983 refs = ref_store_init(get_git_common_dir(),
1984 REF_STORE_ALL_CAPS);
1985
1986 if (refs)
1987 register_ref_store_map(&worktree_ref_stores, "worktree",
1988 refs, id);
1989 return refs;
1990}
1991
620a66b9 1992void base_ref_store_init(struct ref_store *refs,
fbfd0a29 1993 const struct ref_storage_be *be)
00eebe35 1994{
620a66b9 1995 refs->be = be;
00eebe35 1996}
127b42a1
RS
1997
1998/* backend functions */
7d2df051 1999int refs_pack_refs(struct ref_store *refs, unsigned int flags)
8231527e 2000{
8231527e
MH
2001 return refs->be->pack_refs(refs, flags);
2002}
2003
36a31792 2004int peel_iterated_oid(const struct object_id *base, struct object_id *peeled)
7d2df051 2005{
36a31792
JK
2006 if (current_ref_iter &&
2007 (current_ref_iter->oid == base ||
2008 oideq(current_ref_iter->oid, base)))
2009 return ref_iterator_peel(current_ref_iter, peeled);
ba1c052f 2010
617480d7 2011 return peel_object(base, peeled) ? -1 : 0;
7d2df051 2012}
bd427cf2 2013
7d2df051
NTND
2014int refs_create_symref(struct ref_store *refs,
2015 const char *ref_target,
2016 const char *refs_heads_master,
2017 const char *logmsg)
2018{
523fa69c
JH
2019 char *msg;
2020 int retval;
2021
2022 msg = normalize_reflog_message(logmsg);
2023 retval = refs->be->create_symref(refs, ref_target, refs_heads_master,
2024 msg);
2025 free(msg);
2026 return retval;
bd427cf2
MH
2027}
2028
284689ba
MH
2029int create_symref(const char *ref_target, const char *refs_heads_master,
2030 const char *logmsg)
2031{
23a3f0cb 2032 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
7d2df051 2033 refs_heads_master, logmsg);
284689ba
MH
2034}
2035
2ced105c
MH
2036int ref_update_reject_duplicates(struct string_list *refnames,
2037 struct strbuf *err)
2038{
a552e50e 2039 size_t i, n = refnames->nr;
2ced105c
MH
2040
2041 assert(err);
2042
8556f8d6
MH
2043 for (i = 1; i < n; i++) {
2044 int cmp = strcmp(refnames->items[i - 1].string,
2045 refnames->items[i].string);
2046
2047 if (!cmp) {
2ced105c 2048 strbuf_addf(err,
661558f0 2049 _("multiple updates for ref '%s' not allowed"),
2ced105c
MH
2050 refnames->items[i].string);
2051 return 1;
8556f8d6 2052 } else if (cmp > 0) {
033abf97 2053 BUG("ref_update_reject_duplicates() received unsorted list");
2ced105c 2054 }
8556f8d6 2055 }
2ced105c
MH
2056 return 0;
2057}
2058
67541597
PS
2059static int run_transaction_hook(struct ref_transaction *transaction,
2060 const char *state)
2061{
2062 struct child_process proc = CHILD_PROCESS_INIT;
2063 struct strbuf buf = STRBUF_INIT;
0a0fbbe3 2064 const char *hook;
67541597
PS
2065 int ret = 0, i;
2066
0a0fbbe3 2067 hook = find_hook("reference-transaction");
67541597 2068 if (!hook)
67541597 2069 return ret;
67541597 2070
c972bf4c 2071 strvec_pushl(&proc.args, hook, state, NULL);
67541597
PS
2072 proc.in = -1;
2073 proc.stdout_to_stderr = 1;
2074 proc.trace2_hook_name = "reference-transaction";
2075
2076 ret = start_command(&proc);
2077 if (ret)
2078 return ret;
2079
2080 sigchain_push(SIGPIPE, SIG_IGN);
2081
2082 for (i = 0; i < transaction->nr; i++) {
2083 struct ref_update *update = transaction->updates[i];
2084
2085 strbuf_reset(&buf);
2086 strbuf_addf(&buf, "%s %s %s\n",
2087 oid_to_hex(&update->old_oid),
2088 oid_to_hex(&update->new_oid),
2089 update->refname);
2090
2091 if (write_in_full(proc.in, buf.buf, buf.len) < 0) {
2092 if (errno != EPIPE)
2093 ret = -1;
2094 break;
2095 }
2096 }
2097
2098 close(proc.in);
2099 sigchain_pop(SIGPIPE);
2100 strbuf_release(&buf);
2101
2102 ret |= finish_command(&proc);
2103 return ret;
2104}
2105
30173b88
MH
2106int ref_transaction_prepare(struct ref_transaction *transaction,
2107 struct strbuf *err)
127b42a1 2108{
c0fe4e8b 2109 struct ref_store *refs = transaction->ref_store;
67541597 2110 int ret;
127b42a1 2111
8d4240d3
MH
2112 switch (transaction->state) {
2113 case REF_TRANSACTION_OPEN:
2114 /* Good. */
2115 break;
30173b88 2116 case REF_TRANSACTION_PREPARED:
033abf97 2117 BUG("prepare called twice on reference transaction");
30173b88 2118 break;
8d4240d3 2119 case REF_TRANSACTION_CLOSED:
033abf97 2120 BUG("prepare called on a closed reference transaction");
8d4240d3
MH
2121 break;
2122 default:
033abf97 2123 BUG("unexpected reference transaction state");
8d4240d3
MH
2124 break;
2125 }
2126
d8f4481c
JK
2127 if (getenv(GIT_QUARANTINE_ENVIRONMENT)) {
2128 strbuf_addstr(err,
2129 _("ref updates forbidden inside quarantine environment"));
2130 return -1;
2131 }
2132
67541597
PS
2133 ret = refs->be->transaction_prepare(refs, transaction, err);
2134 if (ret)
2135 return ret;
2136
2137 ret = run_transaction_hook(transaction, "prepared");
2138 if (ret) {
2139 ref_transaction_abort(transaction, err);
2140 die(_("ref updates aborted by hook"));
2141 }
2142
2143 return 0;
30173b88
MH
2144}
2145
2146int ref_transaction_abort(struct ref_transaction *transaction,
2147 struct strbuf *err)
2148{
2149 struct ref_store *refs = transaction->ref_store;
2150 int ret = 0;
2151
2152 switch (transaction->state) {
2153 case REF_TRANSACTION_OPEN:
2154 /* No need to abort explicitly. */
2155 break;
2156 case REF_TRANSACTION_PREPARED:
2157 ret = refs->be->transaction_abort(refs, transaction, err);
2158 break;
2159 case REF_TRANSACTION_CLOSED:
033abf97 2160 BUG("abort called on a closed reference transaction");
30173b88
MH
2161 break;
2162 default:
033abf97 2163 BUG("unexpected reference transaction state");
30173b88
MH
2164 break;
2165 }
2166
67541597
PS
2167 run_transaction_hook(transaction, "aborted");
2168
30173b88
MH
2169 ref_transaction_free(transaction);
2170 return ret;
2171}
2172
2173int ref_transaction_commit(struct ref_transaction *transaction,
2174 struct strbuf *err)
2175{
2176 struct ref_store *refs = transaction->ref_store;
2177 int ret;
2178
2179 switch (transaction->state) {
2180 case REF_TRANSACTION_OPEN:
2181 /* Need to prepare first. */
2182 ret = ref_transaction_prepare(transaction, err);
2183 if (ret)
2184 return ret;
2185 break;
2186 case REF_TRANSACTION_PREPARED:
2187 /* Fall through to finish. */
2188 break;
2189 case REF_TRANSACTION_CLOSED:
033abf97 2190 BUG("commit called on a closed reference transaction");
30173b88
MH
2191 break;
2192 default:
033abf97 2193 BUG("unexpected reference transaction state");
30173b88
MH
2194 break;
2195 }
2196
67541597
PS
2197 ret = refs->be->transaction_finish(refs, transaction, err);
2198 if (!ret)
2199 run_transaction_hook(transaction, "committed");
2200 return ret;
127b42a1 2201}
62665823 2202
7d2df051
NTND
2203int refs_verify_refname_available(struct ref_store *refs,
2204 const char *refname,
b05855b5 2205 const struct string_list *extras,
7d2df051
NTND
2206 const struct string_list *skip,
2207 struct strbuf *err)
62665823 2208{
b05855b5
MH
2209 const char *slash;
2210 const char *extra_refname;
2211 struct strbuf dirname = STRBUF_INIT;
2212 struct strbuf referent = STRBUF_INIT;
2213 struct object_id oid;
2214 unsigned int type;
2215 struct ref_iterator *iter;
2216 int ok;
2217 int ret = -1;
2218
2219 /*
2220 * For the sake of comments in this function, suppose that
2221 * refname is "refs/foo/bar".
2222 */
2223
2224 assert(err);
2225
2226 strbuf_grow(&dirname, strlen(refname) + 1);
2227 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
2228 /* Expand dirname to the new prefix, not including the trailing slash: */
2229 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2230
2231 /*
2232 * We are still at a leading dir of the refname (e.g.,
2233 * "refs/foo"; if there is a reference with that name,
2234 * it is a conflict, *unless* it is in skip.
2235 */
2236 if (skip && string_list_has_string(skip, dirname.buf))
2237 continue;
2238
99afe91a 2239 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) {
661558f0 2240 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
b05855b5
MH
2241 dirname.buf, refname);
2242 goto cleanup;
2243 }
2244
2245 if (extras && string_list_has_string(extras, dirname.buf)) {
661558f0 2246 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
b05855b5
MH
2247 refname, dirname.buf);
2248 goto cleanup;
2249 }
2250 }
2251
2252 /*
2253 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2254 * There is no point in searching for a reference with that
2255 * name, because a refname isn't considered to conflict with
2256 * itself. But we still need to check for references whose
2257 * names are in the "refs/foo/bar/" namespace, because they
2258 * *do* conflict.
2259 */
2260 strbuf_addstr(&dirname, refname + dirname.len);
2261 strbuf_addch(&dirname, '/');
2262
2263 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
2264 DO_FOR_EACH_INCLUDE_BROKEN);
2265 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2266 if (skip &&
2267 string_list_has_string(skip, iter->refname))
2268 continue;
2269
661558f0 2270 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
b05855b5
MH
2271 iter->refname, refname);
2272 ref_iterator_abort(iter);
2273 goto cleanup;
2274 }
2275
2276 if (ok != ITER_DONE)
033abf97 2277 BUG("error while iterating over references");
b05855b5
MH
2278
2279 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2280 if (extra_refname)
661558f0 2281 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
b05855b5
MH
2282 refname, extra_refname);
2283 else
2284 ret = 0;
2285
2286cleanup:
2287 strbuf_release(&referent);
2288 strbuf_release(&dirname);
2289 return ret;
62665823 2290}
e3688bd6 2291
7d2df051 2292int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
e3688bd6 2293{
e3688bd6 2294 struct ref_iterator *iter;
4a6067cd 2295 struct do_for_each_ref_help hp = { fn, cb_data };
e3688bd6
DT
2296
2297 iter = refs->be->reflog_iterator_begin(refs);
2298
4a6067cd
SB
2299 return do_for_each_repo_ref_iterator(the_repository, iter,
2300 do_for_each_ref_helper, &hp);
e3688bd6
DT
2301}
2302
7d2df051 2303int for_each_reflog(each_ref_fn fn, void *cb_data)
e3688bd6 2304{
23a3f0cb 2305 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
7d2df051 2306}
e3688bd6 2307
7d2df051
NTND
2308int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2309 const char *refname,
2310 each_reflog_ent_fn fn,
2311 void *cb_data)
2312{
e3688bd6
DT
2313 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2314 fn, cb_data);
2315}
2316
7d2df051
NTND
2317int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2318 void *cb_data)
2319{
23a3f0cb 2320 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
7d2df051
NTND
2321 refname, fn, cb_data);
2322}
2323
2324int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2325 each_reflog_ent_fn fn, void *cb_data)
2326{
2327 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2328}
2329
e3688bd6
DT
2330int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2331 void *cb_data)
2332{
23a3f0cb 2333 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
7d2df051
NTND
2334 fn, cb_data);
2335}
e3688bd6 2336
7d2df051
NTND
2337int refs_reflog_exists(struct ref_store *refs, const char *refname)
2338{
2339 return refs->be->reflog_exists(refs, refname);
e3688bd6
DT
2340}
2341
2342int reflog_exists(const char *refname)
2343{
23a3f0cb 2344 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
7d2df051 2345}
e3688bd6 2346
7d2df051
NTND
2347int refs_create_reflog(struct ref_store *refs, const char *refname,
2348 int force_create, struct strbuf *err)
2349{
2350 return refs->be->create_reflog(refs, refname, force_create, err);
e3688bd6
DT
2351}
2352
2353int safe_create_reflog(const char *refname, int force_create,
2354 struct strbuf *err)
2355{
23a3f0cb 2356 return refs_create_reflog(get_main_ref_store(the_repository), refname,
7d2df051
NTND
2357 force_create, err);
2358}
e3688bd6 2359
7d2df051
NTND
2360int refs_delete_reflog(struct ref_store *refs, const char *refname)
2361{
2362 return refs->be->delete_reflog(refs, refname);
e3688bd6
DT
2363}
2364
2365int delete_reflog(const char *refname)
2366{
23a3f0cb 2367 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
7d2df051 2368}
e3688bd6 2369
7d2df051 2370int refs_reflog_expire(struct ref_store *refs,
0155f710 2371 const char *refname, const struct object_id *oid,
7d2df051
NTND
2372 unsigned int flags,
2373 reflog_expiry_prepare_fn prepare_fn,
2374 reflog_expiry_should_prune_fn should_prune_fn,
2375 reflog_expiry_cleanup_fn cleanup_fn,
2376 void *policy_cb_data)
2377{
0155f710 2378 return refs->be->reflog_expire(refs, refname, oid, flags,
7d2df051
NTND
2379 prepare_fn, should_prune_fn,
2380 cleanup_fn, policy_cb_data);
e3688bd6
DT
2381}
2382
0155f710 2383int reflog_expire(const char *refname, const struct object_id *oid,
e3688bd6
DT
2384 unsigned int flags,
2385 reflog_expiry_prepare_fn prepare_fn,
2386 reflog_expiry_should_prune_fn should_prune_fn,
2387 reflog_expiry_cleanup_fn cleanup_fn,
2388 void *policy_cb_data)
2389{
23a3f0cb 2390 return refs_reflog_expire(get_main_ref_store(the_repository),
0155f710 2391 refname, oid, flags,
7d2df051
NTND
2392 prepare_fn, should_prune_fn,
2393 cleanup_fn, policy_cb_data);
e3688bd6 2394}
fc681463
DT
2395
2396int initial_ref_transaction_commit(struct ref_transaction *transaction,
2397 struct strbuf *err)
2398{
c0fe4e8b 2399 struct ref_store *refs = transaction->ref_store;
fc681463
DT
2400
2401 return refs->be->initial_transaction_commit(refs, transaction, err);
2402}
a27dcf89 2403
523fa69c 2404int refs_delete_refs(struct ref_store *refs, const char *logmsg,
64da4199 2405 struct string_list *refnames, unsigned int flags)
a27dcf89 2406{
523fa69c
JH
2407 char *msg;
2408 int retval;
2409
2410 msg = normalize_reflog_message(logmsg);
2411 retval = refs->be->delete_refs(refs, msg, refnames, flags);
2412 free(msg);
2413 return retval;
a27dcf89 2414}
9b6b40d9 2415
64da4199
MH
2416int delete_refs(const char *msg, struct string_list *refnames,
2417 unsigned int flags)
9b6b40d9 2418{
23a3f0cb 2419 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
7d2df051 2420}
9b6b40d9 2421
7d2df051
NTND
2422int refs_rename_ref(struct ref_store *refs, const char *oldref,
2423 const char *newref, const char *logmsg)
2424{
523fa69c
JH
2425 char *msg;
2426 int retval;
2427
2428 msg = normalize_reflog_message(logmsg);
2429 retval = refs->be->rename_ref(refs, oldref, newref, msg);
2430 free(msg);
2431 return retval;
9b6b40d9 2432}
7d2df051
NTND
2433
2434int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2435{
23a3f0cb 2436 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
7d2df051 2437}
52d59cc6
SD
2438
2439int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2440 const char *newref, const char *logmsg)
2441{
523fa69c
JH
2442 char *msg;
2443 int retval;
2444
2445 msg = normalize_reflog_message(logmsg);
2446 retval = refs->be->copy_ref(refs, oldref, newref, msg);
2447 free(msg);
2448 return retval;
52d59cc6
SD
2449}
2450
2451int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2452{
23a3f0cb 2453 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
52d59cc6 2454}