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