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