Sync with maint
[git/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"
cf0adba7
JH
12#include "object.h"
13#include "tag.h"
5d0bc90e 14#include "submodule.h"
17eff96b 15#include "worktree.h"
3581d793 16
3dce444f
RS
17/*
18 * List of all available backends
19 */
20static struct ref_storage_be *refs_backends = &refs_be_files;
21
22static struct ref_storage_be *find_ref_storage_backend(const char *name)
23{
24 struct ref_storage_be *be;
25 for (be = refs_backends; be; be = be->next)
26 if (!strcmp(be->name, name))
27 return be;
28 return NULL;
29}
30
31int ref_storage_backend_exists(const char *name)
32{
33 return find_ref_storage_backend(name) != NULL;
34}
35
bc5fd6d3 36/*
dde8a902
DT
37 * How to handle various characters in refnames:
38 * 0: An acceptable character for refs
5e650228
JH
39 * 1: End-of-component
40 * 2: ., look for a preceding . to reject .. in refs
41 * 3: {, look for a preceding @ to reject @{ in refs
53a8555e 42 * 4: A bad character: ASCII control characters, and
cd377f45
JK
43 * ":", "?", "[", "\", "^", "~", SP, or TAB
44 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
dde8a902
DT
45 */
46static unsigned char refname_disposition[256] = {
5e650228
JH
47 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
48 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
cd377f45 49 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
5e650228 50 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
dde8a902 51 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5e650228
JH
52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
dde8a902
DT
55};
56
57/*
58 * Try to read one refname component from the front of refname.
59 * Return the length of the component found, or -1 if the component is
60 * not legal. It is legal if it is something reasonable to have under
61 * ".git/refs/"; We do not like it if:
bc5fd6d3
MH
62 *
63 * - any path component of it begins with ".", or
64 * - it has double dots "..", or
53a8555e 65 * - it has ASCII control characters, or
cd377f45
JK
66 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
67 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
53a8555e
JK
68 * - it ends with a "/", or
69 * - it ends with ".lock", or
70 * - it contains a "@{" portion
bc5fd6d3 71 */
cd377f45 72static int check_refname_component(const char *refname, int *flags)
bc5fd6d3
MH
73{
74 const char *cp;
75 char last = '\0';
76
77 for (cp = refname; ; cp++) {
dde8a902
DT
78 int ch = *cp & 255;
79 unsigned char disp = refname_disposition[ch];
80 switch (disp) {
5e650228 81 case 1:
dde8a902 82 goto out;
5e650228 83 case 2:
dde8a902
DT
84 if (last == '.')
85 return -1; /* Refname contains "..". */
86 break;
5e650228 87 case 3:
dde8a902
DT
88 if (last == '@')
89 return -1; /* Refname contains "@{". */
bc5fd6d3 90 break;
5e650228 91 case 4:
dde8a902 92 return -1;
cd377f45
JK
93 case 5:
94 if (!(*flags & REFNAME_REFSPEC_PATTERN))
95 return -1; /* refspec can't be a pattern */
96
97 /*
98 * Unset the pattern flag so that we only accept
99 * a single asterisk for one side of refspec.
100 */
101 *flags &= ~ REFNAME_REFSPEC_PATTERN;
102 break;
dde8a902 103 }
bc5fd6d3
MH
104 last = ch;
105 }
dde8a902 106out:
bc5fd6d3 107 if (cp == refname)
dac529e4 108 return 0; /* Component has zero length. */
f3cc52d8
JN
109 if (refname[0] == '.')
110 return -1; /* Component starts with '.'. */
7108ad23
MH
111 if (cp - refname >= LOCK_SUFFIX_LEN &&
112 !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN))
bc5fd6d3
MH
113 return -1; /* Refname ends with ".lock". */
114 return cp - refname;
115}
116
5e650228 117int check_refname_format(const char *refname, int flags)
bc5fd6d3
MH
118{
119 int component_len, component_count = 0;
120
9ba89f48
FC
121 if (!strcmp(refname, "@"))
122 /* Refname is a single character '@'. */
123 return -1;
124
bc5fd6d3
MH
125 while (1) {
126 /* We are at the start of a path component. */
cd377f45
JK
127 component_len = check_refname_component(refname, &flags);
128 if (component_len <= 0)
129 return -1;
130
bc5fd6d3
MH
131 component_count++;
132 if (refname[component_len] == '\0')
133 break;
134 /* Skip to next component. */
135 refname += component_len + 1;
136 }
137
138 if (refname[component_len - 1] == '.')
139 return -1; /* Refname ends with '.'. */
140 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
141 return -1; /* Refname has only one component. */
142 return 0;
143}
144
4cb77009 145int refname_is_safe(const char *refname)
d0f810f0 146{
39950fef
MH
147 const char *rest;
148
149 if (skip_prefix(refname, "refs/", &rest)) {
d0f810f0
RS
150 char *buf;
151 int result;
e40f3557
MH
152 size_t restlen = strlen(rest);
153
154 /* rest must not be empty, or start or end with "/" */
155 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
156 return 0;
d0f810f0 157
d0f810f0
RS
158 /*
159 * Does the refname try to escape refs/?
160 * For example: refs/foo/../bar is safe but refs/foo/../../bar
161 * is not.
162 */
e40f3557
MH
163 buf = xmallocz(restlen);
164 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
d0f810f0
RS
165 free(buf);
166 return result;
167 }
35db25c6
MH
168
169 do {
d0f810f0
RS
170 if (!isupper(*refname) && *refname != '_')
171 return 0;
172 refname++;
35db25c6 173 } while (*refname);
d0f810f0
RS
174 return 1;
175}
176
67be7c5a
MH
177/*
178 * Return true if refname, which has the specified oid and flags, can
179 * be resolved to an object in the database. If the referred-to object
180 * does not exist, emit a warning and return false.
181 */
182int ref_resolves_to_object(const char *refname,
183 const struct object_id *oid,
184 unsigned int flags)
185{
186 if (flags & REF_ISBROKEN)
187 return 0;
188 if (!has_sha1_file(oid->hash)) {
189 error("%s does not point to a valid object!", refname);
190 return 0;
191 }
192 return 1;
193}
194
7d2df051
NTND
195char *refs_resolve_refdup(struct ref_store *refs,
196 const char *refname, int resolve_flags,
0f2dc722 197 struct object_id *oid, int *flags)
7d2df051
NTND
198{
199 const char *result;
200
201 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
49e61479 202 oid, flags);
7d2df051
NTND
203 return xstrdup_or_null(result);
204}
205
7bd9bcf3 206char *resolve_refdup(const char *refname, int resolve_flags,
0f2dc722 207 struct object_id *oid, int *flags)
e1e22e37 208{
7d2df051
NTND
209 return refs_resolve_refdup(get_main_ref_store(),
210 refname, resolve_flags,
0f2dc722 211 oid, flags);
cddc4258
MH
212}
213
7bd9bcf3
MH
214/* The argument to filter_refs */
215struct ref_filter {
216 const char *pattern;
217 each_ref_fn *fn;
218 void *cb_data;
219};
432ad41e 220
7d2df051 221int refs_read_ref_full(struct ref_store *refs, const char *refname,
34c290a6 222 int resolve_flags, struct object_id *oid, int *flags)
732134ed 223{
49e61479 224 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags))
7bd9bcf3
MH
225 return 0;
226 return -1;
732134ed
MH
227}
228
34c290a6 229int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags)
7d2df051
NTND
230{
231 return refs_read_ref_full(get_main_ref_store(), refname,
34c290a6 232 resolve_flags, oid, flags);
7d2df051
NTND
233}
234
34c290a6 235int read_ref(const char *refname, struct object_id *oid)
cddc4258 236{
34c290a6 237 return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
c774aab9
JP
238}
239
7bd9bcf3 240int ref_exists(const char *refname)
bc5fd6d3 241{
744c040b 242 return !!resolve_ref_unsafe(refname, RESOLVE_REF_READING, NULL, NULL);
bc5fd6d3
MH
243}
244
7bd9bcf3
MH
245static int filter_refs(const char *refname, const struct object_id *oid,
246 int flags, void *data)
432ad41e 247{
7bd9bcf3
MH
248 struct ref_filter *filter = (struct ref_filter *)data;
249
55d34269 250 if (wildmatch(filter->pattern, refname, 0))
7bd9bcf3
MH
251 return 0;
252 return filter->fn(refname, oid, flags, filter->cb_data);
432ad41e
MH
253}
254
ac2ed0d7 255enum peel_status peel_object(const struct object_id *name, struct object_id *oid)
c774aab9 256{
ac2ed0d7 257 struct object *o = lookup_unknown_object(name->hash);
c774aab9 258
7bd9bcf3 259 if (o->type == OBJ_NONE) {
ac2ed0d7 260 int type = sha1_object_info(name->hash, NULL);
7bd9bcf3
MH
261 if (type < 0 || !object_as_type(o, type, 0))
262 return PEEL_INVALID;
263 }
bc5fd6d3 264
7bd9bcf3
MH
265 if (o->type != OBJ_TAG)
266 return PEEL_NON_TAG;
e1980c9d 267
7bd9bcf3
MH
268 o = deref_tag_noverify(o);
269 if (!o)
270 return PEEL_INVALID;
271
ac2ed0d7 272 oidcpy(oid, &o->oid);
7bd9bcf3 273 return PEEL_PEELED;
e1980c9d
JH
274}
275
7bd9bcf3
MH
276struct warn_if_dangling_data {
277 FILE *fp;
278 const char *refname;
279 const struct string_list *refnames;
280 const char *msg_fmt;
281};
bc5fd6d3 282
7bd9bcf3
MH
283static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
284 int flags, void *cb_data)
285{
286 struct warn_if_dangling_data *d = cb_data;
287 const char *resolves_to;
bc5fd6d3 288
7bd9bcf3
MH
289 if (!(flags & REF_ISSYMREF))
290 return 0;
bc5fd6d3 291
744c040b 292 resolves_to = resolve_ref_unsafe(refname, 0, NULL, NULL);
7bd9bcf3
MH
293 if (!resolves_to
294 || (d->refname
295 ? strcmp(resolves_to, d->refname)
296 : !string_list_has_string(d->refnames, resolves_to))) {
297 return 0;
298 }
bc5fd6d3 299
7bd9bcf3
MH
300 fprintf(d->fp, d->msg_fmt, refname);
301 fputc('\n', d->fp);
302 return 0;
bc5fd6d3
MH
303}
304
7bd9bcf3 305void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
f348ac92 306{
7bd9bcf3
MH
307 struct warn_if_dangling_data data;
308
309 data.fp = fp;
310 data.refname = refname;
311 data.refnames = NULL;
312 data.msg_fmt = msg_fmt;
313 for_each_rawref(warn_if_dangling_symref, &data);
f348ac92
MH
314}
315
7bd9bcf3 316void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
432ad41e 317{
7bd9bcf3 318 struct warn_if_dangling_data data;
432ad41e 319
7bd9bcf3
MH
320 data.fp = fp;
321 data.refname = NULL;
322 data.refnames = refnames;
323 data.msg_fmt = msg_fmt;
324 for_each_rawref(warn_if_dangling_symref, &data);
432ad41e
MH
325}
326
7d2df051
NTND
327int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
328{
329 return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
330}
331
7bd9bcf3 332int for_each_tag_ref(each_ref_fn fn, void *cb_data)
432ad41e 333{
7d2df051 334 return refs_for_each_tag_ref(get_main_ref_store(), fn, cb_data);
432ad41e
MH
335}
336
7d2df051
NTND
337int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
338{
339 return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
432ad41e
MH
340}
341
7bd9bcf3 342int for_each_branch_ref(each_ref_fn fn, void *cb_data)
432ad41e 343{
7d2df051 344 return refs_for_each_branch_ref(get_main_ref_store(), fn, cb_data);
432ad41e
MH
345}
346
7d2df051
NTND
347int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
348{
349 return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
202a56a9 350}
432ad41e 351
7bd9bcf3 352int for_each_remote_ref(each_ref_fn fn, void *cb_data)
e9c4c111 353{
7d2df051 354 return refs_for_each_remote_ref(get_main_ref_store(), fn, cb_data);
202a56a9
MH
355}
356
7bd9bcf3
MH
357int head_ref_namespaced(each_ref_fn fn, void *cb_data)
358{
359 struct strbuf buf = STRBUF_INIT;
360 int ret = 0;
361 struct object_id oid;
362 int flag;
c774aab9 363
7bd9bcf3 364 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
34c290a6 365 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, &oid, &flag))
7bd9bcf3
MH
366 ret = fn(buf.buf, &oid, flag, cb_data);
367 strbuf_release(&buf);
c774aab9 368
7bd9bcf3 369 return ret;
e9c4c111 370}
c774aab9 371
7bd9bcf3
MH
372int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
373 const char *prefix, void *cb_data)
662428f4 374{
7bd9bcf3
MH
375 struct strbuf real_pattern = STRBUF_INIT;
376 struct ref_filter filter;
377 int ret;
d08bae7e 378
59556548 379 if (!prefix && !starts_with(pattern, "refs/"))
d08bae7e 380 strbuf_addstr(&real_pattern, "refs/");
b09fe971
IL
381 else if (prefix)
382 strbuf_addstr(&real_pattern, prefix);
d08bae7e
IL
383 strbuf_addstr(&real_pattern, pattern);
384
894a9d33 385 if (!has_glob_specials(pattern)) {
9517e6b8 386 /* Append implied '/' '*' if not present. */
00b6c178 387 strbuf_complete(&real_pattern, '/');
d08bae7e
IL
388 /* No need to check for '*', there is none. */
389 strbuf_addch(&real_pattern, '*');
390 }
391
392 filter.pattern = real_pattern.buf;
393 filter.fn = fn;
394 filter.cb_data = cb_data;
395 ret = for_each_ref(filter_refs, &filter);
396
397 strbuf_release(&real_pattern);
398 return ret;
399}
400
b09fe971
IL
401int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
402{
403 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
404}
405
4577e483 406const char *prettify_refname(const char *name)
a9c37a72 407{
3e5b36c6
SG
408 if (skip_prefix(name, "refs/heads/", &name) ||
409 skip_prefix(name, "refs/tags/", &name) ||
410 skip_prefix(name, "refs/remotes/", &name))
411 ; /* nothing */
412 return name;
a9c37a72
DB
413}
414
54457fe5 415static const char *ref_rev_parse_rules[] = {
79803322
SP
416 "%.*s",
417 "refs/%.*s",
418 "refs/tags/%.*s",
419 "refs/heads/%.*s",
420 "refs/remotes/%.*s",
421 "refs/remotes/%.*s/HEAD",
422 NULL
423};
424
54457fe5 425int refname_match(const char *abbrev_name, const char *full_name)
79803322
SP
426{
427 const char **p;
428 const int abbrev_name_len = strlen(abbrev_name);
429
54457fe5 430 for (p = ref_rev_parse_rules; *p; p++) {
79803322
SP
431 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
432 return 1;
433 }
434 }
435
436 return 0;
437}
438
ff74f7f1
JH
439/*
440 * *string and *len will only be substituted, and *string returned (for
441 * later free()ing) if the string passed in is a magic short-hand form
442 * to name a branch.
443 */
444static char *substitute_branch_name(const char **string, int *len)
445{
446 struct strbuf buf = STRBUF_INIT;
0e9f62da 447 int ret = interpret_branch_name(*string, *len, &buf, 0);
ff74f7f1
JH
448
449 if (ret == *len) {
450 size_t size;
451 *string = strbuf_detach(&buf, &size);
452 *len = size;
453 return (char *)*string;
454 }
455
456 return NULL;
457}
458
cca5fa64 459int dwim_ref(const char *str, int len, struct object_id *oid, char **ref)
ff74f7f1
JH
460{
461 char *last_branch = substitute_branch_name(&str, &len);
cca5fa64 462 int refs_found = expand_ref(str, len, oid, ref);
41da7111
NTND
463 free(last_branch);
464 return refs_found;
465}
466
cca5fa64 467int expand_ref(const char *str, int len, struct object_id *oid, char **ref)
41da7111 468{
ff74f7f1
JH
469 const char **p, *r;
470 int refs_found = 0;
6cd4a898 471 struct strbuf fullref = STRBUF_INIT;
ff74f7f1
JH
472
473 *ref = NULL;
474 for (p = ref_rev_parse_rules; *p; p++) {
cca5fa64 475 struct object_id oid_from_ref;
476 struct object_id *this_result;
ff74f7f1
JH
477 int flag;
478
cca5fa64 479 this_result = refs_found ? &oid_from_ref : oid;
6cd4a898
JK
480 strbuf_reset(&fullref);
481 strbuf_addf(&fullref, *p, len, str);
482 r = resolve_ref_unsafe(fullref.buf, RESOLVE_REF_READING,
49e61479 483 this_result, &flag);
ff74f7f1
JH
484 if (r) {
485 if (!refs_found++)
486 *ref = xstrdup(r);
487 if (!warn_ambiguous_refs)
488 break;
6cd4a898
JK
489 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
490 warning("ignoring dangling symref %s.", fullref.buf);
491 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
492 warning("ignoring broken ref %s.", fullref.buf);
55956350 493 }
ff74f7f1 494 }
6cd4a898 495 strbuf_release(&fullref);
ff74f7f1
JH
496 return refs_found;
497}
498
334dc52f 499int dwim_log(const char *str, int len, struct object_id *oid, char **log)
ff74f7f1
JH
500{
501 char *last_branch = substitute_branch_name(&str, &len);
502 const char **p;
503 int logs_found = 0;
6cd4a898 504 struct strbuf path = STRBUF_INIT;
ff74f7f1
JH
505
506 *log = NULL;
507 for (p = ref_rev_parse_rules; *p; p++) {
334dc52f 508 struct object_id hash;
ff74f7f1
JH
509 const char *ref, *it;
510
6cd4a898
JK
511 strbuf_reset(&path);
512 strbuf_addf(&path, *p, len, str);
513 ref = resolve_ref_unsafe(path.buf, RESOLVE_REF_READING,
49e61479 514 &hash, NULL);
ff74f7f1
JH
515 if (!ref)
516 continue;
6cd4a898
JK
517 if (reflog_exists(path.buf))
518 it = path.buf;
519 else if (strcmp(ref, path.buf) && reflog_exists(ref))
ff74f7f1
JH
520 it = ref;
521 else
522 continue;
523 if (!logs_found++) {
524 *log = xstrdup(it);
334dc52f 525 oidcpy(oid, &hash);
ff74f7f1 526 }
7bd9bcf3
MH
527 if (!warn_ambiguous_refs)
528 break;
c0277d15 529 }
6cd4a898 530 strbuf_release(&path);
7bd9bcf3
MH
531 free(last_branch);
532 return logs_found;
2ddb5d17
BK
533}
534
266b1827
DT
535static int is_per_worktree_ref(const char *refname)
536{
ce414b33
DT
537 return !strcmp(refname, "HEAD") ||
538 starts_with(refname, "refs/bisect/");
266b1827
DT
539}
540
541static int is_pseudoref_syntax(const char *refname)
542{
543 const char *c;
544
545 for (c = refname; *c; c++) {
546 if (!isupper(*c) && *c != '-' && *c != '_')
547 return 0;
548 }
549
550 return 1;
551}
552
553enum ref_type ref_type(const char *refname)
554{
555 if (is_per_worktree_ref(refname))
556 return REF_TYPE_PER_WORKTREE;
557 if (is_pseudoref_syntax(refname))
558 return REF_TYPE_PSEUDOREF;
559 return REF_TYPE_NORMAL;
560}
561
4ff0f01c
MH
562long get_files_ref_lock_timeout_ms(void)
563{
564 static int configured = 0;
565
566 /* The default timeout is 100 ms: */
567 static int timeout_ms = 100;
568
569 if (!configured) {
570 git_config_get_int("core.filesreflocktimeout", &timeout_ms);
571 configured = 1;
572 }
573
574 return timeout_ms;
575}
576
ae077771 577static int write_pseudoref(const char *pseudoref, const struct object_id *oid,
578 const struct object_id *old_oid, struct strbuf *err)
74ec19d4
DT
579{
580 const char *filename;
581 int fd;
582 static struct lock_file lock;
583 struct strbuf buf = STRBUF_INIT;
584 int ret = -1;
585
6ee18216 586 if (!oid)
587 return 0;
588
ae077771 589 strbuf_addf(&buf, "%s\n", oid_to_hex(oid));
74ec19d4
DT
590
591 filename = git_path("%s", pseudoref);
4ff0f01c
MH
592 fd = hold_lock_file_for_update_timeout(&lock, filename,
593 LOCK_DIE_ON_ERROR,
594 get_files_ref_lock_timeout_ms());
74ec19d4 595 if (fd < 0) {
0568c8e9 596 strbuf_addf(err, "could not open '%s' for writing: %s",
74ec19d4 597 filename, strerror(errno));
aeb014f6 598 goto done;
74ec19d4
DT
599 }
600
ae077771 601 if (old_oid) {
602 struct object_id actual_old_oid;
2c3aed13 603
34c290a6 604 if (read_ref(pseudoref, &actual_old_oid))
2c3aed13 605 die("could not read ref '%s'", pseudoref);
ae077771 606 if (oidcmp(&actual_old_oid, old_oid)) {
0568c8e9 607 strbuf_addf(err, "unexpected sha1 when writing '%s'", pseudoref);
74ec19d4
DT
608 rollback_lock_file(&lock);
609 goto done;
610 }
611 }
612
06f46f23 613 if (write_in_full(fd, buf.buf, buf.len) < 0) {
0568c8e9 614 strbuf_addf(err, "could not write to '%s'", filename);
74ec19d4
DT
615 rollback_lock_file(&lock);
616 goto done;
617 }
618
619 commit_lock_file(&lock);
620 ret = 0;
621done:
622 strbuf_release(&buf);
623 return ret;
624}
625
2616a5e5 626static int delete_pseudoref(const char *pseudoref, const struct object_id *old_oid)
74ec19d4
DT
627{
628 static struct lock_file lock;
629 const char *filename;
630
631 filename = git_path("%s", pseudoref);
632
2616a5e5 633 if (old_oid && !is_null_oid(old_oid)) {
74ec19d4 634 int fd;
2616a5e5 635 struct object_id actual_old_oid;
74ec19d4 636
4ff0f01c
MH
637 fd = hold_lock_file_for_update_timeout(
638 &lock, filename, LOCK_DIE_ON_ERROR,
639 get_files_ref_lock_timeout_ms());
74ec19d4
DT
640 if (fd < 0)
641 die_errno(_("Could not open '%s' for writing"), filename);
34c290a6 642 if (read_ref(pseudoref, &actual_old_oid))
2c3aed13 643 die("could not read ref '%s'", pseudoref);
2616a5e5 644 if (oidcmp(&actual_old_oid, old_oid)) {
74ec19d4
DT
645 warning("Unexpected sha1 when deleting %s", pseudoref);
646 rollback_lock_file(&lock);
647 return -1;
a4c653df 648 }
74ec19d4
DT
649
650 unlink(filename);
651 rollback_lock_file(&lock);
652 } else {
653 unlink(filename);
4bd18c43 654 }
a4c653df 655
4bd18c43 656 return 0;
95fc7512 657}
d556fae2 658
c0fe4e8b
NTND
659int refs_delete_ref(struct ref_store *refs, const char *msg,
660 const char *refname,
2616a5e5 661 const struct object_id *old_oid,
c0fe4e8b 662 unsigned int flags)
41b625b0 663{
7521cc46 664 struct ref_transaction *transaction;
a4c653df 665 struct strbuf err = STRBUF_INIT;
8b5157e4 666
c0fe4e8b
NTND
667 if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
668 assert(refs == get_main_ref_store());
2616a5e5 669 return delete_pseudoref(refname, old_oid);
c0fe4e8b 670 }
d48744d1 671
c0fe4e8b 672 transaction = ref_store_transaction_begin(refs, &err);
7521cc46 673 if (!transaction ||
89f3bbdd 674 ref_transaction_delete(transaction, refname, old_oid,
755b49ae 675 flags, msg, &err) ||
db7516ab 676 ref_transaction_commit(transaction, &err)) {
7521cc46
RS
677 error("%s", err.buf);
678 ref_transaction_free(transaction);
679 strbuf_release(&err);
c0277d15 680 return 1;
41b625b0 681 }
7bd9bcf3
MH
682 ref_transaction_free(transaction);
683 strbuf_release(&err);
b531394d
BC
684 return 0;
685}
41b625b0 686
c0fe4e8b 687int delete_ref(const char *msg, const char *refname,
2616a5e5 688 const struct object_id *old_oid, unsigned int flags)
c0fe4e8b
NTND
689{
690 return refs_delete_ref(get_main_ref_store(), msg, refname,
2616a5e5 691 old_oid, flags);
c0fe4e8b
NTND
692}
693
4cb77009 694int copy_reflog_msg(char *buf, const char *msg)
0ec29a47
JH
695{
696 char *cp = buf;
697 char c;
698 int wasspace = 1;
8b5157e4 699
0ec29a47
JH
700 *cp++ = '\t';
701 while ((c = *msg++)) {
702 if (wasspace && isspace(c))
703 continue;
704 wasspace = isspace(c);
705 if (wasspace)
706 c = ' ';
707 *cp++ = c;
a4c653df 708 }
0ec29a47
JH
709 while (buf < cp && isspace(cp[-1]))
710 cp--;
711 *cp++ = '\n';
712 return cp - buf;
713}
8b5157e4 714
4cb77009 715int should_autocreate_reflog(const char *refname)
4e2bef57 716{
341fb286
CW
717 switch (log_all_ref_updates) {
718 case LOG_REFS_ALWAYS:
719 return 1;
720 case LOG_REFS_NORMAL:
721 return starts_with(refname, "refs/heads/") ||
722 starts_with(refname, "refs/remotes/") ||
723 starts_with(refname, "refs/notes/") ||
724 !strcmp(refname, "HEAD");
725 default:
4e2bef57 726 return 0;
341fb286 727 }
4e2bef57
DT
728}
729
e7e0f26e 730int is_branch(const char *refname)
c3b0dec5 731{
59556548 732 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
41b625b0
NP
733}
734
4207ed28
RS
735struct read_ref_at_cb {
736 const char *refname;
dddbad72 737 timestamp_t at_time;
4207ed28
RS
738 int cnt;
739 int reccnt;
8eb36d94 740 struct object_id *oid;
4207ed28
RS
741 int found_it;
742
8eb36d94 743 struct object_id ooid;
744 struct object_id noid;
4207ed28 745 int tz;
dddbad72 746 timestamp_t date;
4207ed28 747 char **msg;
dddbad72 748 timestamp_t *cutoff_time;
4207ed28
RS
749 int *cutoff_tz;
750 int *cutoff_cnt;
751};
752
9461d272 753static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
dddbad72 754 const char *email, timestamp_t timestamp, int tz,
4207ed28
RS
755 const char *message, void *cb_data)
756{
757 struct read_ref_at_cb *cb = cb_data;
758
759 cb->reccnt++;
760 cb->tz = tz;
761 cb->date = timestamp;
762
763 if (timestamp <= cb->at_time || cb->cnt == 0) {
764 if (cb->msg)
765 *cb->msg = xstrdup(message);
766 if (cb->cutoff_time)
767 *cb->cutoff_time = timestamp;
768 if (cb->cutoff_tz)
769 *cb->cutoff_tz = tz;
770 if (cb->cutoff_cnt)
771 *cb->cutoff_cnt = cb->reccnt - 1;
772 /*
78fb4579 773 * we have not yet updated cb->[n|o]oid so they still
4207ed28
RS
774 * hold the values for the previous record.
775 */
8eb36d94 776 if (!is_null_oid(&cb->ooid)) {
777 oidcpy(cb->oid, noid);
778 if (oidcmp(&cb->ooid, noid))
4207ed28 779 warning("Log for ref %s has gap after %s.",
a5481a6c 780 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
4207ed28
RS
781 }
782 else if (cb->date == cb->at_time)
8eb36d94 783 oidcpy(cb->oid, noid);
784 else if (oidcmp(noid, cb->oid))
4207ed28
RS
785 warning("Log for ref %s unexpectedly ended on %s.",
786 cb->refname, show_date(cb->date, cb->tz,
a5481a6c 787 DATE_MODE(RFC2822)));
8eb36d94 788 oidcpy(&cb->ooid, ooid);
789 oidcpy(&cb->noid, noid);
4207ed28
RS
790 cb->found_it = 1;
791 return 1;
792 }
8eb36d94 793 oidcpy(&cb->ooid, ooid);
794 oidcpy(&cb->noid, noid);
4207ed28
RS
795 if (cb->cnt > 0)
796 cb->cnt--;
797 return 0;
798}
799
9461d272 800static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
dddbad72 801 const char *email, timestamp_t timestamp,
4207ed28
RS
802 int tz, const char *message, void *cb_data)
803{
804 struct read_ref_at_cb *cb = cb_data;
805
806 if (cb->msg)
807 *cb->msg = xstrdup(message);
808 if (cb->cutoff_time)
809 *cb->cutoff_time = timestamp;
810 if (cb->cutoff_tz)
811 *cb->cutoff_tz = tz;
812 if (cb->cutoff_cnt)
813 *cb->cutoff_cnt = cb->reccnt;
8eb36d94 814 oidcpy(cb->oid, ooid);
815 if (is_null_oid(cb->oid))
816 oidcpy(cb->oid, noid);
4207ed28
RS
817 /* We just want the first entry */
818 return 1;
16d7cc90
JH
819}
820
dddbad72 821int read_ref_at(const char *refname, unsigned int flags, timestamp_t at_time, int cnt,
8eb36d94 822 struct object_id *oid, char **msg,
dddbad72 823 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
d556fae2 824{
4207ed28 825 struct read_ref_at_cb cb;
d556fae2 826
4207ed28
RS
827 memset(&cb, 0, sizeof(cb));
828 cb.refname = refname;
829 cb.at_time = at_time;
830 cb.cnt = cnt;
831 cb.msg = msg;
832 cb.cutoff_time = cutoff_time;
833 cb.cutoff_tz = cutoff_tz;
834 cb.cutoff_cnt = cutoff_cnt;
8eb36d94 835 cb.oid = oid;
4207ed28
RS
836
837 for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);
838
c41a87dd 839 if (!cb.reccnt) {
321c89bf 840 if (flags & GET_OID_QUIETLY)
c41a87dd
DA
841 exit(128);
842 else
843 die("Log for %s is empty.", refname);
844 }
4207ed28
RS
845 if (cb.found_it)
846 return 0;
847
848 for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);
d556fae2 849
16d7cc90 850 return 1;
d556fae2 851}
2ff81662 852
c0fe4e8b
NTND
853struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
854 struct strbuf *err)
caa4046c 855{
c0fe4e8b 856 struct ref_transaction *tr;
5a603b04
JN
857 assert(err);
858
c0fe4e8b
NTND
859 tr = xcalloc(1, sizeof(struct ref_transaction));
860 tr->ref_store = refs;
861 return tr;
862}
863
864struct ref_transaction *ref_transaction_begin(struct strbuf *err)
865{
866 return ref_store_transaction_begin(get_main_ref_store(), err);
caa4046c
MH
867}
868
026bd1d3 869void ref_transaction_free(struct ref_transaction *transaction)
caa4046c 870{
43a2dfde 871 size_t i;
caa4046c 872
1b07255c
RS
873 if (!transaction)
874 return;
875
30173b88
MH
876 switch (transaction->state) {
877 case REF_TRANSACTION_OPEN:
878 case REF_TRANSACTION_CLOSED:
879 /* OK */
880 break;
881 case REF_TRANSACTION_PREPARED:
882 die("BUG: free called on a prepared reference transaction");
883 break;
884 default:
885 die("BUG: unexpected reference transaction state");
886 break;
887 }
888
db7516ab
RS
889 for (i = 0; i < transaction->nr; i++) {
890 free(transaction->updates[i]->msg);
88615910 891 free(transaction->updates[i]);
db7516ab 892 }
caa4046c
MH
893 free(transaction->updates);
894 free(transaction);
895}
896
71564516
MH
897struct ref_update *ref_transaction_add_update(
898 struct ref_transaction *transaction,
899 const char *refname, unsigned int flags,
89f3bbdd 900 const struct object_id *new_oid,
901 const struct object_id *old_oid,
71564516 902 const char *msg)
caa4046c 903{
96ffc06f 904 struct ref_update *update;
71564516
MH
905
906 if (transaction->state != REF_TRANSACTION_OPEN)
907 die("BUG: update called for transaction that is not open");
908
96ffc06f 909 FLEX_ALLOC_STR(update, refname, refname);
caa4046c
MH
910 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
911 transaction->updates[transaction->nr++] = update;
71564516
MH
912
913 update->flags = flags;
914
915 if (flags & REF_HAVE_NEW)
89f3bbdd 916 oidcpy(&update->new_oid, new_oid);
71564516 917 if (flags & REF_HAVE_OLD)
89f3bbdd 918 oidcpy(&update->old_oid, old_oid);
13092a91 919 update->msg = xstrdup_or_null(msg);
caa4046c
MH
920 return update;
921}
922
8e34800e
RS
923int ref_transaction_update(struct ref_transaction *transaction,
924 const char *refname,
89f3bbdd 925 const struct object_id *new_oid,
926 const struct object_id *old_oid,
1d147bdf 927 unsigned int flags, const char *msg,
8e34800e 928 struct strbuf *err)
caa4046c 929{
5a603b04
JN
930 assert(err);
931
89f3bbdd 932 if ((new_oid && !is_null_oid(new_oid)) ?
8a679de6
MH
933 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
934 !refname_is_safe(refname)) {
0568c8e9 935 strbuf_addf(err, "refusing to update ref with bad name '%s'",
d0f810f0
RS
936 refname);
937 return -1;
938 }
939
a9bbbcec
MH
940 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
941 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
c788c54c 942
89f3bbdd 943 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
71564516
MH
944
945 ref_transaction_add_update(transaction, refname, flags,
89f3bbdd 946 new_oid, old_oid, msg);
8e34800e 947 return 0;
caa4046c
MH
948}
949
b416af5b
RS
950int ref_transaction_create(struct ref_transaction *transaction,
951 const char *refname,
89f3bbdd 952 const struct object_id *new_oid,
fec14ec3 953 unsigned int flags, const char *msg,
b416af5b 954 struct strbuf *err)
caa4046c 955{
89f3bbdd 956 if (!new_oid || is_null_oid(new_oid))
957 die("BUG: create called without valid new_oid");
958 return ref_transaction_update(transaction, refname, new_oid,
959 &null_oid, flags, msg, err);
caa4046c
MH
960}
961
8c8bdc0d
RS
962int ref_transaction_delete(struct ref_transaction *transaction,
963 const char *refname,
89f3bbdd 964 const struct object_id *old_oid,
fb5a6bb6 965 unsigned int flags, const char *msg,
8c8bdc0d 966 struct strbuf *err)
caa4046c 967{
89f3bbdd 968 if (old_oid && is_null_oid(old_oid))
969 die("BUG: delete called with old_oid set to zeros");
1d147bdf 970 return ref_transaction_update(transaction, refname,
89f3bbdd 971 &null_oid, old_oid,
1d147bdf 972 flags, msg, err);
caa4046c
MH
973}
974
16180334
MH
975int ref_transaction_verify(struct ref_transaction *transaction,
976 const char *refname,
89f3bbdd 977 const struct object_id *old_oid,
16180334
MH
978 unsigned int flags,
979 struct strbuf *err)
980{
89f3bbdd 981 if (!old_oid)
982 die("BUG: verify called with old_oid set to NULL");
16180334 983 return ref_transaction_update(transaction, refname,
89f3bbdd 984 NULL, old_oid,
16180334
MH
985 flags, NULL, err);
986}
987
c0fe4e8b 988int refs_update_ref(struct ref_store *refs, const char *msg,
ae077771 989 const char *refname, const struct object_id *new_oid,
990 const struct object_id *old_oid, unsigned int flags,
c0fe4e8b 991 enum action_on_err onerr)
4738a333 992{
74ec19d4 993 struct ref_transaction *t = NULL;
b4d75ac1 994 struct strbuf err = STRBUF_INIT;
74ec19d4 995 int ret = 0;
b4d75ac1 996
74ec19d4 997 if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
c0fe4e8b 998 assert(refs == get_main_ref_store());
ae077771 999 ret = write_pseudoref(refname, new_oid, old_oid, &err);
74ec19d4 1000 } else {
c0fe4e8b 1001 t = ref_store_transaction_begin(refs, &err);
74ec19d4 1002 if (!t ||
89f3bbdd 1003 ref_transaction_update(t, refname, new_oid, old_oid,
74ec19d4
DT
1004 flags, msg, &err) ||
1005 ref_transaction_commit(t, &err)) {
1006 ret = 1;
1007 ref_transaction_free(t);
1008 }
1009 }
1010 if (ret) {
b4d75ac1
RS
1011 const char *str = "update_ref failed for ref '%s': %s";
1012
b4d75ac1
RS
1013 switch (onerr) {
1014 case UPDATE_REFS_MSG_ON_ERR:
1015 error(str, refname, err.buf);
1016 break;
1017 case UPDATE_REFS_DIE_ON_ERR:
1018 die(str, refname, err.buf);
1019 break;
1020 case UPDATE_REFS_QUIET_ON_ERR:
1021 break;
1022 }
1023 strbuf_release(&err);
4738a333 1024 return 1;
b4d75ac1
RS
1025 }
1026 strbuf_release(&err);
74ec19d4
DT
1027 if (t)
1028 ref_transaction_free(t);
b4d75ac1 1029 return 0;
4738a333
BK
1030}
1031
c0fe4e8b 1032int update_ref(const char *msg, const char *refname,
ae077771 1033 const struct object_id *new_oid,
1034 const struct object_id *old_oid,
c0fe4e8b
NTND
1035 unsigned int flags, enum action_on_err onerr)
1036{
ae077771 1037 return refs_update_ref(get_main_ref_store(), msg, refname, new_oid,
1038 old_oid, flags, onerr);
c0fe4e8b
NTND
1039}
1040
dfefa935 1041char *shorten_unambiguous_ref(const char *refname, int strict)
7c2b3029
JK
1042{
1043 int i;
1044 static char **scanf_fmts;
1045 static int nr_rules;
1046 char *short_name;
6cd4a898 1047 struct strbuf resolved_buf = STRBUF_INIT;
7c2b3029 1048
7c2b3029 1049 if (!nr_rules) {
4346663a
MH
1050 /*
1051 * Pre-generate scanf formats from ref_rev_parse_rules[].
1052 * Generate a format suitable for scanf from a
1053 * ref_rev_parse_rules rule by interpolating "%s" at the
1054 * location of the "%.*s".
1055 */
7c2b3029 1056 size_t total_len = 0;
84d5633f 1057 size_t offset = 0;
7c2b3029
JK
1058
1059 /* the rule list is NULL terminated, count them first */
a4165851 1060 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
7902fe03
MH
1061 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1062 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
7c2b3029 1063
50492f7b 1064 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
7c2b3029 1065
84d5633f 1066 offset = 0;
7c2b3029 1067 for (i = 0; i < nr_rules; i++) {
4346663a 1068 assert(offset < total_len);
84d5633f 1069 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
4346663a
MH
1070 offset += snprintf(scanf_fmts[i], total_len - offset,
1071 ref_rev_parse_rules[i], 2, "%s") + 1;
7c2b3029
JK
1072 }
1073 }
1074
1075 /* bail out if there are no rules */
1076 if (!nr_rules)
dfefa935 1077 return xstrdup(refname);
7c2b3029 1078
dfefa935
MH
1079 /* buffer for scanf result, at most refname must fit */
1080 short_name = xstrdup(refname);
7c2b3029
JK
1081
1082 /* skip first rule, it will always match */
1083 for (i = nr_rules - 1; i > 0 ; --i) {
1084 int j;
6e7b3309 1085 int rules_to_fail = i;
7c2b3029
JK
1086 int short_name_len;
1087
dfefa935 1088 if (1 != sscanf(refname, scanf_fmts[i], short_name))
7c2b3029
JK
1089 continue;
1090
1091 short_name_len = strlen(short_name);
1092
6e7b3309
BW
1093 /*
1094 * in strict mode, all (except the matched one) rules
1095 * must fail to resolve to a valid non-ambiguous ref
1096 */
1097 if (strict)
1098 rules_to_fail = nr_rules;
1099
7c2b3029
JK
1100 /*
1101 * check if the short name resolves to a valid ref,
1102 * but use only rules prior to the matched one
1103 */
6e7b3309 1104 for (j = 0; j < rules_to_fail; j++) {
7c2b3029 1105 const char *rule = ref_rev_parse_rules[j];
7c2b3029 1106
6e7b3309
BW
1107 /* skip matched rule */
1108 if (i == j)
1109 continue;
1110
7c2b3029
JK
1111 /*
1112 * the short name is ambiguous, if it resolves
1113 * (with this previous rule) to a valid ref
1114 * read_ref() returns 0 on success
1115 */
6cd4a898
JK
1116 strbuf_reset(&resolved_buf);
1117 strbuf_addf(&resolved_buf, rule,
1118 short_name_len, short_name);
1119 if (ref_exists(resolved_buf.buf))
7c2b3029
JK
1120 break;
1121 }
1122
1123 /*
1124 * short name is non-ambiguous if all previous rules
1125 * haven't resolved to a valid ref
1126 */
6cd4a898
JK
1127 if (j == rules_to_fail) {
1128 strbuf_release(&resolved_buf);
7c2b3029 1129 return short_name;
6cd4a898 1130 }
7c2b3029
JK
1131 }
1132
6cd4a898 1133 strbuf_release(&resolved_buf);
7c2b3029 1134 free(short_name);
dfefa935 1135 return xstrdup(refname);
7c2b3029 1136}
daebaa78
JH
1137
1138static struct string_list *hide_refs;
1139
1140int parse_hide_refs_config(const char *var, const char *value, const char *section)
1141{
ad8c7cda 1142 const char *key;
daebaa78 1143 if (!strcmp("transfer.hiderefs", var) ||
ad8c7cda
JK
1144 (!parse_config_key(var, section, NULL, NULL, &key) &&
1145 !strcmp(key, "hiderefs"))) {
daebaa78
JH
1146 char *ref;
1147 int len;
1148
1149 if (!value)
1150 return config_error_nonbool(var);
1151 ref = xstrdup(value);
1152 len = strlen(ref);
1153 while (len && ref[len - 1] == '/')
1154 ref[--len] = '\0';
1155 if (!hide_refs) {
1156 hide_refs = xcalloc(1, sizeof(*hide_refs));
1157 hide_refs->strdup_strings = 1;
1158 }
1159 string_list_append(hide_refs, ref);
1160 }
1161 return 0;
1162}
1163
78a766ab 1164int ref_is_hidden(const char *refname, const char *refname_full)
daebaa78 1165{
2bc31d16 1166 int i;
daebaa78
JH
1167
1168 if (!hide_refs)
1169 return 0;
2bc31d16
JK
1170 for (i = hide_refs->nr - 1; i >= 0; i--) {
1171 const char *match = hide_refs->items[i].string;
78a766ab 1172 const char *subject;
2bc31d16 1173 int neg = 0;
7a40a95e 1174 const char *p;
2bc31d16
JK
1175
1176 if (*match == '!') {
1177 neg = 1;
1178 match++;
1179 }
1180
78a766ab
LF
1181 if (*match == '^') {
1182 subject = refname_full;
1183 match++;
1184 } else {
1185 subject = refname;
1186 }
1187
1188 /* refname can be NULL when namespaces are used. */
7a40a95e
CC
1189 if (subject &&
1190 skip_prefix(subject, match, &p) &&
1191 (!*p || *p == '/'))
2bc31d16 1192 return !neg;
daebaa78
JH
1193 }
1194 return 0;
1195}
fa5b1830 1196
0845122c
DT
1197const char *find_descendant_ref(const char *dirname,
1198 const struct string_list *extras,
1199 const struct string_list *skip)
fa5b1830 1200{
0845122c 1201 int pos;
fa5b1830 1202
0845122c
DT
1203 if (!extras)
1204 return NULL;
fa5b1830
MH
1205
1206 /*
0845122c
DT
1207 * Look at the place where dirname would be inserted into
1208 * extras. If there is an entry at that position that starts
1209 * with dirname (remember, dirname includes the trailing
1210 * slash) and is not in skip, then we have a conflict.
fa5b1830 1211 */
0845122c
DT
1212 for (pos = string_list_find_insert_index(extras, dirname, 0);
1213 pos < extras->nr; pos++) {
1214 const char *extra_refname = extras->items[pos].string;
fa5b1830 1215
0845122c
DT
1216 if (!starts_with(extra_refname, dirname))
1217 break;
1218
1219 if (!skip || !string_list_has_string(skip, extra_refname))
1220 return extra_refname;
fa5b1830 1221 }
0845122c
DT
1222 return NULL;
1223}
fa5b1830 1224
7d2df051
NTND
1225int refs_rename_ref_available(struct ref_store *refs,
1226 const char *old_refname,
1227 const char *new_refname)
0845122c
DT
1228{
1229 struct string_list skip = STRING_LIST_INIT_NODUP;
1230 struct strbuf err = STRBUF_INIT;
ff3a299c 1231 int ok;
fa5b1830 1232
ff3a299c 1233 string_list_insert(&skip, old_refname);
7d2df051
NTND
1234 ok = !refs_verify_refname_available(refs, new_refname,
1235 NULL, &skip, &err);
ff3a299c 1236 if (!ok)
0845122c
DT
1237 error("%s", err.buf);
1238
1239 string_list_clear(&skip, 0);
1240 strbuf_release(&err);
ff3a299c 1241 return ok;
fa5b1830 1242}
2bf68ed5 1243
62f0b399 1244int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2bf68ed5
DT
1245{
1246 struct object_id oid;
1247 int flag;
1248
62f0b399 1249 if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING,
34c290a6 1250 &oid, &flag))
2bf68ed5
DT
1251 return fn("HEAD", &oid, flag, cb_data);
1252
1253 return 0;
1254}
1255
1256int head_ref(each_ref_fn fn, void *cb_data)
1257{
62f0b399 1258 return refs_head_ref(get_main_ref_store(), fn, cb_data);
2bf68ed5 1259}
93770590 1260
e121b9cb
MH
1261struct ref_iterator *refs_ref_iterator_begin(
1262 struct ref_store *refs,
1263 const char *prefix, int trim, int flags)
1264{
1265 struct ref_iterator *iter;
1266
0a0865b8
MH
1267 if (ref_paranoia < 0)
1268 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);
1269 if (ref_paranoia)
1270 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1271
e121b9cb 1272 iter = refs->be->iterator_begin(refs, prefix, flags);
c7599718
MH
1273
1274 /*
1275 * `iterator_begin()` already takes care of prefix, but we
1276 * might need to do some trimming:
1277 */
1278 if (trim)
1279 iter = prefix_ref_iterator_begin(iter, "", trim);
e121b9cb 1280
8738a8a4
MH
1281 /* Sanity check for subclasses: */
1282 if (!iter->ordered)
1283 BUG("reference iterator is not ordered");
1284
e121b9cb
MH
1285 return iter;
1286}
1287
4c4de895
MH
1288/*
1289 * Call fn for each reference in the specified submodule for which the
1290 * refname begins with prefix. If trim is non-zero, then trim that
1291 * many characters off the beginning of each refname before passing
1292 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1293 * include broken references in the iteration. If fn ever returns a
1294 * non-zero value, stop the iteration and return that value;
1295 * otherwise, return 0.
1296 */
7d2df051 1297static int do_for_each_ref(struct ref_store *refs, const char *prefix,
4c4de895
MH
1298 each_ref_fn fn, int trim, int flags, void *cb_data)
1299{
1300 struct ref_iterator *iter;
1301
00eebe35
MH
1302 if (!refs)
1303 return 0;
1304
e121b9cb 1305 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
4c4de895
MH
1306
1307 return do_for_each_ref_iterator(iter, fn, cb_data);
1308}
1309
7d2df051
NTND
1310int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1311{
1312 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1313}
1314
93770590
DT
1315int for_each_ref(each_ref_fn fn, void *cb_data)
1316{
7d2df051 1317 return refs_for_each_ref(get_main_ref_store(), fn, cb_data);
93770590
DT
1318}
1319
7d2df051
NTND
1320int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1321 each_ref_fn fn, void *cb_data)
1322{
1323 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
93770590
DT
1324}
1325
1326int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1327{
7d2df051 1328 return refs_for_each_ref_in(get_main_ref_store(), prefix, fn, cb_data);
93770590
DT
1329}
1330
1331int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
1332{
1333 unsigned int flag = 0;
1334
1335 if (broken)
1336 flag = DO_FOR_EACH_INCLUDE_BROKEN;
7d2df051
NTND
1337 return do_for_each_ref(get_main_ref_store(),
1338 prefix, fn, 0, flag, cb_data);
93770590
DT
1339}
1340
073cf63c
NTND
1341int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
1342 each_ref_fn fn, void *cb_data,
1343 unsigned int broken)
03df567f
MH
1344{
1345 unsigned int flag = 0;
1346
1347 if (broken)
1348 flag = DO_FOR_EACH_INCLUDE_BROKEN;
073cf63c 1349 return do_for_each_ref(refs, prefix, fn, 0, flag, cb_data);
03df567f
MH
1350}
1351
93770590
DT
1352int for_each_replace_ref(each_ref_fn fn, void *cb_data)
1353{
7d2df051
NTND
1354 return do_for_each_ref(get_main_ref_store(),
1355 git_replace_ref_base, fn,
1356 strlen(git_replace_ref_base),
006f3f28 1357 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
93770590
DT
1358}
1359
1360int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1361{
1362 struct strbuf buf = STRBUF_INIT;
1363 int ret;
1364 strbuf_addf(&buf, "%srefs/", get_git_namespace());
7d2df051
NTND
1365 ret = do_for_each_ref(get_main_ref_store(),
1366 buf.buf, fn, 0, 0, cb_data);
93770590
DT
1367 strbuf_release(&buf);
1368 return ret;
1369}
1370
7d2df051 1371int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
93770590 1372{
7d2df051 1373 return do_for_each_ref(refs, "", fn, 0,
93770590
DT
1374 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1375}
2d0663b2 1376
7d2df051
NTND
1377int for_each_rawref(each_ref_fn fn, void *cb_data)
1378{
1379 return refs_for_each_rawref(get_main_ref_store(), fn, cb_data);
1380}
1381
470be518 1382int refs_read_raw_ref(struct ref_store *ref_store,
99afe91a 1383 const char *refname, struct object_id *oid,
470be518
MH
1384 struct strbuf *referent, unsigned int *type)
1385{
99afe91a 1386 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent, type);
470be518
MH
1387}
1388
2d0663b2 1389/* This function needs to return a meaningful errno on failure */
7d2df051 1390const char *refs_resolve_ref_unsafe(struct ref_store *refs,
3c0cb0cb
MH
1391 const char *refname,
1392 int resolve_flags,
49e61479 1393 struct object_id *oid, int *flags)
2d0663b2
DT
1394{
1395 static struct strbuf sb_refname = STRBUF_INIT;
54fad661 1396 struct object_id unused_oid;
2d0663b2
DT
1397 int unused_flags;
1398 int symref_count;
1399
49e61479 1400 if (!oid)
1401 oid = &unused_oid;
2d0663b2
DT
1402 if (!flags)
1403 flags = &unused_flags;
1404
1405 *flags = 0;
1406
1407 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1408 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1409 !refname_is_safe(refname)) {
1410 errno = EINVAL;
1411 return NULL;
1412 }
1413
1414 /*
1415 * dwim_ref() uses REF_ISBROKEN to distinguish between
1416 * missing refs and refs that were present but invalid,
1417 * to complain about the latter to stderr.
1418 *
1419 * We don't know whether the ref exists, so don't set
1420 * REF_ISBROKEN yet.
1421 */
1422 *flags |= REF_BAD_NAME;
1423 }
1424
1425 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1426 unsigned int read_flags = 0;
1427
470be518 1428 if (refs_read_raw_ref(refs, refname,
99afe91a 1429 oid, &sb_refname, &read_flags)) {
2d0663b2 1430 *flags |= read_flags;
a1c1d817
JK
1431
1432 /* In reading mode, refs must eventually resolve */
1433 if (resolve_flags & RESOLVE_REF_READING)
1434 return NULL;
1435
1436 /*
1437 * Otherwise a missing ref is OK. But the files backend
1438 * may show errors besides ENOENT if there are
1439 * similarly-named refs.
1440 */
1441 if (errno != ENOENT &&
1442 errno != EISDIR &&
1443 errno != ENOTDIR)
2d0663b2 1444 return NULL;
a1c1d817 1445
49e61479 1446 oidclr(oid);
2d0663b2
DT
1447 if (*flags & REF_BAD_NAME)
1448 *flags |= REF_ISBROKEN;
1449 return refname;
1450 }
1451
1452 *flags |= read_flags;
1453
1454 if (!(read_flags & REF_ISSYMREF)) {
1455 if (*flags & REF_BAD_NAME) {
49e61479 1456 oidclr(oid);
2d0663b2
DT
1457 *flags |= REF_ISBROKEN;
1458 }
1459 return refname;
1460 }
1461
1462 refname = sb_refname.buf;
1463 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
49e61479 1464 oidclr(oid);
2d0663b2
DT
1465 return refname;
1466 }
1467 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1468 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1469 !refname_is_safe(refname)) {
1470 errno = EINVAL;
1471 return NULL;
1472 }
1473
1474 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1475 }
1476 }
1477
1478 errno = ELOOP;
1479 return NULL;
1480}
00eebe35 1481
6fb5acfd
DT
1482/* backend functions */
1483int refs_init_db(struct strbuf *err)
1484{
077be78d 1485 struct ref_store *refs = get_main_ref_store();
6fb5acfd
DT
1486
1487 return refs->be->init_db(refs, err);
1488}
1489
bd40dcda 1490const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
49e61479 1491 struct object_id *oid, int *flags)
bd40dcda 1492{
7d2df051 1493 return refs_resolve_ref_unsafe(get_main_ref_store(), refname,
49e61479 1494 resolve_flags, oid, flags);
bd40dcda
MH
1495}
1496
a8355bb7 1497int resolve_gitlink_ref(const char *submodule, const char *refname,
a98e6101 1498 struct object_id *oid)
424dcc76 1499{
424dcc76
MH
1500 struct ref_store *refs;
1501 int flags;
1502
29babbee 1503 refs = get_submodule_ref_store(submodule);
48a8475f 1504
424dcc76
MH
1505 if (!refs)
1506 return -1;
1507
49e61479 1508 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
a98e6101 1509 is_null_oid(oid))
424dcc76
MH
1510 return -1;
1511 return 0;
1512}
1513
0c064d90 1514struct ref_store_hash_entry
7d4558c4
MH
1515{
1516 struct hashmap_entry ent; /* must be the first member! */
1517
1518 struct ref_store *refs;
1519
0c064d90
NTND
1520 /* NUL-terminated identifier of the ref store: */
1521 char name[FLEX_ARRAY];
7d4558c4
MH
1522};
1523
7663cdc8
SB
1524static int ref_store_hash_cmp(const void *unused_cmp_data,
1525 const void *entry, const void *entry_or_key,
7d4558c4
MH
1526 const void *keydata)
1527{
0c064d90
NTND
1528 const struct ref_store_hash_entry *e1 = entry, *e2 = entry_or_key;
1529 const char *name = keydata ? keydata : e2->name;
7d4558c4 1530
0c064d90 1531 return strcmp(e1->name, name);
7d4558c4
MH
1532}
1533
0c064d90
NTND
1534static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1535 const char *name, struct ref_store *refs)
7d4558c4 1536{
0c064d90 1537 struct ref_store_hash_entry *entry;
7d4558c4 1538
0c064d90
NTND
1539 FLEX_ALLOC_STR(entry, name, name);
1540 hashmap_entry_init(entry, strhash(name));
7d4558c4
MH
1541 entry->refs = refs;
1542 return entry;
1543}
1544
00eebe35
MH
1545/* A pointer to the ref_store for the main repository: */
1546static struct ref_store *main_ref_store;
1547
7d4558c4
MH
1548/* A hashmap of ref_stores, stored by submodule name: */
1549static struct hashmap submodule_ref_stores;
00eebe35 1550
17eff96b
NTND
1551/* A hashmap of ref_stores, stored by worktree id: */
1552static struct hashmap worktree_ref_stores;
1553
c468da4e 1554/*
0c064d90
NTND
1555 * Look up a ref store by name. If that ref_store hasn't been
1556 * registered yet, return NULL.
c468da4e 1557 */
0c064d90
NTND
1558static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1559 const char *name)
00eebe35 1560{
0c064d90 1561 struct ref_store_hash_entry *entry;
00eebe35 1562
0c064d90 1563 if (!map->tablesize)
7d4558c4
MH
1564 /* It's initialized on demand in register_ref_store(). */
1565 return NULL;
620a66b9 1566
0c064d90 1567 entry = hashmap_get_from_hash(map, strhash(name), name);
7d4558c4 1568 return entry ? entry->refs : NULL;
00eebe35
MH
1569}
1570
c468da4e
MH
1571/*
1572 * Create, record, and return a ref_store instance for the specified
5d0bc90e 1573 * gitdir.
c468da4e 1574 */
9e7ec634
NTND
1575static struct ref_store *ref_store_init(const char *gitdir,
1576 unsigned int flags)
00eebe35
MH
1577{
1578 const char *be_name = "files";
1579 struct ref_storage_be *be = find_ref_storage_backend(be_name);
ba88add5 1580 struct ref_store *refs;
00eebe35
MH
1581
1582 if (!be)
1583 die("BUG: reference backend %s is unknown", be_name);
1584
9e7ec634 1585 refs = be->init(gitdir, flags);
ba88add5 1586 return refs;
00eebe35
MH
1587}
1588
077be78d 1589struct ref_store *get_main_ref_store(void)
24c8407e
NTND
1590{
1591 if (main_ref_store)
1592 return main_ref_store;
1593
0d8a814d 1594 main_ref_store = ref_store_init(get_git_dir(), REF_STORE_ALL_CAPS);
378dc910
NTND
1595 return main_ref_store;
1596}
1597
1598/*
0c064d90
NTND
1599 * Associate a ref store with a name. It is a fatal error to call this
1600 * function twice for the same name.
378dc910 1601 */
0c064d90
NTND
1602static void register_ref_store_map(struct hashmap *map,
1603 const char *type,
1604 struct ref_store *refs,
1605 const char *name)
378dc910 1606{
0c064d90 1607 if (!map->tablesize)
7663cdc8 1608 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
378dc910 1609
0c064d90
NTND
1610 if (hashmap_put(map, alloc_ref_store_hash_entry(name, refs)))
1611 die("BUG: %s ref_store '%s' initialized twice", type, name);
24c8407e
NTND
1612}
1613
18d0002d 1614struct ref_store *get_submodule_ref_store(const char *submodule)
00eebe35 1615{
126c9e05 1616 struct strbuf submodule_sb = STRBUF_INIT;
00eebe35 1617 struct ref_store *refs;
29babbee
NTND
1618 char *to_free = NULL;
1619 size_t len;
00eebe35 1620
82a150f2
NTND
1621 if (!submodule)
1622 return NULL;
1623
873ea90d
NTND
1624 len = strlen(submodule);
1625 while (len && is_dir_sep(submodule[len - 1]))
1626 len--;
1627 if (!len)
1628 return NULL;
00eebe35 1629
29babbee
NTND
1630 if (submodule[len])
1631 /* We need to strip off one or more trailing slashes */
1632 submodule = to_free = xmemdupz(submodule, len);
00eebe35 1633
0c064d90 1634 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
126c9e05 1635 if (refs)
2c616c17 1636 goto done;
00eebe35 1637
126c9e05 1638 strbuf_addstr(&submodule_sb, submodule);
2c616c17
NTND
1639 if (!is_nonbare_repository_dir(&submodule_sb))
1640 goto done;
00eebe35 1641
2c616c17
NTND
1642 if (submodule_to_gitdir(&submodule_sb, submodule))
1643 goto done;
00eebe35 1644
9e7ec634
NTND
1645 /* assume that add_submodule_odb() has been called */
1646 refs = ref_store_init(submodule_sb.buf,
1647 REF_STORE_READ | REF_STORE_ODB);
0c064d90
NTND
1648 register_ref_store_map(&submodule_ref_stores, "submodule",
1649 refs, submodule);
5d0bc90e 1650
2c616c17 1651done:
5d0bc90e 1652 strbuf_release(&submodule_sb);
29babbee
NTND
1653 free(to_free);
1654
00eebe35
MH
1655 return refs;
1656}
1657
17eff96b
NTND
1658struct ref_store *get_worktree_ref_store(const struct worktree *wt)
1659{
1660 struct ref_store *refs;
1661 const char *id;
1662
1663 if (wt->is_current)
1664 return get_main_ref_store();
1665
1666 id = wt->id ? wt->id : "/";
1667 refs = lookup_ref_store_map(&worktree_ref_stores, id);
1668 if (refs)
1669 return refs;
1670
1671 if (wt->id)
1672 refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
1673 REF_STORE_ALL_CAPS);
1674 else
1675 refs = ref_store_init(get_git_common_dir(),
1676 REF_STORE_ALL_CAPS);
1677
1678 if (refs)
1679 register_ref_store_map(&worktree_ref_stores, "worktree",
1680 refs, id);
1681 return refs;
1682}
1683
620a66b9 1684void base_ref_store_init(struct ref_store *refs,
fbfd0a29 1685 const struct ref_storage_be *be)
00eebe35 1686{
620a66b9 1687 refs->be = be;
00eebe35 1688}
127b42a1
RS
1689
1690/* backend functions */
7d2df051 1691int refs_pack_refs(struct ref_store *refs, unsigned int flags)
8231527e 1692{
8231527e
MH
1693 return refs->be->pack_refs(refs, flags);
1694}
1695
7d2df051 1696int refs_peel_ref(struct ref_store *refs, const char *refname,
b420d909 1697 struct object_id *oid)
7d2df051 1698{
ba1c052f 1699 int flag;
34c290a6 1700 struct object_id base;
ba1c052f
MH
1701
1702 if (current_ref_iter && current_ref_iter->refname == refname) {
1703 struct object_id peeled;
1704
1705 if (ref_iterator_peel(current_ref_iter, &peeled))
1706 return -1;
b420d909 1707 oidcpy(oid, &peeled);
ba1c052f
MH
1708 return 0;
1709 }
1710
1711 if (refs_read_ref_full(refs, refname,
34c290a6 1712 RESOLVE_REF_READING, &base, &flag))
ba1c052f
MH
1713 return -1;
1714
ac2ed0d7 1715 return peel_object(&base, oid);
8231527e
MH
1716}
1717
b420d909 1718int peel_ref(const char *refname, struct object_id *oid)
bd427cf2 1719{
b420d909 1720 return refs_peel_ref(get_main_ref_store(), refname, oid);
7d2df051 1721}
bd427cf2 1722
7d2df051
NTND
1723int refs_create_symref(struct ref_store *refs,
1724 const char *ref_target,
1725 const char *refs_heads_master,
1726 const char *logmsg)
1727{
1728 return refs->be->create_symref(refs, ref_target,
1729 refs_heads_master,
1730 logmsg);
bd427cf2
MH
1731}
1732
284689ba
MH
1733int create_symref(const char *ref_target, const char *refs_heads_master,
1734 const char *logmsg)
1735{
7d2df051
NTND
1736 return refs_create_symref(get_main_ref_store(), ref_target,
1737 refs_heads_master, logmsg);
284689ba
MH
1738}
1739
2ced105c
MH
1740int ref_update_reject_duplicates(struct string_list *refnames,
1741 struct strbuf *err)
1742{
a552e50e 1743 size_t i, n = refnames->nr;
2ced105c
MH
1744
1745 assert(err);
1746
8556f8d6
MH
1747 for (i = 1; i < n; i++) {
1748 int cmp = strcmp(refnames->items[i - 1].string,
1749 refnames->items[i].string);
1750
1751 if (!cmp) {
2ced105c
MH
1752 strbuf_addf(err,
1753 "multiple updates for ref '%s' not allowed.",
1754 refnames->items[i].string);
1755 return 1;
8556f8d6
MH
1756 } else if (cmp > 0) {
1757 die("BUG: ref_update_reject_duplicates() received unsorted list");
2ced105c 1758 }
8556f8d6 1759 }
2ced105c
MH
1760 return 0;
1761}
1762
30173b88
MH
1763int ref_transaction_prepare(struct ref_transaction *transaction,
1764 struct strbuf *err)
127b42a1 1765{
c0fe4e8b 1766 struct ref_store *refs = transaction->ref_store;
127b42a1 1767
8d4240d3
MH
1768 switch (transaction->state) {
1769 case REF_TRANSACTION_OPEN:
1770 /* Good. */
1771 break;
30173b88
MH
1772 case REF_TRANSACTION_PREPARED:
1773 die("BUG: prepare called twice on reference transaction");
1774 break;
8d4240d3
MH
1775 case REF_TRANSACTION_CLOSED:
1776 die("BUG: prepare called on a closed reference transaction");
1777 break;
1778 default:
1779 die("BUG: unexpected reference transaction state");
1780 break;
1781 }
1782
d8f4481c
JK
1783 if (getenv(GIT_QUARANTINE_ENVIRONMENT)) {
1784 strbuf_addstr(err,
1785 _("ref updates forbidden inside quarantine environment"));
1786 return -1;
1787 }
1788
30173b88
MH
1789 return refs->be->transaction_prepare(refs, transaction, err);
1790}
1791
1792int ref_transaction_abort(struct ref_transaction *transaction,
1793 struct strbuf *err)
1794{
1795 struct ref_store *refs = transaction->ref_store;
1796 int ret = 0;
1797
1798 switch (transaction->state) {
1799 case REF_TRANSACTION_OPEN:
1800 /* No need to abort explicitly. */
1801 break;
1802 case REF_TRANSACTION_PREPARED:
1803 ret = refs->be->transaction_abort(refs, transaction, err);
1804 break;
1805 case REF_TRANSACTION_CLOSED:
1806 die("BUG: abort called on a closed reference transaction");
1807 break;
1808 default:
1809 die("BUG: unexpected reference transaction state");
1810 break;
1811 }
1812
1813 ref_transaction_free(transaction);
1814 return ret;
1815}
1816
1817int ref_transaction_commit(struct ref_transaction *transaction,
1818 struct strbuf *err)
1819{
1820 struct ref_store *refs = transaction->ref_store;
1821 int ret;
1822
1823 switch (transaction->state) {
1824 case REF_TRANSACTION_OPEN:
1825 /* Need to prepare first. */
1826 ret = ref_transaction_prepare(transaction, err);
1827 if (ret)
1828 return ret;
1829 break;
1830 case REF_TRANSACTION_PREPARED:
1831 /* Fall through to finish. */
1832 break;
1833 case REF_TRANSACTION_CLOSED:
1834 die("BUG: commit called on a closed reference transaction");
1835 break;
1836 default:
1837 die("BUG: unexpected reference transaction state");
1838 break;
1839 }
1840
1841 return refs->be->transaction_finish(refs, transaction, err);
127b42a1 1842}
62665823 1843
7d2df051
NTND
1844int refs_verify_refname_available(struct ref_store *refs,
1845 const char *refname,
b05855b5 1846 const struct string_list *extras,
7d2df051
NTND
1847 const struct string_list *skip,
1848 struct strbuf *err)
62665823 1849{
b05855b5
MH
1850 const char *slash;
1851 const char *extra_refname;
1852 struct strbuf dirname = STRBUF_INIT;
1853 struct strbuf referent = STRBUF_INIT;
1854 struct object_id oid;
1855 unsigned int type;
1856 struct ref_iterator *iter;
1857 int ok;
1858 int ret = -1;
1859
1860 /*
1861 * For the sake of comments in this function, suppose that
1862 * refname is "refs/foo/bar".
1863 */
1864
1865 assert(err);
1866
1867 strbuf_grow(&dirname, strlen(refname) + 1);
1868 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
1869 /* Expand dirname to the new prefix, not including the trailing slash: */
1870 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
1871
1872 /*
1873 * We are still at a leading dir of the refname (e.g.,
1874 * "refs/foo"; if there is a reference with that name,
1875 * it is a conflict, *unless* it is in skip.
1876 */
1877 if (skip && string_list_has_string(skip, dirname.buf))
1878 continue;
1879
99afe91a 1880 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) {
b05855b5
MH
1881 strbuf_addf(err, "'%s' exists; cannot create '%s'",
1882 dirname.buf, refname);
1883 goto cleanup;
1884 }
1885
1886 if (extras && string_list_has_string(extras, dirname.buf)) {
1887 strbuf_addf(err, "cannot process '%s' and '%s' at the same time",
1888 refname, dirname.buf);
1889 goto cleanup;
1890 }
1891 }
1892
1893 /*
1894 * We are at the leaf of our refname (e.g., "refs/foo/bar").
1895 * There is no point in searching for a reference with that
1896 * name, because a refname isn't considered to conflict with
1897 * itself. But we still need to check for references whose
1898 * names are in the "refs/foo/bar/" namespace, because they
1899 * *do* conflict.
1900 */
1901 strbuf_addstr(&dirname, refname + dirname.len);
1902 strbuf_addch(&dirname, '/');
1903
1904 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
1905 DO_FOR_EACH_INCLUDE_BROKEN);
1906 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
1907 if (skip &&
1908 string_list_has_string(skip, iter->refname))
1909 continue;
1910
1911 strbuf_addf(err, "'%s' exists; cannot create '%s'",
1912 iter->refname, refname);
1913 ref_iterator_abort(iter);
1914 goto cleanup;
1915 }
1916
1917 if (ok != ITER_DONE)
1918 die("BUG: error while iterating over references");
1919
1920 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
1921 if (extra_refname)
1922 strbuf_addf(err, "cannot process '%s' and '%s' at the same time",
1923 refname, extra_refname);
1924 else
1925 ret = 0;
1926
1927cleanup:
1928 strbuf_release(&referent);
1929 strbuf_release(&dirname);
1930 return ret;
62665823 1931}
e3688bd6 1932
7d2df051 1933int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
e3688bd6 1934{
e3688bd6
DT
1935 struct ref_iterator *iter;
1936
1937 iter = refs->be->reflog_iterator_begin(refs);
1938
1939 return do_for_each_ref_iterator(iter, fn, cb_data);
1940}
1941
7d2df051 1942int for_each_reflog(each_ref_fn fn, void *cb_data)
e3688bd6 1943{
7d2df051
NTND
1944 return refs_for_each_reflog(get_main_ref_store(), fn, cb_data);
1945}
e3688bd6 1946
7d2df051
NTND
1947int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
1948 const char *refname,
1949 each_reflog_ent_fn fn,
1950 void *cb_data)
1951{
e3688bd6
DT
1952 return refs->be->for_each_reflog_ent_reverse(refs, refname,
1953 fn, cb_data);
1954}
1955
7d2df051
NTND
1956int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
1957 void *cb_data)
1958{
1959 return refs_for_each_reflog_ent_reverse(get_main_ref_store(),
1960 refname, fn, cb_data);
1961}
1962
1963int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
1964 each_reflog_ent_fn fn, void *cb_data)
1965{
1966 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
1967}
1968
e3688bd6
DT
1969int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
1970 void *cb_data)
1971{
7d2df051
NTND
1972 return refs_for_each_reflog_ent(get_main_ref_store(), refname,
1973 fn, cb_data);
1974}
e3688bd6 1975
7d2df051
NTND
1976int refs_reflog_exists(struct ref_store *refs, const char *refname)
1977{
1978 return refs->be->reflog_exists(refs, refname);
e3688bd6
DT
1979}
1980
1981int reflog_exists(const char *refname)
1982{
7d2df051
NTND
1983 return refs_reflog_exists(get_main_ref_store(), refname);
1984}
e3688bd6 1985
7d2df051
NTND
1986int refs_create_reflog(struct ref_store *refs, const char *refname,
1987 int force_create, struct strbuf *err)
1988{
1989 return refs->be->create_reflog(refs, refname, force_create, err);
e3688bd6
DT
1990}
1991
1992int safe_create_reflog(const char *refname, int force_create,
1993 struct strbuf *err)
1994{
7d2df051
NTND
1995 return refs_create_reflog(get_main_ref_store(), refname,
1996 force_create, err);
1997}
e3688bd6 1998
7d2df051
NTND
1999int refs_delete_reflog(struct ref_store *refs, const char *refname)
2000{
2001 return refs->be->delete_reflog(refs, refname);
e3688bd6
DT
2002}
2003
2004int delete_reflog(const char *refname)
2005{
7d2df051
NTND
2006 return refs_delete_reflog(get_main_ref_store(), refname);
2007}
e3688bd6 2008
7d2df051 2009int refs_reflog_expire(struct ref_store *refs,
0155f710 2010 const char *refname, const struct object_id *oid,
7d2df051
NTND
2011 unsigned int flags,
2012 reflog_expiry_prepare_fn prepare_fn,
2013 reflog_expiry_should_prune_fn should_prune_fn,
2014 reflog_expiry_cleanup_fn cleanup_fn,
2015 void *policy_cb_data)
2016{
0155f710 2017 return refs->be->reflog_expire(refs, refname, oid, flags,
7d2df051
NTND
2018 prepare_fn, should_prune_fn,
2019 cleanup_fn, policy_cb_data);
e3688bd6
DT
2020}
2021
0155f710 2022int reflog_expire(const char *refname, const struct object_id *oid,
e3688bd6
DT
2023 unsigned int flags,
2024 reflog_expiry_prepare_fn prepare_fn,
2025 reflog_expiry_should_prune_fn should_prune_fn,
2026 reflog_expiry_cleanup_fn cleanup_fn,
2027 void *policy_cb_data)
2028{
7d2df051 2029 return refs_reflog_expire(get_main_ref_store(),
0155f710 2030 refname, oid, flags,
7d2df051
NTND
2031 prepare_fn, should_prune_fn,
2032 cleanup_fn, policy_cb_data);
e3688bd6 2033}
fc681463
DT
2034
2035int initial_ref_transaction_commit(struct ref_transaction *transaction,
2036 struct strbuf *err)
2037{
c0fe4e8b 2038 struct ref_store *refs = transaction->ref_store;
fc681463
DT
2039
2040 return refs->be->initial_transaction_commit(refs, transaction, err);
2041}
a27dcf89 2042
64da4199
MH
2043int refs_delete_refs(struct ref_store *refs, const char *msg,
2044 struct string_list *refnames, unsigned int flags)
a27dcf89 2045{
64da4199 2046 return refs->be->delete_refs(refs, msg, refnames, flags);
a27dcf89 2047}
9b6b40d9 2048
64da4199
MH
2049int delete_refs(const char *msg, struct string_list *refnames,
2050 unsigned int flags)
9b6b40d9 2051{
64da4199 2052 return refs_delete_refs(get_main_ref_store(), msg, refnames, flags);
7d2df051 2053}
9b6b40d9 2054
7d2df051
NTND
2055int refs_rename_ref(struct ref_store *refs, const char *oldref,
2056 const char *newref, const char *logmsg)
2057{
9b6b40d9
DT
2058 return refs->be->rename_ref(refs, oldref, newref, logmsg);
2059}
7d2df051
NTND
2060
2061int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2062{
2063 return refs_rename_ref(get_main_ref_store(), oldref, newref, logmsg);
2064}
52d59cc6
SD
2065
2066int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2067 const char *newref, const char *logmsg)
2068{
2069 return refs->be->copy_ref(refs, oldref, newref, logmsg);
2070}
2071
2072int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2073{
2074 return refs_copy_existing_ref(get_main_ref_store(), oldref, newref, logmsg);
2075}