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