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