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