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