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