environment.c: fix potential segfault by get_git_common_dir()
[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
4c4de895
MH
1233/*
1234 * Call fn for each reference in the specified submodule for which the
1235 * refname begins with prefix. If trim is non-zero, then trim that
1236 * many characters off the beginning of each refname before passing
1237 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1238 * include broken references in the iteration. If fn ever returns a
1239 * non-zero value, stop the iteration and return that value;
1240 * otherwise, return 0.
1241 */
7d2df051 1242static int do_for_each_ref(struct ref_store *refs, const char *prefix,
4c4de895
MH
1243 each_ref_fn fn, int trim, int flags, void *cb_data)
1244{
1245 struct ref_iterator *iter;
1246
00eebe35
MH
1247 if (!refs)
1248 return 0;
1249
1a769003 1250 iter = refs->be->iterator_begin(refs, prefix, flags);
4c4de895
MH
1251 iter = prefix_ref_iterator_begin(iter, prefix, trim);
1252
1253 return do_for_each_ref_iterator(iter, fn, cb_data);
1254}
1255
7d2df051
NTND
1256int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1257{
1258 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1259}
1260
93770590
DT
1261int for_each_ref(each_ref_fn fn, void *cb_data)
1262{
7d2df051 1263 return refs_for_each_ref(get_main_ref_store(), fn, cb_data);
93770590
DT
1264}
1265
1266int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1267{
7d2df051
NTND
1268 return refs_for_each_ref(get_submodule_ref_store(submodule), fn, cb_data);
1269}
1270
1271int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1272 each_ref_fn fn, void *cb_data)
1273{
1274 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
93770590
DT
1275}
1276
1277int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1278{
7d2df051 1279 return refs_for_each_ref_in(get_main_ref_store(), prefix, fn, cb_data);
93770590
DT
1280}
1281
1282int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
1283{
1284 unsigned int flag = 0;
1285
1286 if (broken)
1287 flag = DO_FOR_EACH_INCLUDE_BROKEN;
7d2df051
NTND
1288 return do_for_each_ref(get_main_ref_store(),
1289 prefix, fn, 0, flag, cb_data);
93770590
DT
1290}
1291
1292int for_each_ref_in_submodule(const char *submodule, const char *prefix,
7d2df051 1293 each_ref_fn fn, void *cb_data)
93770590 1294{
7d2df051
NTND
1295 return refs_for_each_ref_in(get_submodule_ref_store(submodule),
1296 prefix, fn, cb_data);
93770590
DT
1297}
1298
1299int for_each_replace_ref(each_ref_fn fn, void *cb_data)
1300{
7d2df051
NTND
1301 return do_for_each_ref(get_main_ref_store(),
1302 git_replace_ref_base, fn,
1303 strlen(git_replace_ref_base),
1304 0, cb_data);
93770590
DT
1305}
1306
1307int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1308{
1309 struct strbuf buf = STRBUF_INIT;
1310 int ret;
1311 strbuf_addf(&buf, "%srefs/", get_git_namespace());
7d2df051
NTND
1312 ret = do_for_each_ref(get_main_ref_store(),
1313 buf.buf, fn, 0, 0, cb_data);
93770590
DT
1314 strbuf_release(&buf);
1315 return ret;
1316}
1317
7d2df051 1318int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
93770590 1319{
7d2df051 1320 return do_for_each_ref(refs, "", fn, 0,
93770590
DT
1321 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1322}
2d0663b2 1323
7d2df051
NTND
1324int for_each_rawref(each_ref_fn fn, void *cb_data)
1325{
1326 return refs_for_each_rawref(get_main_ref_store(), fn, cb_data);
1327}
1328
2d0663b2 1329/* This function needs to return a meaningful errno on failure */
7d2df051 1330const char *refs_resolve_ref_unsafe(struct ref_store *refs,
3c0cb0cb
MH
1331 const char *refname,
1332 int resolve_flags,
1333 unsigned char *sha1, int *flags)
2d0663b2
DT
1334{
1335 static struct strbuf sb_refname = STRBUF_INIT;
1336 int unused_flags;
1337 int symref_count;
1338
1339 if (!flags)
1340 flags = &unused_flags;
1341
1342 *flags = 0;
1343
1344 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1345 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1346 !refname_is_safe(refname)) {
1347 errno = EINVAL;
1348 return NULL;
1349 }
1350
1351 /*
1352 * dwim_ref() uses REF_ISBROKEN to distinguish between
1353 * missing refs and refs that were present but invalid,
1354 * to complain about the latter to stderr.
1355 *
1356 * We don't know whether the ref exists, so don't set
1357 * REF_ISBROKEN yet.
1358 */
1359 *flags |= REF_BAD_NAME;
1360 }
1361
1362 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1363 unsigned int read_flags = 0;
1364
e1e33b72
MH
1365 if (refs->be->read_raw_ref(refs, refname,
1366 sha1, &sb_refname, &read_flags)) {
2d0663b2
DT
1367 *flags |= read_flags;
1368 if (errno != ENOENT || (resolve_flags & RESOLVE_REF_READING))
1369 return NULL;
1370 hashclr(sha1);
1371 if (*flags & REF_BAD_NAME)
1372 *flags |= REF_ISBROKEN;
1373 return refname;
1374 }
1375
1376 *flags |= read_flags;
1377
1378 if (!(read_flags & REF_ISSYMREF)) {
1379 if (*flags & REF_BAD_NAME) {
1380 hashclr(sha1);
1381 *flags |= REF_ISBROKEN;
1382 }
1383 return refname;
1384 }
1385
1386 refname = sb_refname.buf;
1387 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1388 hashclr(sha1);
1389 return refname;
1390 }
1391 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1392 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1393 !refname_is_safe(refname)) {
1394 errno = EINVAL;
1395 return NULL;
1396 }
1397
1398 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1399 }
1400 }
1401
1402 errno = ELOOP;
1403 return NULL;
1404}
00eebe35 1405
6fb5acfd
DT
1406/* backend functions */
1407int refs_init_db(struct strbuf *err)
1408{
077be78d 1409 struct ref_store *refs = get_main_ref_store();
6fb5acfd
DT
1410
1411 return refs->be->init_db(refs, err);
1412}
1413
bd40dcda
MH
1414const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1415 unsigned char *sha1, int *flags)
1416{
7d2df051 1417 return refs_resolve_ref_unsafe(get_main_ref_store(), refname,
bd40dcda
MH
1418 resolve_flags, sha1, flags);
1419}
1420
a8355bb7
MH
1421int resolve_gitlink_ref(const char *submodule, const char *refname,
1422 unsigned char *sha1)
424dcc76 1423{
a8355bb7 1424 size_t len = strlen(submodule);
424dcc76
MH
1425 struct ref_store *refs;
1426 int flags;
1427
a8355bb7 1428 while (len && submodule[len - 1] == '/')
424dcc76 1429 len--;
48a8475f 1430
424dcc76
MH
1431 if (!len)
1432 return -1;
1433
a8355bb7 1434 if (submodule[len]) {
48a8475f 1435 /* We need to strip off one or more trailing slashes */
a8355bb7 1436 char *stripped = xmemdupz(submodule, len);
48a8475f 1437
18d0002d 1438 refs = get_submodule_ref_store(stripped);
48a8475f
MH
1439 free(stripped);
1440 } else {
18d0002d 1441 refs = get_submodule_ref_store(submodule);
48a8475f
MH
1442 }
1443
424dcc76
MH
1444 if (!refs)
1445 return -1;
1446
7d2df051 1447 if (!refs_resolve_ref_unsafe(refs, refname, 0, sha1, &flags) ||
424dcc76
MH
1448 is_null_sha1(sha1))
1449 return -1;
1450 return 0;
1451}
1452
7d4558c4
MH
1453struct submodule_hash_entry
1454{
1455 struct hashmap_entry ent; /* must be the first member! */
1456
1457 struct ref_store *refs;
1458
1459 /* NUL-terminated name of submodule: */
1460 char submodule[FLEX_ARRAY];
1461};
1462
1463static int submodule_hash_cmp(const void *entry, const void *entry_or_key,
1464 const void *keydata)
1465{
1466 const struct submodule_hash_entry *e1 = entry, *e2 = entry_or_key;
1467 const char *submodule = keydata ? keydata : e2->submodule;
1468
1469 return strcmp(e1->submodule, submodule);
1470}
1471
1472static struct submodule_hash_entry *alloc_submodule_hash_entry(
1473 const char *submodule, struct ref_store *refs)
1474{
1475 struct submodule_hash_entry *entry;
1476
1477 FLEX_ALLOC_STR(entry, submodule, submodule);
1478 hashmap_entry_init(entry, strhash(submodule));
1479 entry->refs = refs;
1480 return entry;
1481}
1482
00eebe35
MH
1483/* A pointer to the ref_store for the main repository: */
1484static struct ref_store *main_ref_store;
1485
7d4558c4
MH
1486/* A hashmap of ref_stores, stored by submodule name: */
1487static struct hashmap submodule_ref_stores;
00eebe35 1488
c468da4e 1489/*
9476c6ed
NTND
1490 * Return the ref_store instance for the specified submodule. If that
1491 * ref_store hasn't been initialized yet, return NULL.
c468da4e 1492 */
9476c6ed 1493static struct ref_store *lookup_submodule_ref_store(const char *submodule)
00eebe35 1494{
7d4558c4 1495 struct submodule_hash_entry *entry;
00eebe35 1496
7d4558c4
MH
1497 if (!submodule_ref_stores.tablesize)
1498 /* It's initialized on demand in register_ref_store(). */
1499 return NULL;
620a66b9 1500
7d4558c4
MH
1501 entry = hashmap_get_from_hash(&submodule_ref_stores,
1502 strhash(submodule), submodule);
1503 return entry ? entry->refs : NULL;
00eebe35
MH
1504}
1505
c468da4e
MH
1506/*
1507 * Create, record, and return a ref_store instance for the specified
5d0bc90e 1508 * gitdir.
c468da4e 1509 */
9e7ec634
NTND
1510static struct ref_store *ref_store_init(const char *gitdir,
1511 unsigned int flags)
00eebe35
MH
1512{
1513 const char *be_name = "files";
1514 struct ref_storage_be *be = find_ref_storage_backend(be_name);
ba88add5 1515 struct ref_store *refs;
00eebe35
MH
1516
1517 if (!be)
1518 die("BUG: reference backend %s is unknown", be_name);
1519
9e7ec634 1520 refs = be->init(gitdir, flags);
ba88add5 1521 return refs;
00eebe35
MH
1522}
1523
077be78d 1524struct ref_store *get_main_ref_store(void)
24c8407e
NTND
1525{
1526 if (main_ref_store)
1527 return main_ref_store;
1528
9e7ec634
NTND
1529 main_ref_store = ref_store_init(get_git_dir(),
1530 (REF_STORE_READ |
1531 REF_STORE_WRITE |
1532 REF_STORE_ODB |
1533 REF_STORE_MAIN));
378dc910
NTND
1534 return main_ref_store;
1535}
1536
1537/*
1538 * Register the specified ref_store to be the one that should be used
1539 * for submodule. It is a fatal error to call this function twice for
1540 * the same submodule.
1541 */
1542static void register_submodule_ref_store(struct ref_store *refs,
1543 const char *submodule)
1544{
1545 if (!submodule_ref_stores.tablesize)
1546 hashmap_init(&submodule_ref_stores, submodule_hash_cmp, 0);
1547
1548 if (hashmap_put(&submodule_ref_stores,
1549 alloc_submodule_hash_entry(submodule, refs)))
1550 die("BUG: ref_store for submodule '%s' initialized twice",
1551 submodule);
24c8407e
NTND
1552}
1553
18d0002d 1554struct ref_store *get_submodule_ref_store(const char *submodule)
00eebe35 1555{
126c9e05 1556 struct strbuf submodule_sb = STRBUF_INIT;
00eebe35 1557 struct ref_store *refs;
126c9e05 1558 int ret;
00eebe35
MH
1559
1560 if (!submodule || !*submodule) {
18d0002d
NTND
1561 /*
1562 * FIXME: This case is ideally not allowed. But that
1563 * can't happen until we clean up all the callers.
1564 */
24c8407e 1565 return get_main_ref_store();
126c9e05 1566 }
00eebe35 1567
126c9e05
NTND
1568 refs = lookup_submodule_ref_store(submodule);
1569 if (refs)
1570 return refs;
00eebe35 1571
126c9e05
NTND
1572 strbuf_addstr(&submodule_sb, submodule);
1573 ret = is_nonbare_repository_dir(&submodule_sb);
1574 strbuf_release(&submodule_sb);
1575 if (!ret)
1576 return NULL;
1577
5d0bc90e
NTND
1578 ret = submodule_to_gitdir(&submodule_sb, submodule);
1579 if (ret) {
1580 strbuf_release(&submodule_sb);
1581 return NULL;
1582 }
1583
9e7ec634
NTND
1584 /* assume that add_submodule_odb() has been called */
1585 refs = ref_store_init(submodule_sb.buf,
1586 REF_STORE_READ | REF_STORE_ODB);
378dc910 1587 register_submodule_ref_store(refs, submodule);
5d0bc90e
NTND
1588
1589 strbuf_release(&submodule_sb);
00eebe35
MH
1590 return refs;
1591}
1592
620a66b9 1593void base_ref_store_init(struct ref_store *refs,
fbfd0a29 1594 const struct ref_storage_be *be)
00eebe35 1595{
620a66b9 1596 refs->be = be;
00eebe35 1597}
127b42a1
RS
1598
1599/* backend functions */
7d2df051
NTND
1600int refs_pack_refs(struct ref_store *refs, unsigned int flags)
1601{
1602 return refs->be->pack_refs(refs, flags);
1603}
1604
7d2df051
NTND
1605int refs_peel_ref(struct ref_store *refs, const char *refname,
1606 unsigned char *sha1)
1607{
1608 return refs->be->peel_ref(refs, refname, sha1);
8231527e
MH
1609}
1610
bd427cf2
MH
1611int peel_ref(const char *refname, unsigned char *sha1)
1612{
7d2df051
NTND
1613 return refs_peel_ref(get_main_ref_store(), refname, sha1);
1614}
bd427cf2 1615
7d2df051
NTND
1616int refs_create_symref(struct ref_store *refs,
1617 const char *ref_target,
1618 const char *refs_heads_master,
1619 const char *logmsg)
1620{
1621 return refs->be->create_symref(refs, ref_target,
1622 refs_heads_master,
1623 logmsg);
bd427cf2
MH
1624}
1625
284689ba
MH
1626int create_symref(const char *ref_target, const char *refs_heads_master,
1627 const char *logmsg)
1628{
7d2df051
NTND
1629 return refs_create_symref(get_main_ref_store(), ref_target,
1630 refs_heads_master, logmsg);
284689ba
MH
1631}
1632
127b42a1
RS
1633int ref_transaction_commit(struct ref_transaction *transaction,
1634 struct strbuf *err)
1635{
c0fe4e8b 1636 struct ref_store *refs = transaction->ref_store;
127b42a1
RS
1637
1638 return refs->be->transaction_commit(refs, transaction, err);
1639}
62665823 1640
7d2df051
NTND
1641int refs_verify_refname_available(struct ref_store *refs,
1642 const char *refname,
1643 const struct string_list *extra,
1644 const struct string_list *skip,
1645 struct strbuf *err)
62665823 1646{
62665823
MH
1647 return refs->be->verify_refname_available(refs, refname, extra, skip, err);
1648}
e3688bd6 1649
7d2df051 1650int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
e3688bd6 1651{
e3688bd6
DT
1652 struct ref_iterator *iter;
1653
1654 iter = refs->be->reflog_iterator_begin(refs);
1655
1656 return do_for_each_ref_iterator(iter, fn, cb_data);
1657}
1658
7d2df051 1659int for_each_reflog(each_ref_fn fn, void *cb_data)
e3688bd6 1660{
7d2df051
NTND
1661 return refs_for_each_reflog(get_main_ref_store(), fn, cb_data);
1662}
e3688bd6 1663
7d2df051
NTND
1664int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
1665 const char *refname,
1666 each_reflog_ent_fn fn,
1667 void *cb_data)
1668{
e3688bd6
DT
1669 return refs->be->for_each_reflog_ent_reverse(refs, refname,
1670 fn, cb_data);
1671}
1672
7d2df051
NTND
1673int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
1674 void *cb_data)
1675{
1676 return refs_for_each_reflog_ent_reverse(get_main_ref_store(),
1677 refname, fn, cb_data);
1678}
1679
1680int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
1681 each_reflog_ent_fn fn, void *cb_data)
1682{
1683 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
1684}
1685
e3688bd6
DT
1686int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
1687 void *cb_data)
1688{
7d2df051
NTND
1689 return refs_for_each_reflog_ent(get_main_ref_store(), refname,
1690 fn, cb_data);
1691}
e3688bd6 1692
7d2df051
NTND
1693int refs_reflog_exists(struct ref_store *refs, const char *refname)
1694{
1695 return refs->be->reflog_exists(refs, refname);
e3688bd6
DT
1696}
1697
1698int reflog_exists(const char *refname)
1699{
7d2df051
NTND
1700 return refs_reflog_exists(get_main_ref_store(), refname);
1701}
e3688bd6 1702
7d2df051
NTND
1703int refs_create_reflog(struct ref_store *refs, const char *refname,
1704 int force_create, struct strbuf *err)
1705{
1706 return refs->be->create_reflog(refs, refname, force_create, err);
e3688bd6
DT
1707}
1708
1709int safe_create_reflog(const char *refname, int force_create,
1710 struct strbuf *err)
1711{
7d2df051
NTND
1712 return refs_create_reflog(get_main_ref_store(), refname,
1713 force_create, err);
1714}
e3688bd6 1715
7d2df051
NTND
1716int refs_delete_reflog(struct ref_store *refs, const char *refname)
1717{
1718 return refs->be->delete_reflog(refs, refname);
e3688bd6
DT
1719}
1720
1721int delete_reflog(const char *refname)
1722{
7d2df051
NTND
1723 return refs_delete_reflog(get_main_ref_store(), refname);
1724}
e3688bd6 1725
7d2df051
NTND
1726int refs_reflog_expire(struct ref_store *refs,
1727 const char *refname, const unsigned char *sha1,
1728 unsigned int flags,
1729 reflog_expiry_prepare_fn prepare_fn,
1730 reflog_expiry_should_prune_fn should_prune_fn,
1731 reflog_expiry_cleanup_fn cleanup_fn,
1732 void *policy_cb_data)
1733{
1734 return refs->be->reflog_expire(refs, refname, sha1, flags,
1735 prepare_fn, should_prune_fn,
1736 cleanup_fn, policy_cb_data);
e3688bd6
DT
1737}
1738
1739int reflog_expire(const char *refname, const unsigned char *sha1,
1740 unsigned int flags,
1741 reflog_expiry_prepare_fn prepare_fn,
1742 reflog_expiry_should_prune_fn should_prune_fn,
1743 reflog_expiry_cleanup_fn cleanup_fn,
1744 void *policy_cb_data)
1745{
7d2df051
NTND
1746 return refs_reflog_expire(get_main_ref_store(),
1747 refname, sha1, flags,
1748 prepare_fn, should_prune_fn,
1749 cleanup_fn, policy_cb_data);
e3688bd6 1750}
fc681463
DT
1751
1752int initial_ref_transaction_commit(struct ref_transaction *transaction,
1753 struct strbuf *err)
1754{
c0fe4e8b 1755 struct ref_store *refs = transaction->ref_store;
fc681463
DT
1756
1757 return refs->be->initial_transaction_commit(refs, transaction, err);
1758}
a27dcf89 1759
7d2df051
NTND
1760int refs_delete_refs(struct ref_store *refs, struct string_list *refnames,
1761 unsigned int flags)
a27dcf89 1762{
a27dcf89
DT
1763 return refs->be->delete_refs(refs, refnames, flags);
1764}
9b6b40d9 1765
7d2df051 1766int delete_refs(struct string_list *refnames, unsigned int flags)
9b6b40d9 1767{
7d2df051
NTND
1768 return refs_delete_refs(get_main_ref_store(), refnames, flags);
1769}
9b6b40d9 1770
7d2df051
NTND
1771int refs_rename_ref(struct ref_store *refs, const char *oldref,
1772 const char *newref, const char *logmsg)
1773{
9b6b40d9
DT
1774 return refs->be->rename_ref(refs, oldref, newref, logmsg);
1775}
7d2df051
NTND
1776
1777int rename_ref(const char *oldref, const char *newref, const char *logmsg)
1778{
1779 return refs_rename_ref(get_main_ref_store(), oldref, newref, logmsg);
1780}