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