Merge branch 'tb/banned-vsprintf-namefix'
[git/git.git] / refs.c
CommitLineData
7bd9bcf3
MH
1/*
2 * The backend-independent part of the reference module.
3 */
4
95fc7512 5#include "cache.h"
b2141fc1 6#include "config.h"
7d4558c4 7#include "hashmap.h"
697cc8ef 8#include "lockfile.h"
b05855b5 9#include "iterator.h"
85023577 10#include "refs.h"
4cb77009 11#include "refs/refs-internal.h"
cbd53a21 12#include "object-store.h"
cf0adba7
JH
13#include "object.h"
14#include "tag.h"
5d0bc90e 15#include "submodule.h"
17eff96b 16#include "worktree.h"
b4be7410 17#include "argv-array.h"
23a3f0cb 18#include "repository.h"
3581d793 19
3dce444f
RS
20/*
21 * List of all available backends
22 */
23static struct ref_storage_be *refs_backends = &refs_be_files;
24
25static struct ref_storage_be *find_ref_storage_backend(const char *name)
26{
27 struct ref_storage_be *be;
28 for (be = refs_backends; be; be = be->next)
29 if (!strcmp(be->name, name))
30 return be;
31 return NULL;
32}
33
34int ref_storage_backend_exists(const char *name)
35{
36 return find_ref_storage_backend(name) != NULL;
37}
38
bc5fd6d3 39/*
dde8a902
DT
40 * How to handle various characters in refnames:
41 * 0: An acceptable character for refs
5e650228
JH
42 * 1: End-of-component
43 * 2: ., look for a preceding . to reject .. in refs
44 * 3: {, look for a preceding @ to reject @{ in refs
53a8555e 45 * 4: A bad character: ASCII control characters, and
cd377f45
JK
46 * ":", "?", "[", "\", "^", "~", SP, or TAB
47 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
dde8a902
DT
48 */
49static unsigned char refname_disposition[256] = {
5e650228
JH
50 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
51 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
cd377f45 52 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
5e650228 53 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
dde8a902 54 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5e650228
JH
55 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
56 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
57 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
dde8a902
DT
58};
59
60/*
61 * Try to read one refname component from the front of refname.
62 * Return the length of the component found, or -1 if the component is
63 * not legal. It is legal if it is something reasonable to have under
64 * ".git/refs/"; We do not like it if:
bc5fd6d3 65 *
1de16aec 66 * - it begins with ".", or
bc5fd6d3 67 * - it has double dots "..", or
53a8555e 68 * - it has ASCII control characters, or
cd377f45
JK
69 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
70 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
53a8555e
JK
71 * - it ends with a "/", or
72 * - it ends with ".lock", or
73 * - it contains a "@{" portion
1de16aec
NTND
74 *
75 * When sanitized is not NULL, instead of rejecting the input refname
76 * as an error, try to come up with a usable replacement for the input
77 * refname in it.
bc5fd6d3 78 */
1de16aec
NTND
79static int check_refname_component(const char *refname, int *flags,
80 struct strbuf *sanitized)
bc5fd6d3
MH
81{
82 const char *cp;
83 char last = '\0';
1de16aec
NTND
84 size_t component_start = 0; /* garbage - not a reasonable initial value */
85
86 if (sanitized)
87 component_start = sanitized->len;
bc5fd6d3
MH
88
89 for (cp = refname; ; cp++) {
dde8a902
DT
90 int ch = *cp & 255;
91 unsigned char disp = refname_disposition[ch];
1de16aec
NTND
92
93 if (sanitized && disp != 1)
94 strbuf_addch(sanitized, ch);
95
dde8a902 96 switch (disp) {
5e650228 97 case 1:
dde8a902 98 goto out;
5e650228 99 case 2:
1de16aec
NTND
100 if (last == '.') { /* Refname contains "..". */
101 if (sanitized)
102 /* collapse ".." to single "." */
103 strbuf_setlen(sanitized, sanitized->len - 1);
104 else
105 return -1;
106 }
dde8a902 107 break;
5e650228 108 case 3:
1de16aec
NTND
109 if (last == '@') { /* Refname contains "@{". */
110 if (sanitized)
111 sanitized->buf[sanitized->len-1] = '-';
112 else
113 return -1;
114 }
bc5fd6d3 115 break;
5e650228 116 case 4:
1de16aec
NTND
117 /* forbidden char */
118 if (sanitized)
119 sanitized->buf[sanitized->len-1] = '-';
120 else
121 return -1;
122 break;
cd377f45 123 case 5:
1de16aec
NTND
124 if (!(*flags & REFNAME_REFSPEC_PATTERN)) {
125 /* refspec can't be a pattern */
126 if (sanitized)
127 sanitized->buf[sanitized->len-1] = '-';
128 else
129 return -1;
130 }
cd377f45
JK
131
132 /*
133 * Unset the pattern flag so that we only accept
134 * a single asterisk for one side of refspec.
135 */
136 *flags &= ~ REFNAME_REFSPEC_PATTERN;
137 break;
dde8a902 138 }
bc5fd6d3
MH
139 last = ch;
140 }
dde8a902 141out:
bc5fd6d3 142 if (cp == refname)
dac529e4 143 return 0; /* Component has zero length. */
1de16aec
NTND
144
145 if (refname[0] == '.') { /* Component starts with '.'. */
146 if (sanitized)
147 sanitized->buf[component_start] = '-';
148 else
149 return -1;
150 }
7108ad23 151 if (cp - refname >= LOCK_SUFFIX_LEN &&
1de16aec
NTND
152 !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN)) {
153 if (!sanitized)
154 return -1;
155 /* Refname ends with ".lock". */
156 while (strbuf_strip_suffix(sanitized, LOCK_SUFFIX)) {
157 /* try again in case we have .lock.lock */
158 }
159 }
bc5fd6d3
MH
160 return cp - refname;
161}
162
1de16aec
NTND
163static int check_or_sanitize_refname(const char *refname, int flags,
164 struct strbuf *sanitized)
bc5fd6d3
MH
165{
166 int component_len, component_count = 0;
167
1de16aec 168 if (!strcmp(refname, "@")) {
9ba89f48 169 /* Refname is a single character '@'. */
1de16aec
NTND
170 if (sanitized)
171 strbuf_addch(sanitized, '-');
172 else
173 return -1;
174 }
9ba89f48 175
bc5fd6d3 176 while (1) {
1de16aec
NTND
177 if (sanitized && sanitized->len)
178 strbuf_complete(sanitized, '/');
179
bc5fd6d3 180 /* We are at the start of a path component. */
1de16aec
NTND
181 component_len = check_refname_component(refname, &flags,
182 sanitized);
183 if (sanitized && component_len == 0)
184 ; /* OK, omit empty component */
185 else if (component_len <= 0)
cd377f45
JK
186 return -1;
187
bc5fd6d3
MH
188 component_count++;
189 if (refname[component_len] == '\0')
190 break;
191 /* Skip to next component. */
192 refname += component_len + 1;
193 }
194
1de16aec
NTND
195 if (refname[component_len - 1] == '.') {
196 /* Refname ends with '.'. */
197 if (sanitized)
198 ; /* omit ending dot */
199 else
200 return -1;
201 }
bc5fd6d3
MH
202 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
203 return -1; /* Refname has only one component. */
204 return 0;
205}
206
1de16aec
NTND
207int check_refname_format(const char *refname, int flags)
208{
209 return check_or_sanitize_refname(refname, flags, NULL);
210}
211
212void sanitize_refname_component(const char *refname, struct strbuf *out)
213{
214 if (check_or_sanitize_refname(refname, REFNAME_ALLOW_ONELEVEL, out))
215 BUG("sanitizing refname '%s' check returned error", refname);
216}
217
4cb77009 218int refname_is_safe(const char *refname)
d0f810f0 219{
39950fef
MH
220 const char *rest;
221
222 if (skip_prefix(refname, "refs/", &rest)) {
d0f810f0
RS
223 char *buf;
224 int result;
e40f3557
MH
225 size_t restlen = strlen(rest);
226
227 /* rest must not be empty, or start or end with "/" */
228 if (!restlen || *rest == '/' || rest[restlen - 1] == '/')
229 return 0;
d0f810f0 230
d0f810f0
RS
231 /*
232 * Does the refname try to escape refs/?
233 * For example: refs/foo/../bar is safe but refs/foo/../../bar
234 * is not.
235 */
e40f3557
MH
236 buf = xmallocz(restlen);
237 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
d0f810f0
RS
238 free(buf);
239 return result;
240 }
35db25c6
MH
241
242 do {
d0f810f0
RS
243 if (!isupper(*refname) && *refname != '_')
244 return 0;
245 refname++;
35db25c6 246 } while (*refname);
d0f810f0
RS
247 return 1;
248}
249
67be7c5a
MH
250/*
251 * Return true if refname, which has the specified oid and flags, can
252 * be resolved to an object in the database. If the referred-to object
253 * does not exist, emit a warning and return false.
254 */
255int ref_resolves_to_object(const char *refname,
256 const struct object_id *oid,
257 unsigned int flags)
258{
259 if (flags & REF_ISBROKEN)
260 return 0;
98374a07 261 if (!has_object_file(oid)) {
661558f0 262 error(_("%s does not point to a valid object!"), refname);
67be7c5a
MH
263 return 0;
264 }
265 return 1;
266}
267
7d2df051
NTND
268char *refs_resolve_refdup(struct ref_store *refs,
269 const char *refname, int resolve_flags,
0f2dc722 270 struct object_id *oid, int *flags)
7d2df051
NTND
271{
272 const char *result;
273
274 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
49e61479 275 oid, flags);
7d2df051
NTND
276 return xstrdup_or_null(result);
277}
278
7bd9bcf3 279char *resolve_refdup(const char *refname, int resolve_flags,
0f2dc722 280 struct object_id *oid, int *flags)
e1e22e37 281{
23a3f0cb 282 return refs_resolve_refdup(get_main_ref_store(the_repository),
7d2df051 283 refname, resolve_flags,
0f2dc722 284 oid, flags);
cddc4258
MH
285}
286
7bd9bcf3
MH
287/* The argument to filter_refs */
288struct ref_filter {
289 const char *pattern;
9ab9b5df 290 const char *prefix;
7bd9bcf3
MH
291 each_ref_fn *fn;
292 void *cb_data;
293};
432ad41e 294
7d2df051 295int refs_read_ref_full(struct ref_store *refs, const char *refname,
34c290a6 296 int resolve_flags, struct object_id *oid, int *flags)
732134ed 297{
49e61479 298 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags, oid, flags))
7bd9bcf3
MH
299 return 0;
300 return -1;
732134ed
MH
301}
302
34c290a6 303int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags)
7d2df051 304{
23a3f0cb 305 return refs_read_ref_full(get_main_ref_store(the_repository), refname,
34c290a6 306 resolve_flags, oid, flags);
7d2df051
NTND
307}
308
34c290a6 309int read_ref(const char *refname, struct object_id *oid)
cddc4258 310{
34c290a6 311 return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
c774aab9
JP
312}
313
b3cd33d0
NTND
314static int refs_ref_exists(struct ref_store *refs, const char *refname)
315{
316 return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING, NULL, NULL);
317}
318
7bd9bcf3 319int ref_exists(const char *refname)
bc5fd6d3 320{
b3cd33d0 321 return refs_ref_exists(get_main_ref_store(the_repository), refname);
bc5fd6d3
MH
322}
323
65516f58
RA
324static int match_ref_pattern(const char *refname,
325 const struct string_list_item *item)
326{
327 int matched = 0;
328 if (item->util == NULL) {
329 if (!wildmatch(item->string, refname, 0))
330 matched = 1;
331 } else {
332 const char *rest;
333 if (skip_prefix(refname, item->string, &rest) &&
334 (!*rest || *rest == '/'))
335 matched = 1;
336 }
337 return matched;
338}
339
340int ref_filter_match(const char *refname,
341 const struct string_list *include_patterns,
342 const struct string_list *exclude_patterns)
343{
344 struct string_list_item *item;
345
346 if (exclude_patterns && exclude_patterns->nr) {
347 for_each_string_list_item(item, exclude_patterns) {
348 if (match_ref_pattern(refname, item))
349 return 0;
350 }
351 }
352
353 if (include_patterns && include_patterns->nr) {
354 int found = 0;
355 for_each_string_list_item(item, include_patterns) {
356 if (match_ref_pattern(refname, item)) {
357 found = 1;
358 break;
359 }
360 }
361
362 if (!found)
363 return 0;
364 }
365 return 1;
366}
367
7bd9bcf3
MH
368static int filter_refs(const char *refname, const struct object_id *oid,
369 int flags, void *data)
432ad41e 370{
7bd9bcf3
MH
371 struct ref_filter *filter = (struct ref_filter *)data;
372
55d34269 373 if (wildmatch(filter->pattern, refname, 0))
7bd9bcf3 374 return 0;
9ab9b5df
RA
375 if (filter->prefix)
376 skip_prefix(refname, filter->prefix, &refname);
7bd9bcf3 377 return filter->fn(refname, oid, flags, filter->cb_data);
432ad41e
MH
378}
379
ac2ed0d7 380enum peel_status peel_object(const struct object_id *name, struct object_id *oid)
c774aab9 381{
0ebbcf70 382 struct object *o = lookup_unknown_object(name);
c774aab9 383
7bd9bcf3 384 if (o->type == OBJ_NONE) {
0df8e965 385 int type = oid_object_info(the_repository, name, NULL);
1268dfac 386 if (type < 0 || !object_as_type(the_repository, o, type, 0))
7bd9bcf3
MH
387 return PEEL_INVALID;
388 }
bc5fd6d3 389
7bd9bcf3
MH
390 if (o->type != OBJ_TAG)
391 return PEEL_NON_TAG;
e1980c9d 392
7bd9bcf3
MH
393 o = deref_tag_noverify(o);
394 if (!o)
395 return PEEL_INVALID;
396
ac2ed0d7 397 oidcpy(oid, &o->oid);
7bd9bcf3 398 return PEEL_PEELED;
e1980c9d
JH
399}
400
7bd9bcf3
MH
401struct warn_if_dangling_data {
402 FILE *fp;
403 const char *refname;
404 const struct string_list *refnames;
405 const char *msg_fmt;
406};
bc5fd6d3 407
7bd9bcf3
MH
408static int warn_if_dangling_symref(const char *refname, const struct object_id *oid,
409 int flags, void *cb_data)
410{
411 struct warn_if_dangling_data *d = cb_data;
412 const char *resolves_to;
bc5fd6d3 413
7bd9bcf3
MH
414 if (!(flags & REF_ISSYMREF))
415 return 0;
bc5fd6d3 416
744c040b 417 resolves_to = resolve_ref_unsafe(refname, 0, NULL, NULL);
7bd9bcf3
MH
418 if (!resolves_to
419 || (d->refname
420 ? strcmp(resolves_to, d->refname)
421 : !string_list_has_string(d->refnames, resolves_to))) {
422 return 0;
423 }
bc5fd6d3 424
7bd9bcf3
MH
425 fprintf(d->fp, d->msg_fmt, refname);
426 fputc('\n', d->fp);
427 return 0;
bc5fd6d3
MH
428}
429
7bd9bcf3 430void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
f348ac92 431{
7bd9bcf3
MH
432 struct warn_if_dangling_data data;
433
434 data.fp = fp;
435 data.refname = refname;
436 data.refnames = NULL;
437 data.msg_fmt = msg_fmt;
438 for_each_rawref(warn_if_dangling_symref, &data);
f348ac92
MH
439}
440
7bd9bcf3 441void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
432ad41e 442{
7bd9bcf3 443 struct warn_if_dangling_data data;
432ad41e 444
7bd9bcf3
MH
445 data.fp = fp;
446 data.refname = NULL;
447 data.refnames = refnames;
448 data.msg_fmt = msg_fmt;
449 for_each_rawref(warn_if_dangling_symref, &data);
432ad41e
MH
450}
451
7d2df051
NTND
452int refs_for_each_tag_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
453{
454 return refs_for_each_ref_in(refs, "refs/tags/", fn, cb_data);
455}
456
7bd9bcf3 457int for_each_tag_ref(each_ref_fn fn, void *cb_data)
432ad41e 458{
23a3f0cb 459 return refs_for_each_tag_ref(get_main_ref_store(the_repository), fn, cb_data);
432ad41e
MH
460}
461
7d2df051
NTND
462int refs_for_each_branch_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
463{
464 return refs_for_each_ref_in(refs, "refs/heads/", fn, cb_data);
432ad41e
MH
465}
466
7bd9bcf3 467int for_each_branch_ref(each_ref_fn fn, void *cb_data)
432ad41e 468{
23a3f0cb 469 return refs_for_each_branch_ref(get_main_ref_store(the_repository), fn, cb_data);
432ad41e
MH
470}
471
7d2df051
NTND
472int refs_for_each_remote_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
473{
474 return refs_for_each_ref_in(refs, "refs/remotes/", fn, cb_data);
202a56a9 475}
432ad41e 476
7bd9bcf3 477int for_each_remote_ref(each_ref_fn fn, void *cb_data)
e9c4c111 478{
23a3f0cb 479 return refs_for_each_remote_ref(get_main_ref_store(the_repository), fn, cb_data);
202a56a9
MH
480}
481
7bd9bcf3
MH
482int head_ref_namespaced(each_ref_fn fn, void *cb_data)
483{
484 struct strbuf buf = STRBUF_INIT;
485 int ret = 0;
486 struct object_id oid;
487 int flag;
c774aab9 488
7bd9bcf3 489 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
34c290a6 490 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, &oid, &flag))
7bd9bcf3
MH
491 ret = fn(buf.buf, &oid, flag, cb_data);
492 strbuf_release(&buf);
c774aab9 493
7bd9bcf3 494 return ret;
e9c4c111 495}
c774aab9 496
65516f58
RA
497void normalize_glob_ref(struct string_list_item *item, const char *prefix,
498 const char *pattern)
499{
500 struct strbuf normalized_pattern = STRBUF_INIT;
501
502 if (*pattern == '/')
503 BUG("pattern must not start with '/'");
504
505 if (prefix) {
506 strbuf_addstr(&normalized_pattern, prefix);
507 }
508 else if (!starts_with(pattern, "refs/"))
509 strbuf_addstr(&normalized_pattern, "refs/");
510 strbuf_addstr(&normalized_pattern, pattern);
511 strbuf_strip_suffix(&normalized_pattern, "/");
512
513 item->string = strbuf_detach(&normalized_pattern, NULL);
514 item->util = has_glob_specials(pattern) ? NULL : item->string;
515 strbuf_release(&normalized_pattern);
516}
517
7bd9bcf3
MH
518int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
519 const char *prefix, void *cb_data)
662428f4 520{
7bd9bcf3
MH
521 struct strbuf real_pattern = STRBUF_INIT;
522 struct ref_filter filter;
523 int ret;
d08bae7e 524
59556548 525 if (!prefix && !starts_with(pattern, "refs/"))
d08bae7e 526 strbuf_addstr(&real_pattern, "refs/");
b09fe971
IL
527 else if (prefix)
528 strbuf_addstr(&real_pattern, prefix);
d08bae7e
IL
529 strbuf_addstr(&real_pattern, pattern);
530
894a9d33 531 if (!has_glob_specials(pattern)) {
9517e6b8 532 /* Append implied '/' '*' if not present. */
00b6c178 533 strbuf_complete(&real_pattern, '/');
d08bae7e
IL
534 /* No need to check for '*', there is none. */
535 strbuf_addch(&real_pattern, '*');
536 }
537
538 filter.pattern = real_pattern.buf;
9ab9b5df 539 filter.prefix = prefix;
d08bae7e
IL
540 filter.fn = fn;
541 filter.cb_data = cb_data;
542 ret = for_each_ref(filter_refs, &filter);
543
544 strbuf_release(&real_pattern);
545 return ret;
546}
547
b09fe971
IL
548int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
549{
550 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
551}
552
4577e483 553const char *prettify_refname(const char *name)
a9c37a72 554{
3e5b36c6
SG
555 if (skip_prefix(name, "refs/heads/", &name) ||
556 skip_prefix(name, "refs/tags/", &name) ||
557 skip_prefix(name, "refs/remotes/", &name))
558 ; /* nothing */
559 return name;
a9c37a72
DB
560}
561
54457fe5 562static const char *ref_rev_parse_rules[] = {
79803322
SP
563 "%.*s",
564 "refs/%.*s",
565 "refs/tags/%.*s",
566 "refs/heads/%.*s",
567 "refs/remotes/%.*s",
568 "refs/remotes/%.*s/HEAD",
569 NULL
570};
571
60650a48
JH
572#define NUM_REV_PARSE_RULES (ARRAY_SIZE(ref_rev_parse_rules) - 1)
573
574/*
575 * Is it possible that the caller meant full_name with abbrev_name?
576 * If so return a non-zero value to signal "yes"; the magnitude of
577 * the returned value gives the precedence used for disambiguation.
578 *
579 * If abbrev_name cannot mean full_name, return 0.
580 */
54457fe5 581int refname_match(const char *abbrev_name, const char *full_name)
79803322
SP
582{
583 const char **p;
584 const int abbrev_name_len = strlen(abbrev_name);
60650a48 585 const int num_rules = NUM_REV_PARSE_RULES;
79803322 586
60650a48
JH
587 for (p = ref_rev_parse_rules; *p; p++)
588 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name)))
589 return &ref_rev_parse_rules[num_rules] - p;
79803322
SP
590
591 return 0;
592}
593
b4be7410
BW
594/*
595 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
596 * the results to 'prefixes'
597 */
598void expand_ref_prefix(struct argv_array *prefixes, const char *prefix)
599{
600 const char **p;
601 int len = strlen(prefix);
602
603 for (p = ref_rev_parse_rules; *p; p++)
604 argv_array_pushf(prefixes, *p, len, prefix);
605}
606
ff74f7f1
JH
607/*
608 * *string and *len will only be substituted, and *string returned (for
609 * later free()ing) if the string passed in is a magic short-hand form
610 * to name a branch.
611 */
8f56e9d4
NTND
612static char *substitute_branch_name(struct repository *r,
613 const char **string, int *len)
ff74f7f1
JH
614{
615 struct strbuf buf = STRBUF_INIT;
8f56e9d4 616 int ret = repo_interpret_branch_name(r, *string, *len, &buf, 0);
ff74f7f1
JH
617
618 if (ret == *len) {
619 size_t size;
620 *string = strbuf_detach(&buf, &size);
621 *len = size;
622 return (char *)*string;
623 }
624
625 return NULL;
626}
627
d8984c53
NTND
628int repo_dwim_ref(struct repository *r, const char *str, int len,
629 struct object_id *oid, char **ref)
ff74f7f1 630{
d8984c53
NTND
631 char *last_branch = substitute_branch_name(r, &str, &len);
632 int refs_found = expand_ref(r, str, len, oid, ref);
41da7111
NTND
633 free(last_branch);
634 return refs_found;
635}
636
d8984c53
NTND
637int dwim_ref(const char *str, int len, struct object_id *oid, char **ref)
638{
639 return repo_dwim_ref(the_repository, str, len, oid, ref);
640}
641
0b1dbf53
NTND
642int expand_ref(struct repository *repo, const char *str, int len,
643 struct object_id *oid, char **ref)
41da7111 644{
ff74f7f1
JH
645 const char **p, *r;
646 int refs_found = 0;
6cd4a898 647 struct strbuf fullref = STRBUF_INIT;
ff74f7f1
JH
648
649 *ref = NULL;
650 for (p = ref_rev_parse_rules; *p; p++) {
cca5fa64 651 struct object_id oid_from_ref;
652 struct object_id *this_result;
ff74f7f1
JH
653 int flag;
654
cca5fa64 655 this_result = refs_found ? &oid_from_ref : oid;
6cd4a898
JK
656 strbuf_reset(&fullref);
657 strbuf_addf(&fullref, *p, len, str);
0b1dbf53
NTND
658 r = refs_resolve_ref_unsafe(get_main_ref_store(repo),
659 fullref.buf, RESOLVE_REF_READING,
660 this_result, &flag);
ff74f7f1
JH
661 if (r) {
662 if (!refs_found++)
663 *ref = xstrdup(r);
664 if (!warn_ambiguous_refs)
665 break;
6cd4a898 666 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
661558f0 667 warning(_("ignoring dangling symref %s"), fullref.buf);
6cd4a898 668 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
661558f0 669 warning(_("ignoring broken ref %s"), fullref.buf);
55956350 670 }
ff74f7f1 671 }
6cd4a898 672 strbuf_release(&fullref);
ff74f7f1
JH
673 return refs_found;
674}
675
56700903
NTND
676int repo_dwim_log(struct repository *r, const char *str, int len,
677 struct object_id *oid, char **log)
ff74f7f1 678{
56700903
NTND
679 struct ref_store *refs = get_main_ref_store(r);
680 char *last_branch = substitute_branch_name(r, &str, &len);
ff74f7f1
JH
681 const char **p;
682 int logs_found = 0;
6cd4a898 683 struct strbuf path = STRBUF_INIT;
ff74f7f1
JH
684
685 *log = NULL;
686 for (p = ref_rev_parse_rules; *p; p++) {
334dc52f 687 struct object_id hash;
ff74f7f1
JH
688 const char *ref, *it;
689
6cd4a898
JK
690 strbuf_reset(&path);
691 strbuf_addf(&path, *p, len, str);
56700903
NTND
692 ref = refs_resolve_ref_unsafe(refs, path.buf,
693 RESOLVE_REF_READING,
694 &hash, NULL);
ff74f7f1
JH
695 if (!ref)
696 continue;
56700903 697 if (refs_reflog_exists(refs, path.buf))
6cd4a898 698 it = path.buf;
56700903
NTND
699 else if (strcmp(ref, path.buf) &&
700 refs_reflog_exists(refs, ref))
ff74f7f1
JH
701 it = ref;
702 else
703 continue;
704 if (!logs_found++) {
705 *log = xstrdup(it);
334dc52f 706 oidcpy(oid, &hash);
ff74f7f1 707 }
7bd9bcf3
MH
708 if (!warn_ambiguous_refs)
709 break;
c0277d15 710 }
6cd4a898 711 strbuf_release(&path);
7bd9bcf3
MH
712 free(last_branch);
713 return logs_found;
2ddb5d17
BK
714}
715
56700903
NTND
716int dwim_log(const char *str, int len, struct object_id *oid, char **log)
717{
718 return repo_dwim_log(the_repository, str, len, oid, log);
719}
720
266b1827
DT
721static int is_per_worktree_ref(const char *refname)
722{
ce414b33 723 return !strcmp(refname, "HEAD") ||
8aff1a9c 724 starts_with(refname, "refs/worktree/") ||
a9be29c9
JS
725 starts_with(refname, "refs/bisect/") ||
726 starts_with(refname, "refs/rewritten/");
266b1827
DT
727}
728
729static int is_pseudoref_syntax(const char *refname)
730{
731 const char *c;
732
733 for (c = refname; *c; c++) {
734 if (!isupper(*c) && *c != '-' && *c != '_')
735 return 0;
736 }
737
738 return 1;
739}
740
3a3b9d8c
NTND
741static int is_main_pseudoref_syntax(const char *refname)
742{
743 return skip_prefix(refname, "main-worktree/", &refname) &&
744 *refname &&
745 is_pseudoref_syntax(refname);
746}
747
748static int is_other_pseudoref_syntax(const char *refname)
749{
750 if (!skip_prefix(refname, "worktrees/", &refname))
751 return 0;
752 refname = strchr(refname, '/');
753 if (!refname || !refname[1])
754 return 0;
755 return is_pseudoref_syntax(refname + 1);
756}
757
266b1827
DT
758enum ref_type ref_type(const char *refname)
759{
760 if (is_per_worktree_ref(refname))
761 return REF_TYPE_PER_WORKTREE;
762 if (is_pseudoref_syntax(refname))
763 return REF_TYPE_PSEUDOREF;
3a3b9d8c
NTND
764 if (is_main_pseudoref_syntax(refname))
765 return REF_TYPE_MAIN_PSEUDOREF;
766 if (is_other_pseudoref_syntax(refname))
767 return REF_TYPE_OTHER_PSEUDOREF;
5c79f74f 768 return REF_TYPE_NORMAL;
266b1827
DT
769}
770
4ff0f01c
MH
771long get_files_ref_lock_timeout_ms(void)
772{
773 static int configured = 0;
774
775 /* The default timeout is 100 ms: */
776 static int timeout_ms = 100;
777
778 if (!configured) {
779 git_config_get_int("core.filesreflocktimeout", &timeout_ms);
780 configured = 1;
781 }
782
783 return timeout_ms;
784}
785
ae077771 786static int write_pseudoref(const char *pseudoref, const struct object_id *oid,
787 const struct object_id *old_oid, struct strbuf *err)
74ec19d4
DT
788{
789 const char *filename;
790 int fd;
01084515 791 struct lock_file lock = LOCK_INIT;
74ec19d4
DT
792 struct strbuf buf = STRBUF_INIT;
793 int ret = -1;
794
6ee18216 795 if (!oid)
796 return 0;
797
ae077771 798 strbuf_addf(&buf, "%s\n", oid_to_hex(oid));
74ec19d4
DT
799
800 filename = git_path("%s", pseudoref);
01084515 801 fd = hold_lock_file_for_update_timeout(&lock, filename, 0,
4ff0f01c 802 get_files_ref_lock_timeout_ms());
74ec19d4 803 if (fd < 0) {
661558f0 804 strbuf_addf(err, _("could not open '%s' for writing: %s"),
74ec19d4 805 filename, strerror(errno));
aeb014f6 806 goto done;
74ec19d4
DT
807 }
808
ae077771 809 if (old_oid) {
810 struct object_id actual_old_oid;
2c3aed13 811
db0210d4
812 if (read_ref(pseudoref, &actual_old_oid)) {
813 if (!is_null_oid(old_oid)) {
661558f0 814 strbuf_addf(err, _("could not read ref '%s'"),
db0210d4
815 pseudoref);
816 rollback_lock_file(&lock);
817 goto done;
818 }
819 } else if (is_null_oid(old_oid)) {
661558f0 820 strbuf_addf(err, _("ref '%s' already exists"),
db0210d4
821 pseudoref);
822 rollback_lock_file(&lock);
823 goto done;
9001dc2a 824 } else if (!oideq(&actual_old_oid, old_oid)) {
661558f0 825 strbuf_addf(err, _("unexpected object ID when writing '%s'"),
c0bdd658 826 pseudoref);
74ec19d4
DT
827 rollback_lock_file(&lock);
828 goto done;
829 }
830 }
831
06f46f23 832 if (write_in_full(fd, buf.buf, buf.len) < 0) {
661558f0 833 strbuf_addf(err, _("could not write to '%s'"), filename);
74ec19d4
DT
834 rollback_lock_file(&lock);
835 goto done;
836 }
837
838 commit_lock_file(&lock);
839 ret = 0;
840done:
841 strbuf_release(&buf);
842 return ret;
843}
844
2616a5e5 845static int delete_pseudoref(const char *pseudoref, const struct object_id *old_oid)
74ec19d4 846{
74ec19d4
DT
847 const char *filename;
848
849 filename = git_path("%s", pseudoref);
850
2616a5e5 851 if (old_oid && !is_null_oid(old_oid)) {
3c6fad4a 852 struct lock_file lock = LOCK_INIT;
74ec19d4 853 int fd;
2616a5e5 854 struct object_id actual_old_oid;
74ec19d4 855
4ff0f01c 856 fd = hold_lock_file_for_update_timeout(
3c6fad4a 857 &lock, filename, 0,
4ff0f01c 858 get_files_ref_lock_timeout_ms());
3c6fad4a
859 if (fd < 0) {
860 error_errno(_("could not open '%s' for writing"),
861 filename);
862 return -1;
863 }
34c290a6 864 if (read_ref(pseudoref, &actual_old_oid))
661558f0 865 die(_("could not read ref '%s'"), pseudoref);
9001dc2a 866 if (!oideq(&actual_old_oid, old_oid)) {
661558f0 867 error(_("unexpected object ID when deleting '%s'"),
c0bdd658 868 pseudoref);
74ec19d4
DT
869 rollback_lock_file(&lock);
870 return -1;
a4c653df 871 }
74ec19d4
DT
872
873 unlink(filename);
874 rollback_lock_file(&lock);
875 } else {
876 unlink(filename);
4bd18c43 877 }
a4c653df 878
4bd18c43 879 return 0;
95fc7512 880}
d556fae2 881
c0fe4e8b
NTND
882int refs_delete_ref(struct ref_store *refs, const char *msg,
883 const char *refname,
2616a5e5 884 const struct object_id *old_oid,
c0fe4e8b 885 unsigned int flags)
41b625b0 886{
7521cc46 887 struct ref_transaction *transaction;
a4c653df 888 struct strbuf err = STRBUF_INIT;
8b5157e4 889
c0fe4e8b 890 if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
23a3f0cb 891 assert(refs == get_main_ref_store(the_repository));
2616a5e5 892 return delete_pseudoref(refname, old_oid);
c0fe4e8b 893 }
d48744d1 894
c0fe4e8b 895 transaction = ref_store_transaction_begin(refs, &err);
7521cc46 896 if (!transaction ||
89f3bbdd 897 ref_transaction_delete(transaction, refname, old_oid,
755b49ae 898 flags, msg, &err) ||
db7516ab 899 ref_transaction_commit(transaction, &err)) {
7521cc46
RS
900 error("%s", err.buf);
901 ref_transaction_free(transaction);
902 strbuf_release(&err);
c0277d15 903 return 1;
41b625b0 904 }
7bd9bcf3
MH
905 ref_transaction_free(transaction);
906 strbuf_release(&err);
b531394d
BC
907 return 0;
908}
41b625b0 909
c0fe4e8b 910int delete_ref(const char *msg, const char *refname,
2616a5e5 911 const struct object_id *old_oid, unsigned int flags)
c0fe4e8b 912{
23a3f0cb 913 return refs_delete_ref(get_main_ref_store(the_repository), msg, refname,
2616a5e5 914 old_oid, flags);
c0fe4e8b
NTND
915}
916
80a6c207 917void copy_reflog_msg(struct strbuf *sb, const char *msg)
0ec29a47 918{
0ec29a47
JH
919 char c;
920 int wasspace = 1;
8b5157e4 921
80a6c207 922 strbuf_addch(sb, '\t');
0ec29a47
JH
923 while ((c = *msg++)) {
924 if (wasspace && isspace(c))
925 continue;
926 wasspace = isspace(c);
927 if (wasspace)
928 c = ' ';
80a6c207 929 strbuf_addch(sb, c);
a4c653df 930 }
80a6c207 931 strbuf_rtrim(sb);
0ec29a47 932}
8b5157e4 933
4cb77009 934int should_autocreate_reflog(const char *refname)
4e2bef57 935{
341fb286
CW
936 switch (log_all_ref_updates) {
937 case LOG_REFS_ALWAYS:
938 return 1;
939 case LOG_REFS_NORMAL:
940 return starts_with(refname, "refs/heads/") ||
941 starts_with(refname, "refs/remotes/") ||
942 starts_with(refname, "refs/notes/") ||
943 !strcmp(refname, "HEAD");
944 default:
4e2bef57 945 return 0;
341fb286 946 }
4e2bef57
DT
947}
948
e7e0f26e 949int is_branch(const char *refname)
c3b0dec5 950{
59556548 951 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
41b625b0
NP
952}
953
4207ed28
RS
954struct read_ref_at_cb {
955 const char *refname;
dddbad72 956 timestamp_t at_time;
4207ed28
RS
957 int cnt;
958 int reccnt;
8eb36d94 959 struct object_id *oid;
4207ed28
RS
960 int found_it;
961
8eb36d94 962 struct object_id ooid;
963 struct object_id noid;
4207ed28 964 int tz;
dddbad72 965 timestamp_t date;
4207ed28 966 char **msg;
dddbad72 967 timestamp_t *cutoff_time;
4207ed28
RS
968 int *cutoff_tz;
969 int *cutoff_cnt;
970};
971
9461d272 972static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
dddbad72 973 const char *email, timestamp_t timestamp, int tz,
4207ed28
RS
974 const char *message, void *cb_data)
975{
976 struct read_ref_at_cb *cb = cb_data;
977
978 cb->reccnt++;
979 cb->tz = tz;
980 cb->date = timestamp;
981
982 if (timestamp <= cb->at_time || cb->cnt == 0) {
983 if (cb->msg)
984 *cb->msg = xstrdup(message);
985 if (cb->cutoff_time)
986 *cb->cutoff_time = timestamp;
987 if (cb->cutoff_tz)
988 *cb->cutoff_tz = tz;
989 if (cb->cutoff_cnt)
990 *cb->cutoff_cnt = cb->reccnt - 1;
991 /*
78fb4579 992 * we have not yet updated cb->[n|o]oid so they still
4207ed28
RS
993 * hold the values for the previous record.
994 */
8eb36d94 995 if (!is_null_oid(&cb->ooid)) {
996 oidcpy(cb->oid, noid);
9001dc2a 997 if (!oideq(&cb->ooid, noid))
661558f0 998 warning(_("log for ref %s has gap after %s"),
a5481a6c 999 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
4207ed28
RS
1000 }
1001 else if (cb->date == cb->at_time)
8eb36d94 1002 oidcpy(cb->oid, noid);
9001dc2a 1003 else if (!oideq(noid, cb->oid))
661558f0 1004 warning(_("log for ref %s unexpectedly ended on %s"),
4207ed28 1005 cb->refname, show_date(cb->date, cb->tz,
a5481a6c 1006 DATE_MODE(RFC2822)));
8eb36d94 1007 oidcpy(&cb->ooid, ooid);
1008 oidcpy(&cb->noid, noid);
4207ed28
RS
1009 cb->found_it = 1;
1010 return 1;
1011 }
8eb36d94 1012 oidcpy(&cb->ooid, ooid);
1013 oidcpy(&cb->noid, noid);
4207ed28
RS
1014 if (cb->cnt > 0)
1015 cb->cnt--;
1016 return 0;
1017}
1018
9461d272 1019static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
dddbad72 1020 const char *email, timestamp_t timestamp,
4207ed28
RS
1021 int tz, const char *message, void *cb_data)
1022{
1023 struct read_ref_at_cb *cb = cb_data;
1024
1025 if (cb->msg)
1026 *cb->msg = xstrdup(message);
1027 if (cb->cutoff_time)
1028 *cb->cutoff_time = timestamp;
1029 if (cb->cutoff_tz)
1030 *cb->cutoff_tz = tz;
1031 if (cb->cutoff_cnt)
1032 *cb->cutoff_cnt = cb->reccnt;
8eb36d94 1033 oidcpy(cb->oid, ooid);
1034 if (is_null_oid(cb->oid))
1035 oidcpy(cb->oid, noid);
4207ed28
RS
1036 /* We just want the first entry */
1037 return 1;
16d7cc90
JH
1038}
1039
7fdff474
NTND
1040int read_ref_at(struct ref_store *refs, const char *refname,
1041 unsigned int flags, timestamp_t at_time, int cnt,
8eb36d94 1042 struct object_id *oid, char **msg,
dddbad72 1043 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
d556fae2 1044{
4207ed28 1045 struct read_ref_at_cb cb;
d556fae2 1046
4207ed28
RS
1047 memset(&cb, 0, sizeof(cb));
1048 cb.refname = refname;
1049 cb.at_time = at_time;
1050 cb.cnt = cnt;
1051 cb.msg = msg;
1052 cb.cutoff_time = cutoff_time;
1053 cb.cutoff_tz = cutoff_tz;
1054 cb.cutoff_cnt = cutoff_cnt;
8eb36d94 1055 cb.oid = oid;
4207ed28 1056
7fdff474 1057 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
4207ed28 1058
c41a87dd 1059 if (!cb.reccnt) {
321c89bf 1060 if (flags & GET_OID_QUIETLY)
c41a87dd
DA
1061 exit(128);
1062 else
661558f0 1063 die(_("log for %s is empty"), refname);
c41a87dd 1064 }
4207ed28
RS
1065 if (cb.found_it)
1066 return 0;
1067
7fdff474 1068 refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
d556fae2 1069
16d7cc90 1070 return 1;
d556fae2 1071}
2ff81662 1072
c0fe4e8b
NTND
1073struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
1074 struct strbuf *err)
caa4046c 1075{
c0fe4e8b 1076 struct ref_transaction *tr;
5a603b04
JN
1077 assert(err);
1078
c0fe4e8b
NTND
1079 tr = xcalloc(1, sizeof(struct ref_transaction));
1080 tr->ref_store = refs;
1081 return tr;
1082}
1083
1084struct ref_transaction *ref_transaction_begin(struct strbuf *err)
1085{
23a3f0cb 1086 return ref_store_transaction_begin(get_main_ref_store(the_repository), err);
caa4046c
MH
1087}
1088
026bd1d3 1089void ref_transaction_free(struct ref_transaction *transaction)
caa4046c 1090{
43a2dfde 1091 size_t i;
caa4046c 1092
1b07255c
RS
1093 if (!transaction)
1094 return;
1095
30173b88
MH
1096 switch (transaction->state) {
1097 case REF_TRANSACTION_OPEN:
1098 case REF_TRANSACTION_CLOSED:
1099 /* OK */
1100 break;
1101 case REF_TRANSACTION_PREPARED:
033abf97 1102 BUG("free called on a prepared reference transaction");
30173b88
MH
1103 break;
1104 default:
033abf97 1105 BUG("unexpected reference transaction state");
30173b88
MH
1106 break;
1107 }
1108
db7516ab
RS
1109 for (i = 0; i < transaction->nr; i++) {
1110 free(transaction->updates[i]->msg);
88615910 1111 free(transaction->updates[i]);
db7516ab 1112 }
caa4046c
MH
1113 free(transaction->updates);
1114 free(transaction);
1115}
1116
71564516
MH
1117struct ref_update *ref_transaction_add_update(
1118 struct ref_transaction *transaction,
1119 const char *refname, unsigned int flags,
89f3bbdd 1120 const struct object_id *new_oid,
1121 const struct object_id *old_oid,
71564516 1122 const char *msg)
caa4046c 1123{
96ffc06f 1124 struct ref_update *update;
71564516
MH
1125
1126 if (transaction->state != REF_TRANSACTION_OPEN)
033abf97 1127 BUG("update called for transaction that is not open");
71564516 1128
96ffc06f 1129 FLEX_ALLOC_STR(update, refname, refname);
caa4046c
MH
1130 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
1131 transaction->updates[transaction->nr++] = update;
71564516
MH
1132
1133 update->flags = flags;
1134
1135 if (flags & REF_HAVE_NEW)
89f3bbdd 1136 oidcpy(&update->new_oid, new_oid);
71564516 1137 if (flags & REF_HAVE_OLD)
89f3bbdd 1138 oidcpy(&update->old_oid, old_oid);
13092a91 1139 update->msg = xstrdup_or_null(msg);
caa4046c
MH
1140 return update;
1141}
1142
8e34800e
RS
1143int ref_transaction_update(struct ref_transaction *transaction,
1144 const char *refname,
89f3bbdd 1145 const struct object_id *new_oid,
1146 const struct object_id *old_oid,
1d147bdf 1147 unsigned int flags, const char *msg,
8e34800e 1148 struct strbuf *err)
caa4046c 1149{
5a603b04
JN
1150 assert(err);
1151
89f3bbdd 1152 if ((new_oid && !is_null_oid(new_oid)) ?
8a679de6
MH
1153 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
1154 !refname_is_safe(refname)) {
661558f0 1155 strbuf_addf(err, _("refusing to update ref with bad name '%s'"),
d0f810f0
RS
1156 refname);
1157 return -1;
1158 }
1159
a9bbbcec
MH
1160 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
1161 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
c788c54c 1162
89f3bbdd 1163 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
71564516
MH
1164
1165 ref_transaction_add_update(transaction, refname, flags,
89f3bbdd 1166 new_oid, old_oid, msg);
8e34800e 1167 return 0;
caa4046c
MH
1168}
1169
b416af5b
RS
1170int ref_transaction_create(struct ref_transaction *transaction,
1171 const char *refname,
89f3bbdd 1172 const struct object_id *new_oid,
fec14ec3 1173 unsigned int flags, const char *msg,
b416af5b 1174 struct strbuf *err)
caa4046c 1175{
89f3bbdd 1176 if (!new_oid || is_null_oid(new_oid))
033abf97 1177 BUG("create called without valid new_oid");
89f3bbdd 1178 return ref_transaction_update(transaction, refname, new_oid,
1179 &null_oid, flags, msg, err);
caa4046c
MH
1180}
1181
8c8bdc0d
RS
1182int ref_transaction_delete(struct ref_transaction *transaction,
1183 const char *refname,
89f3bbdd 1184 const struct object_id *old_oid,
fb5a6bb6 1185 unsigned int flags, const char *msg,
8c8bdc0d 1186 struct strbuf *err)
caa4046c 1187{
89f3bbdd 1188 if (old_oid && is_null_oid(old_oid))
033abf97 1189 BUG("delete called with old_oid set to zeros");
1d147bdf 1190 return ref_transaction_update(transaction, refname,
89f3bbdd 1191 &null_oid, old_oid,
1d147bdf 1192 flags, msg, err);
caa4046c
MH
1193}
1194
16180334
MH
1195int ref_transaction_verify(struct ref_transaction *transaction,
1196 const char *refname,
89f3bbdd 1197 const struct object_id *old_oid,
16180334
MH
1198 unsigned int flags,
1199 struct strbuf *err)
1200{
89f3bbdd 1201 if (!old_oid)
033abf97 1202 BUG("verify called with old_oid set to NULL");
16180334 1203 return ref_transaction_update(transaction, refname,
89f3bbdd 1204 NULL, old_oid,
16180334
MH
1205 flags, NULL, err);
1206}
1207
c0fe4e8b 1208int refs_update_ref(struct ref_store *refs, const char *msg,
ae077771 1209 const char *refname, const struct object_id *new_oid,
1210 const struct object_id *old_oid, unsigned int flags,
c0fe4e8b 1211 enum action_on_err onerr)
4738a333 1212{
74ec19d4 1213 struct ref_transaction *t = NULL;
b4d75ac1 1214 struct strbuf err = STRBUF_INIT;
74ec19d4 1215 int ret = 0;
b4d75ac1 1216
74ec19d4 1217 if (ref_type(refname) == REF_TYPE_PSEUDOREF) {
23a3f0cb 1218 assert(refs == get_main_ref_store(the_repository));
ae077771 1219 ret = write_pseudoref(refname, new_oid, old_oid, &err);
74ec19d4 1220 } else {
c0fe4e8b 1221 t = ref_store_transaction_begin(refs, &err);
74ec19d4 1222 if (!t ||
89f3bbdd 1223 ref_transaction_update(t, refname, new_oid, old_oid,
74ec19d4
DT
1224 flags, msg, &err) ||
1225 ref_transaction_commit(t, &err)) {
1226 ret = 1;
1227 ref_transaction_free(t);
1228 }
1229 }
1230 if (ret) {
661558f0 1231 const char *str = _("update_ref failed for ref '%s': %s");
b4d75ac1 1232
b4d75ac1
RS
1233 switch (onerr) {
1234 case UPDATE_REFS_MSG_ON_ERR:
1235 error(str, refname, err.buf);
1236 break;
1237 case UPDATE_REFS_DIE_ON_ERR:
1238 die(str, refname, err.buf);
1239 break;
1240 case UPDATE_REFS_QUIET_ON_ERR:
1241 break;
1242 }
1243 strbuf_release(&err);
4738a333 1244 return 1;
b4d75ac1
RS
1245 }
1246 strbuf_release(&err);
74ec19d4
DT
1247 if (t)
1248 ref_transaction_free(t);
b4d75ac1 1249 return 0;
4738a333
BK
1250}
1251
c0fe4e8b 1252int update_ref(const char *msg, const char *refname,
ae077771 1253 const struct object_id *new_oid,
1254 const struct object_id *old_oid,
c0fe4e8b
NTND
1255 unsigned int flags, enum action_on_err onerr)
1256{
23a3f0cb 1257 return refs_update_ref(get_main_ref_store(the_repository), msg, refname, new_oid,
ae077771 1258 old_oid, flags, onerr);
c0fe4e8b
NTND
1259}
1260
546edf37
NTND
1261char *refs_shorten_unambiguous_ref(struct ref_store *refs,
1262 const char *refname, int strict)
7c2b3029
JK
1263{
1264 int i;
1265 static char **scanf_fmts;
1266 static int nr_rules;
1267 char *short_name;
6cd4a898 1268 struct strbuf resolved_buf = STRBUF_INIT;
7c2b3029 1269
7c2b3029 1270 if (!nr_rules) {
4346663a
MH
1271 /*
1272 * Pre-generate scanf formats from ref_rev_parse_rules[].
1273 * Generate a format suitable for scanf from a
1274 * ref_rev_parse_rules rule by interpolating "%s" at the
1275 * location of the "%.*s".
1276 */
7c2b3029 1277 size_t total_len = 0;
84d5633f 1278 size_t offset = 0;
7c2b3029
JK
1279
1280 /* the rule list is NULL terminated, count them first */
a4165851 1281 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
7902fe03
MH
1282 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1283 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
7c2b3029 1284
50492f7b 1285 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
7c2b3029 1286
84d5633f 1287 offset = 0;
7c2b3029 1288 for (i = 0; i < nr_rules; i++) {
4346663a 1289 assert(offset < total_len);
84d5633f 1290 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
bf4baf1f
JK
1291 offset += xsnprintf(scanf_fmts[i], total_len - offset,
1292 ref_rev_parse_rules[i], 2, "%s") + 1;
7c2b3029
JK
1293 }
1294 }
1295
1296 /* bail out if there are no rules */
1297 if (!nr_rules)
dfefa935 1298 return xstrdup(refname);
7c2b3029 1299
dfefa935
MH
1300 /* buffer for scanf result, at most refname must fit */
1301 short_name = xstrdup(refname);
7c2b3029
JK
1302
1303 /* skip first rule, it will always match */
1304 for (i = nr_rules - 1; i > 0 ; --i) {
1305 int j;
6e7b3309 1306 int rules_to_fail = i;
7c2b3029
JK
1307 int short_name_len;
1308
dfefa935 1309 if (1 != sscanf(refname, scanf_fmts[i], short_name))
7c2b3029
JK
1310 continue;
1311
1312 short_name_len = strlen(short_name);
1313
6e7b3309
BW
1314 /*
1315 * in strict mode, all (except the matched one) rules
1316 * must fail to resolve to a valid non-ambiguous ref
1317 */
1318 if (strict)
1319 rules_to_fail = nr_rules;
1320
7c2b3029
JK
1321 /*
1322 * check if the short name resolves to a valid ref,
1323 * but use only rules prior to the matched one
1324 */
6e7b3309 1325 for (j = 0; j < rules_to_fail; j++) {
7c2b3029 1326 const char *rule = ref_rev_parse_rules[j];
7c2b3029 1327
6e7b3309
BW
1328 /* skip matched rule */
1329 if (i == j)
1330 continue;
1331
7c2b3029
JK
1332 /*
1333 * the short name is ambiguous, if it resolves
1334 * (with this previous rule) to a valid ref
1335 * read_ref() returns 0 on success
1336 */
6cd4a898
JK
1337 strbuf_reset(&resolved_buf);
1338 strbuf_addf(&resolved_buf, rule,
1339 short_name_len, short_name);
546edf37 1340 if (refs_ref_exists(refs, resolved_buf.buf))
7c2b3029
JK
1341 break;
1342 }
1343
1344 /*
1345 * short name is non-ambiguous if all previous rules
1346 * haven't resolved to a valid ref
1347 */
6cd4a898
JK
1348 if (j == rules_to_fail) {
1349 strbuf_release(&resolved_buf);
7c2b3029 1350 return short_name;
6cd4a898 1351 }
7c2b3029
JK
1352 }
1353
6cd4a898 1354 strbuf_release(&resolved_buf);
7c2b3029 1355 free(short_name);
dfefa935 1356 return xstrdup(refname);
7c2b3029 1357}
daebaa78 1358
546edf37
NTND
1359char *shorten_unambiguous_ref(const char *refname, int strict)
1360{
1361 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
1362 refname, strict);
1363}
1364
daebaa78
JH
1365static struct string_list *hide_refs;
1366
1367int parse_hide_refs_config(const char *var, const char *value, const char *section)
1368{
ad8c7cda 1369 const char *key;
daebaa78 1370 if (!strcmp("transfer.hiderefs", var) ||
ad8c7cda
JK
1371 (!parse_config_key(var, section, NULL, NULL, &key) &&
1372 !strcmp(key, "hiderefs"))) {
daebaa78
JH
1373 char *ref;
1374 int len;
1375
1376 if (!value)
1377 return config_error_nonbool(var);
1378 ref = xstrdup(value);
1379 len = strlen(ref);
1380 while (len && ref[len - 1] == '/')
1381 ref[--len] = '\0';
1382 if (!hide_refs) {
1383 hide_refs = xcalloc(1, sizeof(*hide_refs));
1384 hide_refs->strdup_strings = 1;
1385 }
1386 string_list_append(hide_refs, ref);
1387 }
1388 return 0;
1389}
1390
78a766ab 1391int ref_is_hidden(const char *refname, const char *refname_full)
daebaa78 1392{
2bc31d16 1393 int i;
daebaa78
JH
1394
1395 if (!hide_refs)
1396 return 0;
2bc31d16
JK
1397 for (i = hide_refs->nr - 1; i >= 0; i--) {
1398 const char *match = hide_refs->items[i].string;
78a766ab 1399 const char *subject;
2bc31d16 1400 int neg = 0;
7a40a95e 1401 const char *p;
2bc31d16
JK
1402
1403 if (*match == '!') {
1404 neg = 1;
1405 match++;
1406 }
1407
78a766ab
LF
1408 if (*match == '^') {
1409 subject = refname_full;
1410 match++;
1411 } else {
1412 subject = refname;
1413 }
1414
1415 /* refname can be NULL when namespaces are used. */
7a40a95e
CC
1416 if (subject &&
1417 skip_prefix(subject, match, &p) &&
1418 (!*p || *p == '/'))
2bc31d16 1419 return !neg;
daebaa78
JH
1420 }
1421 return 0;
1422}
fa5b1830 1423
0845122c
DT
1424const char *find_descendant_ref(const char *dirname,
1425 const struct string_list *extras,
1426 const struct string_list *skip)
fa5b1830 1427{
0845122c 1428 int pos;
fa5b1830 1429
0845122c
DT
1430 if (!extras)
1431 return NULL;
fa5b1830
MH
1432
1433 /*
0845122c
DT
1434 * Look at the place where dirname would be inserted into
1435 * extras. If there is an entry at that position that starts
1436 * with dirname (remember, dirname includes the trailing
1437 * slash) and is not in skip, then we have a conflict.
fa5b1830 1438 */
0845122c
DT
1439 for (pos = string_list_find_insert_index(extras, dirname, 0);
1440 pos < extras->nr; pos++) {
1441 const char *extra_refname = extras->items[pos].string;
fa5b1830 1442
0845122c
DT
1443 if (!starts_with(extra_refname, dirname))
1444 break;
1445
1446 if (!skip || !string_list_has_string(skip, extra_refname))
1447 return extra_refname;
fa5b1830 1448 }
0845122c
DT
1449 return NULL;
1450}
fa5b1830 1451
7d2df051
NTND
1452int refs_rename_ref_available(struct ref_store *refs,
1453 const char *old_refname,
1454 const char *new_refname)
0845122c
DT
1455{
1456 struct string_list skip = STRING_LIST_INIT_NODUP;
1457 struct strbuf err = STRBUF_INIT;
ff3a299c 1458 int ok;
fa5b1830 1459
ff3a299c 1460 string_list_insert(&skip, old_refname);
7d2df051
NTND
1461 ok = !refs_verify_refname_available(refs, new_refname,
1462 NULL, &skip, &err);
ff3a299c 1463 if (!ok)
0845122c
DT
1464 error("%s", err.buf);
1465
1466 string_list_clear(&skip, 0);
1467 strbuf_release(&err);
ff3a299c 1468 return ok;
fa5b1830 1469}
2bf68ed5 1470
62f0b399 1471int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2bf68ed5
DT
1472{
1473 struct object_id oid;
1474 int flag;
1475
62f0b399 1476 if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING,
34c290a6 1477 &oid, &flag))
2bf68ed5
DT
1478 return fn("HEAD", &oid, flag, cb_data);
1479
1480 return 0;
1481}
1482
1483int head_ref(each_ref_fn fn, void *cb_data)
1484{
23a3f0cb 1485 return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
2bf68ed5 1486}
93770590 1487
e121b9cb
MH
1488struct ref_iterator *refs_ref_iterator_begin(
1489 struct ref_store *refs,
1490 const char *prefix, int trim, int flags)
1491{
1492 struct ref_iterator *iter;
1493
0a0865b8
MH
1494 if (ref_paranoia < 0)
1495 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);
1496 if (ref_paranoia)
1497 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1498
e121b9cb 1499 iter = refs->be->iterator_begin(refs, prefix, flags);
c7599718
MH
1500
1501 /*
1502 * `iterator_begin()` already takes care of prefix, but we
1503 * might need to do some trimming:
1504 */
1505 if (trim)
1506 iter = prefix_ref_iterator_begin(iter, "", trim);
e121b9cb 1507
8738a8a4
MH
1508 /* Sanity check for subclasses: */
1509 if (!iter->ordered)
1510 BUG("reference iterator is not ordered");
1511
e121b9cb
MH
1512 return iter;
1513}
1514
4c4de895
MH
1515/*
1516 * Call fn for each reference in the specified submodule for which the
1517 * refname begins with prefix. If trim is non-zero, then trim that
1518 * many characters off the beginning of each refname before passing
1519 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1520 * include broken references in the iteration. If fn ever returns a
1521 * non-zero value, stop the iteration and return that value;
1522 * otherwise, return 0.
1523 */
4a6067cd
SB
1524static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1525 each_repo_ref_fn fn, int trim, int flags,
1526 void *cb_data)
1527{
1528 struct ref_iterator *iter;
1529 struct ref_store *refs = get_main_ref_store(r);
1530
1531 if (!refs)
1532 return 0;
1533
1534 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1535
1536 return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1537}
1538
1539struct do_for_each_ref_help {
1540 each_ref_fn *fn;
1541 void *cb_data;
1542};
1543
1544static int do_for_each_ref_helper(struct repository *r,
1545 const char *refname,
1546 const struct object_id *oid,
1547 int flags,
1548 void *cb_data)
1549{
1550 struct do_for_each_ref_help *hp = cb_data;
1551
1552 return hp->fn(refname, oid, flags, hp->cb_data);
1553}
1554
7d2df051 1555static int do_for_each_ref(struct ref_store *refs, const char *prefix,
4c4de895
MH
1556 each_ref_fn fn, int trim, int flags, void *cb_data)
1557{
1558 struct ref_iterator *iter;
4a6067cd 1559 struct do_for_each_ref_help hp = { fn, cb_data };
4c4de895 1560
00eebe35
MH
1561 if (!refs)
1562 return 0;
1563
e121b9cb 1564 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
4c4de895 1565
4a6067cd
SB
1566 return do_for_each_repo_ref_iterator(the_repository, iter,
1567 do_for_each_ref_helper, &hp);
4c4de895
MH
1568}
1569
7d2df051
NTND
1570int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1571{
1572 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1573}
1574
93770590
DT
1575int for_each_ref(each_ref_fn fn, void *cb_data)
1576{
23a3f0cb 1577 return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
93770590
DT
1578}
1579
7d2df051
NTND
1580int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1581 each_ref_fn fn, void *cb_data)
1582{
1583 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
93770590
DT
1584}
1585
1586int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1587{
23a3f0cb 1588 return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
93770590
DT
1589}
1590
1591int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
1592{
1593 unsigned int flag = 0;
1594
1595 if (broken)
1596 flag = DO_FOR_EACH_INCLUDE_BROKEN;
23a3f0cb 1597 return do_for_each_ref(get_main_ref_store(the_repository),
7d2df051 1598 prefix, fn, 0, flag, cb_data);
93770590
DT
1599}
1600
073cf63c
NTND
1601int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
1602 each_ref_fn fn, void *cb_data,
1603 unsigned int broken)
03df567f
MH
1604{
1605 unsigned int flag = 0;
1606
1607 if (broken)
1608 flag = DO_FOR_EACH_INCLUDE_BROKEN;
073cf63c 1609 return do_for_each_ref(refs, prefix, fn, 0, flag, cb_data);
03df567f
MH
1610}
1611
212e0f7e 1612int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
93770590 1613{
212e0f7e
SB
1614 return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1615 strlen(git_replace_ref_base),
1616 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
93770590
DT
1617}
1618
1619int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1620{
1621 struct strbuf buf = STRBUF_INIT;
1622 int ret;
1623 strbuf_addf(&buf, "%srefs/", get_git_namespace());
23a3f0cb 1624 ret = do_for_each_ref(get_main_ref_store(the_repository),
7d2df051 1625 buf.buf, fn, 0, 0, cb_data);
93770590
DT
1626 strbuf_release(&buf);
1627 return ret;
1628}
1629
7d2df051 1630int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
93770590 1631{
7d2df051 1632 return do_for_each_ref(refs, "", fn, 0,
93770590
DT
1633 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1634}
2d0663b2 1635
7d2df051
NTND
1636int for_each_rawref(each_ref_fn fn, void *cb_data)
1637{
23a3f0cb 1638 return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
7d2df051
NTND
1639}
1640
470be518 1641int refs_read_raw_ref(struct ref_store *ref_store,
99afe91a 1642 const char *refname, struct object_id *oid,
470be518
MH
1643 struct strbuf *referent, unsigned int *type)
1644{
99afe91a 1645 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent, type);
470be518
MH
1646}
1647
2d0663b2 1648/* This function needs to return a meaningful errno on failure */
7d2df051 1649const char *refs_resolve_ref_unsafe(struct ref_store *refs,
3c0cb0cb
MH
1650 const char *refname,
1651 int resolve_flags,
49e61479 1652 struct object_id *oid, int *flags)
2d0663b2
DT
1653{
1654 static struct strbuf sb_refname = STRBUF_INIT;
54fad661 1655 struct object_id unused_oid;
2d0663b2
DT
1656 int unused_flags;
1657 int symref_count;
1658
49e61479 1659 if (!oid)
1660 oid = &unused_oid;
2d0663b2
DT
1661 if (!flags)
1662 flags = &unused_flags;
1663
1664 *flags = 0;
1665
1666 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1667 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1668 !refname_is_safe(refname)) {
1669 errno = EINVAL;
1670 return NULL;
1671 }
1672
1673 /*
1674 * dwim_ref() uses REF_ISBROKEN to distinguish between
1675 * missing refs and refs that were present but invalid,
1676 * to complain about the latter to stderr.
1677 *
1678 * We don't know whether the ref exists, so don't set
1679 * REF_ISBROKEN yet.
1680 */
1681 *flags |= REF_BAD_NAME;
1682 }
1683
1684 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1685 unsigned int read_flags = 0;
1686
470be518 1687 if (refs_read_raw_ref(refs, refname,
99afe91a 1688 oid, &sb_refname, &read_flags)) {
2d0663b2 1689 *flags |= read_flags;
a1c1d817
JK
1690
1691 /* In reading mode, refs must eventually resolve */
1692 if (resolve_flags & RESOLVE_REF_READING)
1693 return NULL;
1694
1695 /*
1696 * Otherwise a missing ref is OK. But the files backend
1697 * may show errors besides ENOENT if there are
1698 * similarly-named refs.
1699 */
1700 if (errno != ENOENT &&
1701 errno != EISDIR &&
1702 errno != ENOTDIR)
2d0663b2 1703 return NULL;
a1c1d817 1704
49e61479 1705 oidclr(oid);
2d0663b2
DT
1706 if (*flags & REF_BAD_NAME)
1707 *flags |= REF_ISBROKEN;
1708 return refname;
1709 }
1710
1711 *flags |= read_flags;
1712
1713 if (!(read_flags & REF_ISSYMREF)) {
1714 if (*flags & REF_BAD_NAME) {
49e61479 1715 oidclr(oid);
2d0663b2
DT
1716 *flags |= REF_ISBROKEN;
1717 }
1718 return refname;
1719 }
1720
1721 refname = sb_refname.buf;
1722 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
49e61479 1723 oidclr(oid);
2d0663b2
DT
1724 return refname;
1725 }
1726 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1727 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1728 !refname_is_safe(refname)) {
1729 errno = EINVAL;
1730 return NULL;
1731 }
1732
1733 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1734 }
1735 }
1736
1737 errno = ELOOP;
1738 return NULL;
1739}
00eebe35 1740
6fb5acfd
DT
1741/* backend functions */
1742int refs_init_db(struct strbuf *err)
1743{
23a3f0cb 1744 struct ref_store *refs = get_main_ref_store(the_repository);
6fb5acfd
DT
1745
1746 return refs->be->init_db(refs, err);
1747}
1748
bd40dcda 1749const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
49e61479 1750 struct object_id *oid, int *flags)
bd40dcda 1751{
23a3f0cb 1752 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
49e61479 1753 resolve_flags, oid, flags);
bd40dcda
MH
1754}
1755
a8355bb7 1756int resolve_gitlink_ref(const char *submodule, const char *refname,
a98e6101 1757 struct object_id *oid)
424dcc76 1758{
424dcc76
MH
1759 struct ref_store *refs;
1760 int flags;
1761
29babbee 1762 refs = get_submodule_ref_store(submodule);
48a8475f 1763
424dcc76
MH
1764 if (!refs)
1765 return -1;
1766
49e61479 1767 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
a98e6101 1768 is_null_oid(oid))
424dcc76
MH
1769 return -1;
1770 return 0;
1771}
1772
0c064d90 1773struct ref_store_hash_entry
7d4558c4
MH
1774{
1775 struct hashmap_entry ent; /* must be the first member! */
1776
1777 struct ref_store *refs;
1778
0c064d90
NTND
1779 /* NUL-terminated identifier of the ref store: */
1780 char name[FLEX_ARRAY];
7d4558c4
MH
1781};
1782
7663cdc8
SB
1783static int ref_store_hash_cmp(const void *unused_cmp_data,
1784 const void *entry, const void *entry_or_key,
7d4558c4
MH
1785 const void *keydata)
1786{
0c064d90
NTND
1787 const struct ref_store_hash_entry *e1 = entry, *e2 = entry_or_key;
1788 const char *name = keydata ? keydata : e2->name;
7d4558c4 1789
0c064d90 1790 return strcmp(e1->name, name);
7d4558c4
MH
1791}
1792
0c064d90
NTND
1793static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1794 const char *name, struct ref_store *refs)
7d4558c4 1795{
0c064d90 1796 struct ref_store_hash_entry *entry;
7d4558c4 1797
0c064d90
NTND
1798 FLEX_ALLOC_STR(entry, name, name);
1799 hashmap_entry_init(entry, strhash(name));
7d4558c4
MH
1800 entry->refs = refs;
1801 return entry;
1802}
1803
7d4558c4
MH
1804/* A hashmap of ref_stores, stored by submodule name: */
1805static struct hashmap submodule_ref_stores;
00eebe35 1806
17eff96b
NTND
1807/* A hashmap of ref_stores, stored by worktree id: */
1808static struct hashmap worktree_ref_stores;
1809
c468da4e 1810/*
0c064d90
NTND
1811 * Look up a ref store by name. If that ref_store hasn't been
1812 * registered yet, return NULL.
c468da4e 1813 */
0c064d90
NTND
1814static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1815 const char *name)
00eebe35 1816{
0c064d90 1817 struct ref_store_hash_entry *entry;
00eebe35 1818
0c064d90 1819 if (!map->tablesize)
7d4558c4
MH
1820 /* It's initialized on demand in register_ref_store(). */
1821 return NULL;
620a66b9 1822
0c064d90 1823 entry = hashmap_get_from_hash(map, strhash(name), name);
7d4558c4 1824 return entry ? entry->refs : NULL;
00eebe35
MH
1825}
1826
c468da4e
MH
1827/*
1828 * Create, record, and return a ref_store instance for the specified
5d0bc90e 1829 * gitdir.
c468da4e 1830 */
9e7ec634
NTND
1831static struct ref_store *ref_store_init(const char *gitdir,
1832 unsigned int flags)
00eebe35
MH
1833{
1834 const char *be_name = "files";
1835 struct ref_storage_be *be = find_ref_storage_backend(be_name);
ba88add5 1836 struct ref_store *refs;
00eebe35
MH
1837
1838 if (!be)
033abf97 1839 BUG("reference backend %s is unknown", be_name);
00eebe35 1840
9e7ec634 1841 refs = be->init(gitdir, flags);
ba88add5 1842 return refs;
00eebe35
MH
1843}
1844
64a74161 1845struct ref_store *get_main_ref_store(struct repository *r)
24c8407e 1846{
64a74161
SB
1847 if (r->refs)
1848 return r->refs;
24c8407e 1849
2dc417ab
JK
1850 if (!r->gitdir)
1851 BUG("attempting to get main_ref_store outside of repository");
1852
64a74161
SB
1853 r->refs = ref_store_init(r->gitdir, REF_STORE_ALL_CAPS);
1854 return r->refs;
378dc910
NTND
1855}
1856
1857/*
0c064d90
NTND
1858 * Associate a ref store with a name. It is a fatal error to call this
1859 * function twice for the same name.
378dc910 1860 */
0c064d90
NTND
1861static void register_ref_store_map(struct hashmap *map,
1862 const char *type,
1863 struct ref_store *refs,
1864 const char *name)
378dc910 1865{
0c064d90 1866 if (!map->tablesize)
7663cdc8 1867 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
378dc910 1868
0c064d90 1869 if (hashmap_put(map, alloc_ref_store_hash_entry(name, refs)))
033abf97 1870 BUG("%s ref_store '%s' initialized twice", type, name);
24c8407e
NTND
1871}
1872
18d0002d 1873struct ref_store *get_submodule_ref_store(const char *submodule)
00eebe35 1874{
126c9e05 1875 struct strbuf submodule_sb = STRBUF_INIT;
00eebe35 1876 struct ref_store *refs;
29babbee
NTND
1877 char *to_free = NULL;
1878 size_t len;
00eebe35 1879
82a150f2
NTND
1880 if (!submodule)
1881 return NULL;
1882
873ea90d
NTND
1883 len = strlen(submodule);
1884 while (len && is_dir_sep(submodule[len - 1]))
1885 len--;
1886 if (!len)
1887 return NULL;
00eebe35 1888
29babbee
NTND
1889 if (submodule[len])
1890 /* We need to strip off one or more trailing slashes */
1891 submodule = to_free = xmemdupz(submodule, len);
00eebe35 1892
0c064d90 1893 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
126c9e05 1894 if (refs)
2c616c17 1895 goto done;
00eebe35 1896
126c9e05 1897 strbuf_addstr(&submodule_sb, submodule);
2c616c17
NTND
1898 if (!is_nonbare_repository_dir(&submodule_sb))
1899 goto done;
00eebe35 1900
2c616c17
NTND
1901 if (submodule_to_gitdir(&submodule_sb, submodule))
1902 goto done;
00eebe35 1903
9e7ec634
NTND
1904 /* assume that add_submodule_odb() has been called */
1905 refs = ref_store_init(submodule_sb.buf,
1906 REF_STORE_READ | REF_STORE_ODB);
0c064d90
NTND
1907 register_ref_store_map(&submodule_ref_stores, "submodule",
1908 refs, submodule);
5d0bc90e 1909
2c616c17 1910done:
5d0bc90e 1911 strbuf_release(&submodule_sb);
29babbee
NTND
1912 free(to_free);
1913
00eebe35
MH
1914 return refs;
1915}
1916
17eff96b
NTND
1917struct ref_store *get_worktree_ref_store(const struct worktree *wt)
1918{
1919 struct ref_store *refs;
1920 const char *id;
1921
1922 if (wt->is_current)
23a3f0cb 1923 return get_main_ref_store(the_repository);
17eff96b
NTND
1924
1925 id = wt->id ? wt->id : "/";
1926 refs = lookup_ref_store_map(&worktree_ref_stores, id);
1927 if (refs)
1928 return refs;
1929
1930 if (wt->id)
1931 refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
1932 REF_STORE_ALL_CAPS);
1933 else
1934 refs = ref_store_init(get_git_common_dir(),
1935 REF_STORE_ALL_CAPS);
1936
1937 if (refs)
1938 register_ref_store_map(&worktree_ref_stores, "worktree",
1939 refs, id);
1940 return refs;
1941}
1942
620a66b9 1943void base_ref_store_init(struct ref_store *refs,
fbfd0a29 1944 const struct ref_storage_be *be)
00eebe35 1945{
620a66b9 1946 refs->be = be;
00eebe35 1947}
127b42a1
RS
1948
1949/* backend functions */
7d2df051 1950int refs_pack_refs(struct ref_store *refs, unsigned int flags)
8231527e 1951{
8231527e
MH
1952 return refs->be->pack_refs(refs, flags);
1953}
1954
7d2df051 1955int refs_peel_ref(struct ref_store *refs, const char *refname,
b420d909 1956 struct object_id *oid)
7d2df051 1957{
ba1c052f 1958 int flag;
34c290a6 1959 struct object_id base;
ba1c052f
MH
1960
1961 if (current_ref_iter && current_ref_iter->refname == refname) {
1962 struct object_id peeled;
1963
1964 if (ref_iterator_peel(current_ref_iter, &peeled))
1965 return -1;
b420d909 1966 oidcpy(oid, &peeled);
ba1c052f
MH
1967 return 0;
1968 }
1969
1970 if (refs_read_ref_full(refs, refname,
34c290a6 1971 RESOLVE_REF_READING, &base, &flag))
ba1c052f
MH
1972 return -1;
1973
ac2ed0d7 1974 return peel_object(&base, oid);
8231527e
MH
1975}
1976
b420d909 1977int peel_ref(const char *refname, struct object_id *oid)
bd427cf2 1978{
23a3f0cb 1979 return refs_peel_ref(get_main_ref_store(the_repository), refname, oid);
7d2df051 1980}
bd427cf2 1981
7d2df051
NTND
1982int refs_create_symref(struct ref_store *refs,
1983 const char *ref_target,
1984 const char *refs_heads_master,
1985 const char *logmsg)
1986{
1987 return refs->be->create_symref(refs, ref_target,
1988 refs_heads_master,
1989 logmsg);
bd427cf2
MH
1990}
1991
284689ba
MH
1992int create_symref(const char *ref_target, const char *refs_heads_master,
1993 const char *logmsg)
1994{
23a3f0cb 1995 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
7d2df051 1996 refs_heads_master, logmsg);
284689ba
MH
1997}
1998
2ced105c
MH
1999int ref_update_reject_duplicates(struct string_list *refnames,
2000 struct strbuf *err)
2001{
a552e50e 2002 size_t i, n = refnames->nr;
2ced105c
MH
2003
2004 assert(err);
2005
8556f8d6
MH
2006 for (i = 1; i < n; i++) {
2007 int cmp = strcmp(refnames->items[i - 1].string,
2008 refnames->items[i].string);
2009
2010 if (!cmp) {
2ced105c 2011 strbuf_addf(err,
661558f0 2012 _("multiple updates for ref '%s' not allowed"),
2ced105c
MH
2013 refnames->items[i].string);
2014 return 1;
8556f8d6 2015 } else if (cmp > 0) {
033abf97 2016 BUG("ref_update_reject_duplicates() received unsorted list");
2ced105c 2017 }
8556f8d6 2018 }
2ced105c
MH
2019 return 0;
2020}
2021
30173b88
MH
2022int ref_transaction_prepare(struct ref_transaction *transaction,
2023 struct strbuf *err)
127b42a1 2024{
c0fe4e8b 2025 struct ref_store *refs = transaction->ref_store;
127b42a1 2026
8d4240d3
MH
2027 switch (transaction->state) {
2028 case REF_TRANSACTION_OPEN:
2029 /* Good. */
2030 break;
30173b88 2031 case REF_TRANSACTION_PREPARED:
033abf97 2032 BUG("prepare called twice on reference transaction");
30173b88 2033 break;
8d4240d3 2034 case REF_TRANSACTION_CLOSED:
033abf97 2035 BUG("prepare called on a closed reference transaction");
8d4240d3
MH
2036 break;
2037 default:
033abf97 2038 BUG("unexpected reference transaction state");
8d4240d3
MH
2039 break;
2040 }
2041
d8f4481c
JK
2042 if (getenv(GIT_QUARANTINE_ENVIRONMENT)) {
2043 strbuf_addstr(err,
2044 _("ref updates forbidden inside quarantine environment"));
2045 return -1;
2046 }
2047
30173b88
MH
2048 return refs->be->transaction_prepare(refs, transaction, err);
2049}
2050
2051int ref_transaction_abort(struct ref_transaction *transaction,
2052 struct strbuf *err)
2053{
2054 struct ref_store *refs = transaction->ref_store;
2055 int ret = 0;
2056
2057 switch (transaction->state) {
2058 case REF_TRANSACTION_OPEN:
2059 /* No need to abort explicitly. */
2060 break;
2061 case REF_TRANSACTION_PREPARED:
2062 ret = refs->be->transaction_abort(refs, transaction, err);
2063 break;
2064 case REF_TRANSACTION_CLOSED:
033abf97 2065 BUG("abort called on a closed reference transaction");
30173b88
MH
2066 break;
2067 default:
033abf97 2068 BUG("unexpected reference transaction state");
30173b88
MH
2069 break;
2070 }
2071
2072 ref_transaction_free(transaction);
2073 return ret;
2074}
2075
2076int ref_transaction_commit(struct ref_transaction *transaction,
2077 struct strbuf *err)
2078{
2079 struct ref_store *refs = transaction->ref_store;
2080 int ret;
2081
2082 switch (transaction->state) {
2083 case REF_TRANSACTION_OPEN:
2084 /* Need to prepare first. */
2085 ret = ref_transaction_prepare(transaction, err);
2086 if (ret)
2087 return ret;
2088 break;
2089 case REF_TRANSACTION_PREPARED:
2090 /* Fall through to finish. */
2091 break;
2092 case REF_TRANSACTION_CLOSED:
033abf97 2093 BUG("commit called on a closed reference transaction");
30173b88
MH
2094 break;
2095 default:
033abf97 2096 BUG("unexpected reference transaction state");
30173b88
MH
2097 break;
2098 }
2099
2100 return refs->be->transaction_finish(refs, transaction, err);
127b42a1 2101}
62665823 2102
7d2df051
NTND
2103int refs_verify_refname_available(struct ref_store *refs,
2104 const char *refname,
b05855b5 2105 const struct string_list *extras,
7d2df051
NTND
2106 const struct string_list *skip,
2107 struct strbuf *err)
62665823 2108{
b05855b5
MH
2109 const char *slash;
2110 const char *extra_refname;
2111 struct strbuf dirname = STRBUF_INIT;
2112 struct strbuf referent = STRBUF_INIT;
2113 struct object_id oid;
2114 unsigned int type;
2115 struct ref_iterator *iter;
2116 int ok;
2117 int ret = -1;
2118
2119 /*
2120 * For the sake of comments in this function, suppose that
2121 * refname is "refs/foo/bar".
2122 */
2123
2124 assert(err);
2125
2126 strbuf_grow(&dirname, strlen(refname) + 1);
2127 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
2128 /* Expand dirname to the new prefix, not including the trailing slash: */
2129 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2130
2131 /*
2132 * We are still at a leading dir of the refname (e.g.,
2133 * "refs/foo"; if there is a reference with that name,
2134 * it is a conflict, *unless* it is in skip.
2135 */
2136 if (skip && string_list_has_string(skip, dirname.buf))
2137 continue;
2138
99afe91a 2139 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) {
661558f0 2140 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
b05855b5
MH
2141 dirname.buf, refname);
2142 goto cleanup;
2143 }
2144
2145 if (extras && string_list_has_string(extras, dirname.buf)) {
661558f0 2146 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
b05855b5
MH
2147 refname, dirname.buf);
2148 goto cleanup;
2149 }
2150 }
2151
2152 /*
2153 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2154 * There is no point in searching for a reference with that
2155 * name, because a refname isn't considered to conflict with
2156 * itself. But we still need to check for references whose
2157 * names are in the "refs/foo/bar/" namespace, because they
2158 * *do* conflict.
2159 */
2160 strbuf_addstr(&dirname, refname + dirname.len);
2161 strbuf_addch(&dirname, '/');
2162
2163 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
2164 DO_FOR_EACH_INCLUDE_BROKEN);
2165 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2166 if (skip &&
2167 string_list_has_string(skip, iter->refname))
2168 continue;
2169
661558f0 2170 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
b05855b5
MH
2171 iter->refname, refname);
2172 ref_iterator_abort(iter);
2173 goto cleanup;
2174 }
2175
2176 if (ok != ITER_DONE)
033abf97 2177 BUG("error while iterating over references");
b05855b5
MH
2178
2179 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2180 if (extra_refname)
661558f0 2181 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
b05855b5
MH
2182 refname, extra_refname);
2183 else
2184 ret = 0;
2185
2186cleanup:
2187 strbuf_release(&referent);
2188 strbuf_release(&dirname);
2189 return ret;
62665823 2190}
e3688bd6 2191
7d2df051 2192int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
e3688bd6 2193{
e3688bd6 2194 struct ref_iterator *iter;
4a6067cd 2195 struct do_for_each_ref_help hp = { fn, cb_data };
e3688bd6
DT
2196
2197 iter = refs->be->reflog_iterator_begin(refs);
2198
4a6067cd
SB
2199 return do_for_each_repo_ref_iterator(the_repository, iter,
2200 do_for_each_ref_helper, &hp);
e3688bd6
DT
2201}
2202
7d2df051 2203int for_each_reflog(each_ref_fn fn, void *cb_data)
e3688bd6 2204{
23a3f0cb 2205 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
7d2df051 2206}
e3688bd6 2207
7d2df051
NTND
2208int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2209 const char *refname,
2210 each_reflog_ent_fn fn,
2211 void *cb_data)
2212{
e3688bd6
DT
2213 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2214 fn, cb_data);
2215}
2216
7d2df051
NTND
2217int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2218 void *cb_data)
2219{
23a3f0cb 2220 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
7d2df051
NTND
2221 refname, fn, cb_data);
2222}
2223
2224int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2225 each_reflog_ent_fn fn, void *cb_data)
2226{
2227 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2228}
2229
e3688bd6
DT
2230int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2231 void *cb_data)
2232{
23a3f0cb 2233 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
7d2df051
NTND
2234 fn, cb_data);
2235}
e3688bd6 2236
7d2df051
NTND
2237int refs_reflog_exists(struct ref_store *refs, const char *refname)
2238{
2239 return refs->be->reflog_exists(refs, refname);
e3688bd6
DT
2240}
2241
2242int reflog_exists(const char *refname)
2243{
23a3f0cb 2244 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
7d2df051 2245}
e3688bd6 2246
7d2df051
NTND
2247int refs_create_reflog(struct ref_store *refs, const char *refname,
2248 int force_create, struct strbuf *err)
2249{
2250 return refs->be->create_reflog(refs, refname, force_create, err);
e3688bd6
DT
2251}
2252
2253int safe_create_reflog(const char *refname, int force_create,
2254 struct strbuf *err)
2255{
23a3f0cb 2256 return refs_create_reflog(get_main_ref_store(the_repository), refname,
7d2df051
NTND
2257 force_create, err);
2258}
e3688bd6 2259
7d2df051
NTND
2260int refs_delete_reflog(struct ref_store *refs, const char *refname)
2261{
2262 return refs->be->delete_reflog(refs, refname);
e3688bd6
DT
2263}
2264
2265int delete_reflog(const char *refname)
2266{
23a3f0cb 2267 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
7d2df051 2268}
e3688bd6 2269
7d2df051 2270int refs_reflog_expire(struct ref_store *refs,
0155f710 2271 const char *refname, const struct object_id *oid,
7d2df051
NTND
2272 unsigned int flags,
2273 reflog_expiry_prepare_fn prepare_fn,
2274 reflog_expiry_should_prune_fn should_prune_fn,
2275 reflog_expiry_cleanup_fn cleanup_fn,
2276 void *policy_cb_data)
2277{
0155f710 2278 return refs->be->reflog_expire(refs, refname, oid, flags,
7d2df051
NTND
2279 prepare_fn, should_prune_fn,
2280 cleanup_fn, policy_cb_data);
e3688bd6
DT
2281}
2282
0155f710 2283int reflog_expire(const char *refname, const struct object_id *oid,
e3688bd6
DT
2284 unsigned int flags,
2285 reflog_expiry_prepare_fn prepare_fn,
2286 reflog_expiry_should_prune_fn should_prune_fn,
2287 reflog_expiry_cleanup_fn cleanup_fn,
2288 void *policy_cb_data)
2289{
23a3f0cb 2290 return refs_reflog_expire(get_main_ref_store(the_repository),
0155f710 2291 refname, oid, flags,
7d2df051
NTND
2292 prepare_fn, should_prune_fn,
2293 cleanup_fn, policy_cb_data);
e3688bd6 2294}
fc681463
DT
2295
2296int initial_ref_transaction_commit(struct ref_transaction *transaction,
2297 struct strbuf *err)
2298{
c0fe4e8b 2299 struct ref_store *refs = transaction->ref_store;
fc681463
DT
2300
2301 return refs->be->initial_transaction_commit(refs, transaction, err);
2302}
a27dcf89 2303
64da4199
MH
2304int refs_delete_refs(struct ref_store *refs, const char *msg,
2305 struct string_list *refnames, unsigned int flags)
a27dcf89 2306{
64da4199 2307 return refs->be->delete_refs(refs, msg, refnames, flags);
a27dcf89 2308}
9b6b40d9 2309
64da4199
MH
2310int delete_refs(const char *msg, struct string_list *refnames,
2311 unsigned int flags)
9b6b40d9 2312{
23a3f0cb 2313 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
7d2df051 2314}
9b6b40d9 2315
7d2df051
NTND
2316int refs_rename_ref(struct ref_store *refs, const char *oldref,
2317 const char *newref, const char *logmsg)
2318{
9b6b40d9
DT
2319 return refs->be->rename_ref(refs, oldref, newref, logmsg);
2320}
7d2df051
NTND
2321
2322int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2323{
23a3f0cb 2324 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
7d2df051 2325}
52d59cc6
SD
2326
2327int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2328 const char *newref, const char *logmsg)
2329{
2330 return refs->be->copy_ref(refs, oldref, newref, logmsg);
2331}
2332
2333int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2334{
23a3f0cb 2335 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
52d59cc6 2336}