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