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