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