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