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