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