refs: allow for_each_replace_ref to handle arbitrary repositories
[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
0d296c57 1418int for_each_replace_ref(struct repository *r, each_ref_fn fn, void *cb_data)
93770590 1419{
0d296c57 1420 return do_for_each_ref(get_main_ref_store(r),
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
7d4558c4
MH
1611/* A hashmap of ref_stores, stored by submodule name: */
1612static struct hashmap submodule_ref_stores;
00eebe35 1613
17eff96b
NTND
1614/* A hashmap of ref_stores, stored by worktree id: */
1615static struct hashmap worktree_ref_stores;
1616
c468da4e 1617/*
0c064d90
NTND
1618 * Look up a ref store by name. If that ref_store hasn't been
1619 * registered yet, return NULL.
c468da4e 1620 */
0c064d90
NTND
1621static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1622 const char *name)
00eebe35 1623{
0c064d90 1624 struct ref_store_hash_entry *entry;
00eebe35 1625
0c064d90 1626 if (!map->tablesize)
7d4558c4
MH
1627 /* It's initialized on demand in register_ref_store(). */
1628 return NULL;
620a66b9 1629
0c064d90 1630 entry = hashmap_get_from_hash(map, strhash(name), name);
7d4558c4 1631 return entry ? entry->refs : NULL;
00eebe35
MH
1632}
1633
c468da4e
MH
1634/*
1635 * Create, record, and return a ref_store instance for the specified
5d0bc90e 1636 * gitdir.
c468da4e 1637 */
9e7ec634
NTND
1638static struct ref_store *ref_store_init(const char *gitdir,
1639 unsigned int flags)
00eebe35
MH
1640{
1641 const char *be_name = "files";
1642 struct ref_storage_be *be = find_ref_storage_backend(be_name);
ba88add5 1643 struct ref_store *refs;
00eebe35
MH
1644
1645 if (!be)
1646 die("BUG: reference backend %s is unknown", be_name);
1647
9e7ec634 1648 refs = be->init(gitdir, flags);
ba88add5 1649 return refs;
00eebe35
MH
1650}
1651
64a74161 1652struct ref_store *get_main_ref_store(struct repository *r)
24c8407e 1653{
64a74161
SB
1654 if (r->refs)
1655 return r->refs;
24c8407e 1656
64a74161
SB
1657 r->refs = ref_store_init(r->gitdir, REF_STORE_ALL_CAPS);
1658 return r->refs;
378dc910
NTND
1659}
1660
1661/*
0c064d90
NTND
1662 * Associate a ref store with a name. It is a fatal error to call this
1663 * function twice for the same name.
378dc910 1664 */
0c064d90
NTND
1665static void register_ref_store_map(struct hashmap *map,
1666 const char *type,
1667 struct ref_store *refs,
1668 const char *name)
378dc910 1669{
0c064d90 1670 if (!map->tablesize)
7663cdc8 1671 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
378dc910 1672
0c064d90
NTND
1673 if (hashmap_put(map, alloc_ref_store_hash_entry(name, refs)))
1674 die("BUG: %s ref_store '%s' initialized twice", type, name);
24c8407e
NTND
1675}
1676
18d0002d 1677struct ref_store *get_submodule_ref_store(const char *submodule)
00eebe35 1678{
126c9e05 1679 struct strbuf submodule_sb = STRBUF_INIT;
00eebe35 1680 struct ref_store *refs;
29babbee
NTND
1681 char *to_free = NULL;
1682 size_t len;
00eebe35 1683
82a150f2
NTND
1684 if (!submodule)
1685 return NULL;
1686
873ea90d
NTND
1687 len = strlen(submodule);
1688 while (len && is_dir_sep(submodule[len - 1]))
1689 len--;
1690 if (!len)
1691 return NULL;
00eebe35 1692
29babbee
NTND
1693 if (submodule[len])
1694 /* We need to strip off one or more trailing slashes */
1695 submodule = to_free = xmemdupz(submodule, len);
00eebe35 1696
0c064d90 1697 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
126c9e05 1698 if (refs)
2c616c17 1699 goto done;
00eebe35 1700
126c9e05 1701 strbuf_addstr(&submodule_sb, submodule);
2c616c17
NTND
1702 if (!is_nonbare_repository_dir(&submodule_sb))
1703 goto done;
00eebe35 1704
2c616c17
NTND
1705 if (submodule_to_gitdir(&submodule_sb, submodule))
1706 goto done;
00eebe35 1707
9e7ec634
NTND
1708 /* assume that add_submodule_odb() has been called */
1709 refs = ref_store_init(submodule_sb.buf,
1710 REF_STORE_READ | REF_STORE_ODB);
0c064d90
NTND
1711 register_ref_store_map(&submodule_ref_stores, "submodule",
1712 refs, submodule);
5d0bc90e 1713
2c616c17 1714done:
5d0bc90e 1715 strbuf_release(&submodule_sb);
29babbee
NTND
1716 free(to_free);
1717
00eebe35
MH
1718 return refs;
1719}
1720
17eff96b
NTND
1721struct ref_store *get_worktree_ref_store(const struct worktree *wt)
1722{
1723 struct ref_store *refs;
1724 const char *id;
1725
1726 if (wt->is_current)
23a3f0cb 1727 return get_main_ref_store(the_repository);
17eff96b
NTND
1728
1729 id = wt->id ? wt->id : "/";
1730 refs = lookup_ref_store_map(&worktree_ref_stores, id);
1731 if (refs)
1732 return refs;
1733
1734 if (wt->id)
1735 refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
1736 REF_STORE_ALL_CAPS);
1737 else
1738 refs = ref_store_init(get_git_common_dir(),
1739 REF_STORE_ALL_CAPS);
1740
1741 if (refs)
1742 register_ref_store_map(&worktree_ref_stores, "worktree",
1743 refs, id);
1744 return refs;
1745}
1746
620a66b9 1747void base_ref_store_init(struct ref_store *refs,
fbfd0a29 1748 const struct ref_storage_be *be)
00eebe35 1749{
620a66b9 1750 refs->be = be;
00eebe35 1751}
127b42a1
RS
1752
1753/* backend functions */
7d2df051 1754int refs_pack_refs(struct ref_store *refs, unsigned int flags)
8231527e 1755{
8231527e
MH
1756 return refs->be->pack_refs(refs, flags);
1757}
1758
7d2df051 1759int refs_peel_ref(struct ref_store *refs, const char *refname,
b420d909 1760 struct object_id *oid)
7d2df051 1761{
ba1c052f 1762 int flag;
34c290a6 1763 struct object_id base;
ba1c052f
MH
1764
1765 if (current_ref_iter && current_ref_iter->refname == refname) {
1766 struct object_id peeled;
1767
1768 if (ref_iterator_peel(current_ref_iter, &peeled))
1769 return -1;
b420d909 1770 oidcpy(oid, &peeled);
ba1c052f
MH
1771 return 0;
1772 }
1773
1774 if (refs_read_ref_full(refs, refname,
34c290a6 1775 RESOLVE_REF_READING, &base, &flag))
ba1c052f
MH
1776 return -1;
1777
ac2ed0d7 1778 return peel_object(&base, oid);
8231527e
MH
1779}
1780
b420d909 1781int peel_ref(const char *refname, struct object_id *oid)
bd427cf2 1782{
23a3f0cb 1783 return refs_peel_ref(get_main_ref_store(the_repository), refname, oid);
7d2df051 1784}
bd427cf2 1785
7d2df051
NTND
1786int refs_create_symref(struct ref_store *refs,
1787 const char *ref_target,
1788 const char *refs_heads_master,
1789 const char *logmsg)
1790{
1791 return refs->be->create_symref(refs, ref_target,
1792 refs_heads_master,
1793 logmsg);
bd427cf2
MH
1794}
1795
284689ba
MH
1796int create_symref(const char *ref_target, const char *refs_heads_master,
1797 const char *logmsg)
1798{
23a3f0cb 1799 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
7d2df051 1800 refs_heads_master, logmsg);
284689ba
MH
1801}
1802
2ced105c
MH
1803int ref_update_reject_duplicates(struct string_list *refnames,
1804 struct strbuf *err)
1805{
a552e50e 1806 size_t i, n = refnames->nr;
2ced105c
MH
1807
1808 assert(err);
1809
8556f8d6
MH
1810 for (i = 1; i < n; i++) {
1811 int cmp = strcmp(refnames->items[i - 1].string,
1812 refnames->items[i].string);
1813
1814 if (!cmp) {
2ced105c
MH
1815 strbuf_addf(err,
1816 "multiple updates for ref '%s' not allowed.",
1817 refnames->items[i].string);
1818 return 1;
8556f8d6
MH
1819 } else if (cmp > 0) {
1820 die("BUG: ref_update_reject_duplicates() received unsorted list");
2ced105c 1821 }
8556f8d6 1822 }
2ced105c
MH
1823 return 0;
1824}
1825
30173b88
MH
1826int ref_transaction_prepare(struct ref_transaction *transaction,
1827 struct strbuf *err)
127b42a1 1828{
c0fe4e8b 1829 struct ref_store *refs = transaction->ref_store;
127b42a1 1830
8d4240d3
MH
1831 switch (transaction->state) {
1832 case REF_TRANSACTION_OPEN:
1833 /* Good. */
1834 break;
30173b88
MH
1835 case REF_TRANSACTION_PREPARED:
1836 die("BUG: prepare called twice on reference transaction");
1837 break;
8d4240d3
MH
1838 case REF_TRANSACTION_CLOSED:
1839 die("BUG: prepare called on a closed reference transaction");
1840 break;
1841 default:
1842 die("BUG: unexpected reference transaction state");
1843 break;
1844 }
1845
d8f4481c
JK
1846 if (getenv(GIT_QUARANTINE_ENVIRONMENT)) {
1847 strbuf_addstr(err,
1848 _("ref updates forbidden inside quarantine environment"));
1849 return -1;
1850 }
1851
30173b88
MH
1852 return refs->be->transaction_prepare(refs, transaction, err);
1853}
1854
1855int ref_transaction_abort(struct ref_transaction *transaction,
1856 struct strbuf *err)
1857{
1858 struct ref_store *refs = transaction->ref_store;
1859 int ret = 0;
1860
1861 switch (transaction->state) {
1862 case REF_TRANSACTION_OPEN:
1863 /* No need to abort explicitly. */
1864 break;
1865 case REF_TRANSACTION_PREPARED:
1866 ret = refs->be->transaction_abort(refs, transaction, err);
1867 break;
1868 case REF_TRANSACTION_CLOSED:
1869 die("BUG: abort called on a closed reference transaction");
1870 break;
1871 default:
1872 die("BUG: unexpected reference transaction state");
1873 break;
1874 }
1875
1876 ref_transaction_free(transaction);
1877 return ret;
1878}
1879
1880int ref_transaction_commit(struct ref_transaction *transaction,
1881 struct strbuf *err)
1882{
1883 struct ref_store *refs = transaction->ref_store;
1884 int ret;
1885
1886 switch (transaction->state) {
1887 case REF_TRANSACTION_OPEN:
1888 /* Need to prepare first. */
1889 ret = ref_transaction_prepare(transaction, err);
1890 if (ret)
1891 return ret;
1892 break;
1893 case REF_TRANSACTION_PREPARED:
1894 /* Fall through to finish. */
1895 break;
1896 case REF_TRANSACTION_CLOSED:
1897 die("BUG: commit called on a closed reference transaction");
1898 break;
1899 default:
1900 die("BUG: unexpected reference transaction state");
1901 break;
1902 }
1903
1904 return refs->be->transaction_finish(refs, transaction, err);
127b42a1 1905}
62665823 1906
7d2df051
NTND
1907int refs_verify_refname_available(struct ref_store *refs,
1908 const char *refname,
b05855b5 1909 const struct string_list *extras,
7d2df051
NTND
1910 const struct string_list *skip,
1911 struct strbuf *err)
62665823 1912{
b05855b5
MH
1913 const char *slash;
1914 const char *extra_refname;
1915 struct strbuf dirname = STRBUF_INIT;
1916 struct strbuf referent = STRBUF_INIT;
1917 struct object_id oid;
1918 unsigned int type;
1919 struct ref_iterator *iter;
1920 int ok;
1921 int ret = -1;
1922
1923 /*
1924 * For the sake of comments in this function, suppose that
1925 * refname is "refs/foo/bar".
1926 */
1927
1928 assert(err);
1929
1930 strbuf_grow(&dirname, strlen(refname) + 1);
1931 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
1932 /* Expand dirname to the new prefix, not including the trailing slash: */
1933 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
1934
1935 /*
1936 * We are still at a leading dir of the refname (e.g.,
1937 * "refs/foo"; if there is a reference with that name,
1938 * it is a conflict, *unless* it is in skip.
1939 */
1940 if (skip && string_list_has_string(skip, dirname.buf))
1941 continue;
1942
99afe91a 1943 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) {
b05855b5
MH
1944 strbuf_addf(err, "'%s' exists; cannot create '%s'",
1945 dirname.buf, refname);
1946 goto cleanup;
1947 }
1948
1949 if (extras && string_list_has_string(extras, dirname.buf)) {
1950 strbuf_addf(err, "cannot process '%s' and '%s' at the same time",
1951 refname, dirname.buf);
1952 goto cleanup;
1953 }
1954 }
1955
1956 /*
1957 * We are at the leaf of our refname (e.g., "refs/foo/bar").
1958 * There is no point in searching for a reference with that
1959 * name, because a refname isn't considered to conflict with
1960 * itself. But we still need to check for references whose
1961 * names are in the "refs/foo/bar/" namespace, because they
1962 * *do* conflict.
1963 */
1964 strbuf_addstr(&dirname, refname + dirname.len);
1965 strbuf_addch(&dirname, '/');
1966
1967 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
1968 DO_FOR_EACH_INCLUDE_BROKEN);
1969 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
1970 if (skip &&
1971 string_list_has_string(skip, iter->refname))
1972 continue;
1973
1974 strbuf_addf(err, "'%s' exists; cannot create '%s'",
1975 iter->refname, refname);
1976 ref_iterator_abort(iter);
1977 goto cleanup;
1978 }
1979
1980 if (ok != ITER_DONE)
1981 die("BUG: error while iterating over references");
1982
1983 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
1984 if (extra_refname)
1985 strbuf_addf(err, "cannot process '%s' and '%s' at the same time",
1986 refname, extra_refname);
1987 else
1988 ret = 0;
1989
1990cleanup:
1991 strbuf_release(&referent);
1992 strbuf_release(&dirname);
1993 return ret;
62665823 1994}
e3688bd6 1995
7d2df051 1996int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
e3688bd6 1997{
e3688bd6
DT
1998 struct ref_iterator *iter;
1999
2000 iter = refs->be->reflog_iterator_begin(refs);
2001
2002 return do_for_each_ref_iterator(iter, fn, cb_data);
2003}
2004
7d2df051 2005int for_each_reflog(each_ref_fn fn, void *cb_data)
e3688bd6 2006{
23a3f0cb 2007 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
7d2df051 2008}
e3688bd6 2009
7d2df051
NTND
2010int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2011 const char *refname,
2012 each_reflog_ent_fn fn,
2013 void *cb_data)
2014{
e3688bd6
DT
2015 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2016 fn, cb_data);
2017}
2018
7d2df051
NTND
2019int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2020 void *cb_data)
2021{
23a3f0cb 2022 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
7d2df051
NTND
2023 refname, fn, cb_data);
2024}
2025
2026int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2027 each_reflog_ent_fn fn, void *cb_data)
2028{
2029 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2030}
2031
e3688bd6
DT
2032int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2033 void *cb_data)
2034{
23a3f0cb 2035 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
7d2df051
NTND
2036 fn, cb_data);
2037}
e3688bd6 2038
7d2df051
NTND
2039int refs_reflog_exists(struct ref_store *refs, const char *refname)
2040{
2041 return refs->be->reflog_exists(refs, refname);
e3688bd6
DT
2042}
2043
2044int reflog_exists(const char *refname)
2045{
23a3f0cb 2046 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
7d2df051 2047}
e3688bd6 2048
7d2df051
NTND
2049int refs_create_reflog(struct ref_store *refs, const char *refname,
2050 int force_create, struct strbuf *err)
2051{
2052 return refs->be->create_reflog(refs, refname, force_create, err);
e3688bd6
DT
2053}
2054
2055int safe_create_reflog(const char *refname, int force_create,
2056 struct strbuf *err)
2057{
23a3f0cb 2058 return refs_create_reflog(get_main_ref_store(the_repository), refname,
7d2df051
NTND
2059 force_create, err);
2060}
e3688bd6 2061
7d2df051
NTND
2062int refs_delete_reflog(struct ref_store *refs, const char *refname)
2063{
2064 return refs->be->delete_reflog(refs, refname);
e3688bd6
DT
2065}
2066
2067int delete_reflog(const char *refname)
2068{
23a3f0cb 2069 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
7d2df051 2070}
e3688bd6 2071
7d2df051 2072int refs_reflog_expire(struct ref_store *refs,
0155f710 2073 const char *refname, const struct object_id *oid,
7d2df051
NTND
2074 unsigned int flags,
2075 reflog_expiry_prepare_fn prepare_fn,
2076 reflog_expiry_should_prune_fn should_prune_fn,
2077 reflog_expiry_cleanup_fn cleanup_fn,
2078 void *policy_cb_data)
2079{
0155f710 2080 return refs->be->reflog_expire(refs, refname, oid, flags,
7d2df051
NTND
2081 prepare_fn, should_prune_fn,
2082 cleanup_fn, policy_cb_data);
e3688bd6
DT
2083}
2084
0155f710 2085int reflog_expire(const char *refname, const struct object_id *oid,
e3688bd6
DT
2086 unsigned int flags,
2087 reflog_expiry_prepare_fn prepare_fn,
2088 reflog_expiry_should_prune_fn should_prune_fn,
2089 reflog_expiry_cleanup_fn cleanup_fn,
2090 void *policy_cb_data)
2091{
23a3f0cb 2092 return refs_reflog_expire(get_main_ref_store(the_repository),
0155f710 2093 refname, oid, flags,
7d2df051
NTND
2094 prepare_fn, should_prune_fn,
2095 cleanup_fn, policy_cb_data);
e3688bd6 2096}
fc681463
DT
2097
2098int initial_ref_transaction_commit(struct ref_transaction *transaction,
2099 struct strbuf *err)
2100{
c0fe4e8b 2101 struct ref_store *refs = transaction->ref_store;
fc681463
DT
2102
2103 return refs->be->initial_transaction_commit(refs, transaction, err);
2104}
a27dcf89 2105
64da4199
MH
2106int refs_delete_refs(struct ref_store *refs, const char *msg,
2107 struct string_list *refnames, unsigned int flags)
a27dcf89 2108{
64da4199 2109 return refs->be->delete_refs(refs, msg, refnames, flags);
a27dcf89 2110}
9b6b40d9 2111
64da4199
MH
2112int delete_refs(const char *msg, struct string_list *refnames,
2113 unsigned int flags)
9b6b40d9 2114{
23a3f0cb 2115 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
7d2df051 2116}
9b6b40d9 2117
7d2df051
NTND
2118int refs_rename_ref(struct ref_store *refs, const char *oldref,
2119 const char *newref, const char *logmsg)
2120{
9b6b40d9
DT
2121 return refs->be->rename_ref(refs, oldref, newref, logmsg);
2122}
7d2df051
NTND
2123
2124int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2125{
23a3f0cb 2126 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
7d2df051 2127}
52d59cc6
SD
2128
2129int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2130 const char *newref, const char *logmsg)
2131{
2132 return refs->be->copy_ref(refs, oldref, newref, logmsg);
2133}
2134
2135int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2136{
23a3f0cb 2137 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
52d59cc6 2138}