]> git.ipfire.org Git - thirdparty/git.git/blame - refs.c
Merge branch 'jk/clone-allow-bare-and-o-together'
[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
266b1827
DT
814static int is_per_worktree_ref(const char *refname)
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
830 return 1;
831}
832
3a3b9d8c
NTND
833static int is_main_pseudoref_syntax(const char *refname)
834{
835 return skip_prefix(refname, "main-worktree/", &refname) &&
836 *refname &&
837 is_pseudoref_syntax(refname);
838}
839
840static int is_other_pseudoref_syntax(const char *refname)
841{
842 if (!skip_prefix(refname, "worktrees/", &refname))
843 return 0;
844 refname = strchr(refname, '/');
845 if (!refname || !refname[1])
846 return 0;
847 return is_pseudoref_syntax(refname + 1);
848}
849
266b1827
DT
850enum ref_type ref_type(const char *refname)
851{
852 if (is_per_worktree_ref(refname))
853 return REF_TYPE_PER_WORKTREE;
854 if (is_pseudoref_syntax(refname))
855 return REF_TYPE_PSEUDOREF;
3a3b9d8c
NTND
856 if (is_main_pseudoref_syntax(refname))
857 return REF_TYPE_MAIN_PSEUDOREF;
858 if (is_other_pseudoref_syntax(refname))
859 return REF_TYPE_OTHER_PSEUDOREF;
5c79f74f 860 return REF_TYPE_NORMAL;
266b1827
DT
861}
862
4ff0f01c
MH
863long get_files_ref_lock_timeout_ms(void)
864{
865 static int configured = 0;
866
867 /* The default timeout is 100 ms: */
868 static int timeout_ms = 100;
869
870 if (!configured) {
871 git_config_get_int("core.filesreflocktimeout", &timeout_ms);
872 configured = 1;
873 }
874
875 return timeout_ms;
876}
877
c0fe4e8b
NTND
878int refs_delete_ref(struct ref_store *refs, const char *msg,
879 const char *refname,
2616a5e5 880 const struct object_id *old_oid,
c0fe4e8b 881 unsigned int flags)
41b625b0 882{
7521cc46 883 struct ref_transaction *transaction;
a4c653df 884 struct strbuf err = STRBUF_INIT;
8b5157e4 885
c6da34a6 886 transaction = ref_store_transaction_begin(refs, &err);
7521cc46 887 if (!transaction ||
89f3bbdd 888 ref_transaction_delete(transaction, refname, old_oid,
755b49ae 889 flags, msg, &err) ||
db7516ab 890 ref_transaction_commit(transaction, &err)) {
7521cc46
RS
891 error("%s", err.buf);
892 ref_transaction_free(transaction);
893 strbuf_release(&err);
c0277d15 894 return 1;
41b625b0 895 }
7bd9bcf3
MH
896 ref_transaction_free(transaction);
897 strbuf_release(&err);
b531394d
BC
898 return 0;
899}
41b625b0 900
c0fe4e8b 901int delete_ref(const char *msg, const char *refname,
2616a5e5 902 const struct object_id *old_oid, unsigned int flags)
c0fe4e8b 903{
23a3f0cb 904 return refs_delete_ref(get_main_ref_store(the_repository), msg, refname,
2616a5e5 905 old_oid, flags);
c0fe4e8b
NTND
906}
907
523fa69c 908static void copy_reflog_msg(struct strbuf *sb, const char *msg)
0ec29a47 909{
0ec29a47
JH
910 char c;
911 int wasspace = 1;
8b5157e4 912
0ec29a47
JH
913 while ((c = *msg++)) {
914 if (wasspace && isspace(c))
915 continue;
916 wasspace = isspace(c);
917 if (wasspace)
918 c = ' ';
80a6c207 919 strbuf_addch(sb, c);
a4c653df 920 }
80a6c207 921 strbuf_rtrim(sb);
0ec29a47 922}
8b5157e4 923
523fa69c
JH
924static char *normalize_reflog_message(const char *msg)
925{
926 struct strbuf sb = STRBUF_INIT;
927
928 if (msg && *msg)
929 copy_reflog_msg(&sb, msg);
930 return strbuf_detach(&sb, NULL);
931}
932
4cb77009 933int should_autocreate_reflog(const char *refname)
4e2bef57 934{
341fb286
CW
935 switch (log_all_ref_updates) {
936 case LOG_REFS_ALWAYS:
937 return 1;
938 case LOG_REFS_NORMAL:
939 return starts_with(refname, "refs/heads/") ||
940 starts_with(refname, "refs/remotes/") ||
941 starts_with(refname, "refs/notes/") ||
942 !strcmp(refname, "HEAD");
943 default:
4e2bef57 944 return 0;
341fb286 945 }
4e2bef57
DT
946}
947
e7e0f26e 948int is_branch(const char *refname)
c3b0dec5 949{
59556548 950 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
41b625b0
NP
951}
952
4207ed28
RS
953struct read_ref_at_cb {
954 const char *refname;
dddbad72 955 timestamp_t at_time;
4207ed28
RS
956 int cnt;
957 int reccnt;
8eb36d94 958 struct object_id *oid;
4207ed28
RS
959 int found_it;
960
8eb36d94 961 struct object_id ooid;
962 struct object_id noid;
4207ed28 963 int tz;
dddbad72 964 timestamp_t date;
4207ed28 965 char **msg;
dddbad72 966 timestamp_t *cutoff_time;
4207ed28
RS
967 int *cutoff_tz;
968 int *cutoff_cnt;
969};
970
95c2a718
DL
971static void set_read_ref_cutoffs(struct read_ref_at_cb *cb,
972 timestamp_t timestamp, int tz, const char *message)
973{
974 if (cb->msg)
975 *cb->msg = xstrdup(message);
976 if (cb->cutoff_time)
977 *cb->cutoff_time = timestamp;
978 if (cb->cutoff_tz)
979 *cb->cutoff_tz = tz;
980 if (cb->cutoff_cnt)
981 *cb->cutoff_cnt = cb->reccnt;
982}
983
9461d272 984static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
5cf88fd8 985 const char *email UNUSED,
c006e9fa
JK
986 timestamp_t timestamp, int tz,
987 const char *message, void *cb_data)
4207ed28
RS
988{
989 struct read_ref_at_cb *cb = cb_data;
6436a202 990 int reached_count;
4207ed28 991
4207ed28
RS
992 cb->tz = tz;
993 cb->date = timestamp;
994
6436a202
DL
995 /*
996 * It is not possible for cb->cnt == 0 on the first iteration because
997 * that special case is handled in read_ref_at().
998 */
999 if (cb->cnt > 0)
1000 cb->cnt--;
1001 reached_count = cb->cnt == 0 && !is_null_oid(ooid);
1002 if (timestamp <= cb->at_time || reached_count) {
95c2a718 1003 set_read_ref_cutoffs(cb, timestamp, tz, message);
4207ed28 1004 /*
78fb4579 1005 * we have not yet updated cb->[n|o]oid so they still
4207ed28
RS
1006 * hold the values for the previous record.
1007 */
6436a202
DL
1008 if (!is_null_oid(&cb->ooid) && !oideq(&cb->ooid, noid))
1009 warning(_("log for ref %s has gap after %s"),
a5481a6c 1010 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
6436a202
DL
1011 if (reached_count)
1012 oidcpy(cb->oid, ooid);
1013 else if (!is_null_oid(&cb->ooid) || cb->date == cb->at_time)
8eb36d94 1014 oidcpy(cb->oid, noid);
9001dc2a 1015 else if (!oideq(noid, cb->oid))
661558f0 1016 warning(_("log for ref %s unexpectedly ended on %s"),
4207ed28 1017 cb->refname, show_date(cb->date, cb->tz,
a5481a6c 1018 DATE_MODE(RFC2822)));
4207ed28 1019 cb->found_it = 1;
4207ed28 1020 }
95c2a718 1021 cb->reccnt++;
8eb36d94 1022 oidcpy(&cb->ooid, ooid);
1023 oidcpy(&cb->noid, noid);
6436a202
DL
1024 return cb->found_it;
1025}
1026
5cf88fd8 1027static int read_ref_at_ent_newest(struct object_id *ooid UNUSED,
63e14ee2 1028 struct object_id *noid,
5cf88fd8 1029 const char *email UNUSED,
63e14ee2
JK
1030 timestamp_t timestamp, int tz,
1031 const char *message, void *cb_data)
6436a202
DL
1032{
1033 struct read_ref_at_cb *cb = cb_data;
1034
1035 set_read_ref_cutoffs(cb, timestamp, tz, message);
1036 oidcpy(cb->oid, noid);
1037 /* We just want the first entry */
1038 return 1;
4207ed28
RS
1039}
1040
9461d272 1041static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
5cf88fd8 1042 const char *email UNUSED,
c006e9fa
JK
1043 timestamp_t timestamp, int tz,
1044 const char *message, void *cb_data)
4207ed28
RS
1045{
1046 struct read_ref_at_cb *cb = cb_data;
1047
95c2a718 1048 set_read_ref_cutoffs(cb, timestamp, tz, message);
8eb36d94 1049 oidcpy(cb->oid, ooid);
1050 if (is_null_oid(cb->oid))
1051 oidcpy(cb->oid, noid);
4207ed28
RS
1052 /* We just want the first entry */
1053 return 1;
16d7cc90
JH
1054}
1055
7fdff474
NTND
1056int read_ref_at(struct ref_store *refs, const char *refname,
1057 unsigned int flags, timestamp_t at_time, int cnt,
8eb36d94 1058 struct object_id *oid, char **msg,
dddbad72 1059 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
d556fae2 1060{
4207ed28 1061 struct read_ref_at_cb cb;
d556fae2 1062
4207ed28
RS
1063 memset(&cb, 0, sizeof(cb));
1064 cb.refname = refname;
1065 cb.at_time = at_time;
1066 cb.cnt = cnt;
1067 cb.msg = msg;
1068 cb.cutoff_time = cutoff_time;
1069 cb.cutoff_tz = cutoff_tz;
1070 cb.cutoff_cnt = cutoff_cnt;
8eb36d94 1071 cb.oid = oid;
4207ed28 1072
6436a202
DL
1073 if (cb.cnt == 0) {
1074 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent_newest, &cb);
1075 return 0;
1076 }
1077
7fdff474 1078 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
4207ed28 1079
c41a87dd 1080 if (!cb.reccnt) {
321c89bf 1081 if (flags & GET_OID_QUIETLY)
c41a87dd
DA
1082 exit(128);
1083 else
661558f0 1084 die(_("log for %s is empty"), refname);
c41a87dd 1085 }
4207ed28
RS
1086 if (cb.found_it)
1087 return 0;
1088
7fdff474 1089 refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
d556fae2 1090
16d7cc90 1091 return 1;
d556fae2 1092}
2ff81662 1093
c0fe4e8b
NTND
1094struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
1095 struct strbuf *err)
caa4046c 1096{
c0fe4e8b 1097 struct ref_transaction *tr;
5a603b04
JN
1098 assert(err);
1099
ca56dadb 1100 CALLOC_ARRAY(tr, 1);
c0fe4e8b
NTND
1101 tr->ref_store = refs;
1102 return tr;
1103}
1104
1105struct ref_transaction *ref_transaction_begin(struct strbuf *err)
1106{
c6da34a6 1107 return ref_store_transaction_begin(get_main_ref_store(the_repository), err);
caa4046c
MH
1108}
1109
026bd1d3 1110void ref_transaction_free(struct ref_transaction *transaction)
caa4046c 1111{
43a2dfde 1112 size_t i;
caa4046c 1113
1b07255c
RS
1114 if (!transaction)
1115 return;
1116
30173b88
MH
1117 switch (transaction->state) {
1118 case REF_TRANSACTION_OPEN:
1119 case REF_TRANSACTION_CLOSED:
1120 /* OK */
1121 break;
1122 case REF_TRANSACTION_PREPARED:
033abf97 1123 BUG("free called on a prepared reference transaction");
30173b88
MH
1124 break;
1125 default:
033abf97 1126 BUG("unexpected reference transaction state");
30173b88
MH
1127 break;
1128 }
1129
db7516ab
RS
1130 for (i = 0; i < transaction->nr; i++) {
1131 free(transaction->updates[i]->msg);
88615910 1132 free(transaction->updates[i]);
db7516ab 1133 }
caa4046c
MH
1134 free(transaction->updates);
1135 free(transaction);
1136}
1137
71564516
MH
1138struct ref_update *ref_transaction_add_update(
1139 struct ref_transaction *transaction,
1140 const char *refname, unsigned int flags,
89f3bbdd 1141 const struct object_id *new_oid,
1142 const struct object_id *old_oid,
71564516 1143 const char *msg)
caa4046c 1144{
96ffc06f 1145 struct ref_update *update;
71564516
MH
1146
1147 if (transaction->state != REF_TRANSACTION_OPEN)
033abf97 1148 BUG("update called for transaction that is not open");
71564516 1149
96ffc06f 1150 FLEX_ALLOC_STR(update, refname, refname);
caa4046c
MH
1151 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
1152 transaction->updates[transaction->nr++] = update;
71564516
MH
1153
1154 update->flags = flags;
1155
1156 if (flags & REF_HAVE_NEW)
89f3bbdd 1157 oidcpy(&update->new_oid, new_oid);
71564516 1158 if (flags & REF_HAVE_OLD)
89f3bbdd 1159 oidcpy(&update->old_oid, old_oid);
523fa69c 1160 update->msg = normalize_reflog_message(msg);
caa4046c
MH
1161 return update;
1162}
1163
8e34800e
RS
1164int ref_transaction_update(struct ref_transaction *transaction,
1165 const char *refname,
89f3bbdd 1166 const struct object_id *new_oid,
1167 const struct object_id *old_oid,
1d147bdf 1168 unsigned int flags, const char *msg,
8e34800e 1169 struct strbuf *err)
caa4046c 1170{
5a603b04
JN
1171 assert(err);
1172
3c966c7b
HWN
1173 if (!(flags & REF_SKIP_REFNAME_VERIFICATION) &&
1174 ((new_oid && !is_null_oid(new_oid)) ?
1175 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL) :
1176 !refname_is_safe(refname))) {
661558f0 1177 strbuf_addf(err, _("refusing to update ref with bad name '%s'"),
d0f810f0
RS
1178 refname);
1179 return -1;
1180 }
1181
a9bbbcec
MH
1182 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
1183 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
c788c54c 1184
49f1eb3b
JK
1185 /*
1186 * Clear flags outside the allowed set; this should be a noop because
1187 * of the BUG() check above, but it works around a -Wnonnull warning
1188 * with some versions of "gcc -O3".
1189 */
1190 flags &= REF_TRANSACTION_UPDATE_ALLOWED_FLAGS;
1191
89f3bbdd 1192 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
71564516
MH
1193
1194 ref_transaction_add_update(transaction, refname, flags,
89f3bbdd 1195 new_oid, old_oid, msg);
8e34800e 1196 return 0;
caa4046c
MH
1197}
1198
b416af5b
RS
1199int ref_transaction_create(struct ref_transaction *transaction,
1200 const char *refname,
89f3bbdd 1201 const struct object_id *new_oid,
fec14ec3 1202 unsigned int flags, const char *msg,
b416af5b 1203 struct strbuf *err)
caa4046c 1204{
d097a23b
DS
1205 if (!new_oid || is_null_oid(new_oid)) {
1206 strbuf_addf(err, "'%s' has a null OID", refname);
1207 return 1;
1208 }
89f3bbdd 1209 return ref_transaction_update(transaction, refname, new_oid,
14228447 1210 null_oid(), flags, msg, err);
caa4046c
MH
1211}
1212
8c8bdc0d
RS
1213int ref_transaction_delete(struct ref_transaction *transaction,
1214 const char *refname,
89f3bbdd 1215 const struct object_id *old_oid,
fb5a6bb6 1216 unsigned int flags, const char *msg,
8c8bdc0d 1217 struct strbuf *err)
caa4046c 1218{
89f3bbdd 1219 if (old_oid && is_null_oid(old_oid))
033abf97 1220 BUG("delete called with old_oid set to zeros");
1d147bdf 1221 return ref_transaction_update(transaction, refname,
14228447 1222 null_oid(), old_oid,
1d147bdf 1223 flags, msg, err);
caa4046c
MH
1224}
1225
16180334
MH
1226int ref_transaction_verify(struct ref_transaction *transaction,
1227 const char *refname,
89f3bbdd 1228 const struct object_id *old_oid,
16180334
MH
1229 unsigned int flags,
1230 struct strbuf *err)
1231{
89f3bbdd 1232 if (!old_oid)
033abf97 1233 BUG("verify called with old_oid set to NULL");
16180334 1234 return ref_transaction_update(transaction, refname,
89f3bbdd 1235 NULL, old_oid,
16180334
MH
1236 flags, NULL, err);
1237}
1238
c0fe4e8b 1239int refs_update_ref(struct ref_store *refs, const char *msg,
ae077771 1240 const char *refname, const struct object_id *new_oid,
1241 const struct object_id *old_oid, unsigned int flags,
c0fe4e8b 1242 enum action_on_err onerr)
4738a333 1243{
74ec19d4 1244 struct ref_transaction *t = NULL;
b4d75ac1 1245 struct strbuf err = STRBUF_INIT;
74ec19d4 1246 int ret = 0;
b4d75ac1 1247
c6da34a6 1248 t = ref_store_transaction_begin(refs, &err);
09743417
HWN
1249 if (!t ||
1250 ref_transaction_update(t, refname, new_oid, old_oid, flags, msg,
1251 &err) ||
1252 ref_transaction_commit(t, &err)) {
1253 ret = 1;
1254 ref_transaction_free(t);
74ec19d4
DT
1255 }
1256 if (ret) {
661558f0 1257 const char *str = _("update_ref failed for ref '%s': %s");
b4d75ac1 1258
b4d75ac1
RS
1259 switch (onerr) {
1260 case UPDATE_REFS_MSG_ON_ERR:
1261 error(str, refname, err.buf);
1262 break;
1263 case UPDATE_REFS_DIE_ON_ERR:
1264 die(str, refname, err.buf);
1265 break;
1266 case UPDATE_REFS_QUIET_ON_ERR:
1267 break;
1268 }
1269 strbuf_release(&err);
4738a333 1270 return 1;
b4d75ac1
RS
1271 }
1272 strbuf_release(&err);
74ec19d4
DT
1273 if (t)
1274 ref_transaction_free(t);
b4d75ac1 1275 return 0;
4738a333
BK
1276}
1277
c0fe4e8b 1278int update_ref(const char *msg, const char *refname,
ae077771 1279 const struct object_id *new_oid,
1280 const struct object_id *old_oid,
c0fe4e8b
NTND
1281 unsigned int flags, enum action_on_err onerr)
1282{
23a3f0cb 1283 return refs_update_ref(get_main_ref_store(the_repository), msg, refname, new_oid,
ae077771 1284 old_oid, flags, onerr);
c0fe4e8b
NTND
1285}
1286
546edf37
NTND
1287char *refs_shorten_unambiguous_ref(struct ref_store *refs,
1288 const char *refname, int strict)
7c2b3029
JK
1289{
1290 int i;
1291 static char **scanf_fmts;
1292 static int nr_rules;
1293 char *short_name;
6cd4a898 1294 struct strbuf resolved_buf = STRBUF_INIT;
7c2b3029 1295
7c2b3029 1296 if (!nr_rules) {
4346663a
MH
1297 /*
1298 * Pre-generate scanf formats from ref_rev_parse_rules[].
1299 * Generate a format suitable for scanf from a
1300 * ref_rev_parse_rules rule by interpolating "%s" at the
1301 * location of the "%.*s".
1302 */
7c2b3029 1303 size_t total_len = 0;
84d5633f 1304 size_t offset = 0;
7c2b3029
JK
1305
1306 /* the rule list is NULL terminated, count them first */
a4165851 1307 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
7902fe03
MH
1308 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1309 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
7c2b3029 1310
50492f7b 1311 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
7c2b3029 1312
84d5633f 1313 offset = 0;
7c2b3029 1314 for (i = 0; i < nr_rules; i++) {
4346663a 1315 assert(offset < total_len);
84d5633f 1316 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
bf4baf1f
JK
1317 offset += xsnprintf(scanf_fmts[i], total_len - offset,
1318 ref_rev_parse_rules[i], 2, "%s") + 1;
7c2b3029
JK
1319 }
1320 }
1321
1322 /* bail out if there are no rules */
1323 if (!nr_rules)
dfefa935 1324 return xstrdup(refname);
7c2b3029 1325
dfefa935
MH
1326 /* buffer for scanf result, at most refname must fit */
1327 short_name = xstrdup(refname);
7c2b3029
JK
1328
1329 /* skip first rule, it will always match */
1330 for (i = nr_rules - 1; i > 0 ; --i) {
1331 int j;
6e7b3309 1332 int rules_to_fail = i;
7c2b3029
JK
1333 int short_name_len;
1334
dfefa935 1335 if (1 != sscanf(refname, scanf_fmts[i], short_name))
7c2b3029
JK
1336 continue;
1337
1338 short_name_len = strlen(short_name);
1339
6e7b3309
BW
1340 /*
1341 * in strict mode, all (except the matched one) rules
1342 * must fail to resolve to a valid non-ambiguous ref
1343 */
1344 if (strict)
1345 rules_to_fail = nr_rules;
1346
7c2b3029
JK
1347 /*
1348 * check if the short name resolves to a valid ref,
1349 * but use only rules prior to the matched one
1350 */
6e7b3309 1351 for (j = 0; j < rules_to_fail; j++) {
7c2b3029 1352 const char *rule = ref_rev_parse_rules[j];
7c2b3029 1353
6e7b3309
BW
1354 /* skip matched rule */
1355 if (i == j)
1356 continue;
1357
7c2b3029
JK
1358 /*
1359 * the short name is ambiguous, if it resolves
1360 * (with this previous rule) to a valid ref
1361 * read_ref() returns 0 on success
1362 */
6cd4a898
JK
1363 strbuf_reset(&resolved_buf);
1364 strbuf_addf(&resolved_buf, rule,
1365 short_name_len, short_name);
546edf37 1366 if (refs_ref_exists(refs, resolved_buf.buf))
7c2b3029
JK
1367 break;
1368 }
1369
1370 /*
1371 * short name is non-ambiguous if all previous rules
1372 * haven't resolved to a valid ref
1373 */
6cd4a898
JK
1374 if (j == rules_to_fail) {
1375 strbuf_release(&resolved_buf);
7c2b3029 1376 return short_name;
6cd4a898 1377 }
7c2b3029
JK
1378 }
1379
6cd4a898 1380 strbuf_release(&resolved_buf);
7c2b3029 1381 free(short_name);
dfefa935 1382 return xstrdup(refname);
7c2b3029 1383}
daebaa78 1384
546edf37
NTND
1385char *shorten_unambiguous_ref(const char *refname, int strict)
1386{
1387 return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
1388 refname, strict);
1389}
1390
daebaa78
JH
1391static struct string_list *hide_refs;
1392
1393int parse_hide_refs_config(const char *var, const char *value, const char *section)
1394{
ad8c7cda 1395 const char *key;
daebaa78 1396 if (!strcmp("transfer.hiderefs", var) ||
ad8c7cda
JK
1397 (!parse_config_key(var, section, NULL, NULL, &key) &&
1398 !strcmp(key, "hiderefs"))) {
daebaa78
JH
1399 char *ref;
1400 int len;
1401
1402 if (!value)
1403 return config_error_nonbool(var);
1404 ref = xstrdup(value);
1405 len = strlen(ref);
1406 while (len && ref[len - 1] == '/')
1407 ref[--len] = '\0';
1408 if (!hide_refs) {
ca56dadb 1409 CALLOC_ARRAY(hide_refs, 1);
daebaa78
JH
1410 hide_refs->strdup_strings = 1;
1411 }
1412 string_list_append(hide_refs, ref);
1413 }
1414 return 0;
1415}
1416
78a766ab 1417int ref_is_hidden(const char *refname, const char *refname_full)
daebaa78 1418{
2bc31d16 1419 int i;
daebaa78
JH
1420
1421 if (!hide_refs)
1422 return 0;
2bc31d16
JK
1423 for (i = hide_refs->nr - 1; i >= 0; i--) {
1424 const char *match = hide_refs->items[i].string;
78a766ab 1425 const char *subject;
2bc31d16 1426 int neg = 0;
7a40a95e 1427 const char *p;
2bc31d16
JK
1428
1429 if (*match == '!') {
1430 neg = 1;
1431 match++;
1432 }
1433
78a766ab
LF
1434 if (*match == '^') {
1435 subject = refname_full;
1436 match++;
1437 } else {
1438 subject = refname;
1439 }
1440
1441 /* refname can be NULL when namespaces are used. */
7a40a95e
CC
1442 if (subject &&
1443 skip_prefix(subject, match, &p) &&
1444 (!*p || *p == '/'))
2bc31d16 1445 return !neg;
daebaa78
JH
1446 }
1447 return 0;
1448}
fa5b1830 1449
0845122c
DT
1450const char *find_descendant_ref(const char *dirname,
1451 const struct string_list *extras,
1452 const struct string_list *skip)
fa5b1830 1453{
0845122c 1454 int pos;
fa5b1830 1455
0845122c
DT
1456 if (!extras)
1457 return NULL;
fa5b1830
MH
1458
1459 /*
0845122c
DT
1460 * Look at the place where dirname would be inserted into
1461 * extras. If there is an entry at that position that starts
1462 * with dirname (remember, dirname includes the trailing
1463 * slash) and is not in skip, then we have a conflict.
fa5b1830 1464 */
0845122c
DT
1465 for (pos = string_list_find_insert_index(extras, dirname, 0);
1466 pos < extras->nr; pos++) {
1467 const char *extra_refname = extras->items[pos].string;
fa5b1830 1468
0845122c
DT
1469 if (!starts_with(extra_refname, dirname))
1470 break;
1471
1472 if (!skip || !string_list_has_string(skip, extra_refname))
1473 return extra_refname;
fa5b1830 1474 }
0845122c
DT
1475 return NULL;
1476}
fa5b1830 1477
62f0b399 1478int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2bf68ed5
DT
1479{
1480 struct object_id oid;
1481 int flag;
1482
f1da24ca 1483 if (refs_resolve_ref_unsafe(refs, "HEAD", RESOLVE_REF_READING,
ce14de03 1484 &oid, &flag))
2bf68ed5
DT
1485 return fn("HEAD", &oid, flag, cb_data);
1486
1487 return 0;
1488}
1489
1490int head_ref(each_ref_fn fn, void *cb_data)
1491{
23a3f0cb 1492 return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
2bf68ed5 1493}
93770590 1494
e121b9cb
MH
1495struct ref_iterator *refs_ref_iterator_begin(
1496 struct ref_store *refs,
9aab952e
JK
1497 const char *prefix, int trim,
1498 enum do_for_each_ref_flags flags)
e121b9cb
MH
1499{
1500 struct ref_iterator *iter;
1501
6d751be4 1502 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
5d1f5b8c
JK
1503 static int ref_paranoia = -1;
1504
6d751be4 1505 if (ref_paranoia < 0)
968f12fd 1506 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 1);
6d751be4
JK
1507 if (ref_paranoia) {
1508 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1509 flags |= DO_FOR_EACH_OMIT_DANGLING_SYMREFS;
1510 }
1511 }
0a0865b8 1512
e121b9cb 1513 iter = refs->be->iterator_begin(refs, prefix, flags);
c7599718
MH
1514
1515 /*
1516 * `iterator_begin()` already takes care of prefix, but we
1517 * might need to do some trimming:
1518 */
1519 if (trim)
1520 iter = prefix_ref_iterator_begin(iter, "", trim);
e121b9cb 1521
8738a8a4
MH
1522 /* Sanity check for subclasses: */
1523 if (!iter->ordered)
1524 BUG("reference iterator is not ordered");
1525
e121b9cb
MH
1526 return iter;
1527}
1528
4c4de895
MH
1529/*
1530 * Call fn for each reference in the specified submodule for which the
1531 * refname begins with prefix. If trim is non-zero, then trim that
1532 * many characters off the beginning of each refname before passing
1533 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1534 * include broken references in the iteration. If fn ever returns a
1535 * non-zero value, stop the iteration and return that value;
1536 * otherwise, return 0.
1537 */
4a6067cd
SB
1538static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1539 each_repo_ref_fn fn, int trim, int flags,
1540 void *cb_data)
1541{
1542 struct ref_iterator *iter;
1543 struct ref_store *refs = get_main_ref_store(r);
1544
1545 if (!refs)
1546 return 0;
1547
1548 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1549
1550 return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1551}
1552
1553struct do_for_each_ref_help {
1554 each_ref_fn *fn;
1555 void *cb_data;
1556};
1557
1558static int do_for_each_ref_helper(struct repository *r,
1559 const char *refname,
1560 const struct object_id *oid,
1561 int flags,
1562 void *cb_data)
1563{
1564 struct do_for_each_ref_help *hp = cb_data;
1565
1566 return hp->fn(refname, oid, flags, hp->cb_data);
1567}
1568
7d2df051 1569static int do_for_each_ref(struct ref_store *refs, const char *prefix,
9aab952e
JK
1570 each_ref_fn fn, int trim,
1571 enum do_for_each_ref_flags flags, void *cb_data)
4c4de895
MH
1572{
1573 struct ref_iterator *iter;
4a6067cd 1574 struct do_for_each_ref_help hp = { fn, cb_data };
4c4de895 1575
00eebe35
MH
1576 if (!refs)
1577 return 0;
1578
e121b9cb 1579 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
4c4de895 1580
4a6067cd
SB
1581 return do_for_each_repo_ref_iterator(the_repository, iter,
1582 do_for_each_ref_helper, &hp);
4c4de895
MH
1583}
1584
7d2df051
NTND
1585int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1586{
1587 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1588}
1589
93770590
DT
1590int for_each_ref(each_ref_fn fn, void *cb_data)
1591{
23a3f0cb 1592 return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
93770590
DT
1593}
1594
7d2df051
NTND
1595int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1596 each_ref_fn fn, void *cb_data)
1597{
1598 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
93770590
DT
1599}
1600
1601int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1602{
23a3f0cb 1603 return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
93770590
DT
1604}
1605
67985e4e 1606int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data)
93770590 1607{
23a3f0cb 1608 return do_for_each_ref(get_main_ref_store(the_repository),
67985e4e 1609 prefix, fn, 0, 0, cb_data);
93770590
DT
1610}
1611
073cf63c 1612int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
67985e4e 1613 each_ref_fn fn, void *cb_data)
03df567f 1614{
67985e4e 1615 return do_for_each_ref(refs, prefix, fn, 0, 0, cb_data);
03df567f
MH
1616}
1617
212e0f7e 1618int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
93770590 1619{
97e61e0f 1620 const char *git_replace_ref_base = ref_namespace[NAMESPACE_REPLACE].ref;
212e0f7e
SB
1621 return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1622 strlen(git_replace_ref_base),
1623 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
93770590
DT
1624}
1625
1626int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1627{
1628 struct strbuf buf = STRBUF_INIT;
1629 int ret;
1630 strbuf_addf(&buf, "%srefs/", get_git_namespace());
23a3f0cb 1631 ret = do_for_each_ref(get_main_ref_store(the_repository),
7d2df051 1632 buf.buf, fn, 0, 0, cb_data);
93770590
DT
1633 strbuf_release(&buf);
1634 return ret;
1635}
1636
7d2df051 1637int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
93770590 1638{
7d2df051 1639 return do_for_each_ref(refs, "", fn, 0,
93770590
DT
1640 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1641}
2d0663b2 1642
7d2df051
NTND
1643int for_each_rawref(each_ref_fn fn, void *cb_data)
1644{
23a3f0cb 1645 return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
7d2df051
NTND
1646}
1647
16b1985b
TB
1648static int qsort_strcmp(const void *va, const void *vb)
1649{
1650 const char *a = *(const char **)va;
1651 const char *b = *(const char **)vb;
1652
1653 return strcmp(a, b);
1654}
1655
1656static void find_longest_prefixes_1(struct string_list *out,
1657 struct strbuf *prefix,
1658 const char **patterns, size_t nr)
1659{
1660 size_t i;
1661
1662 for (i = 0; i < nr; i++) {
1663 char c = patterns[i][prefix->len];
1664 if (!c || is_glob_special(c)) {
1665 string_list_append(out, prefix->buf);
1666 return;
1667 }
1668 }
1669
1670 i = 0;
1671 while (i < nr) {
1672 size_t end;
1673
1674 /*
1675 * Set "end" to the index of the element _after_ the last one
1676 * in our group.
1677 */
1678 for (end = i + 1; end < nr; end++) {
1679 if (patterns[i][prefix->len] != patterns[end][prefix->len])
1680 break;
1681 }
1682
1683 strbuf_addch(prefix, patterns[i][prefix->len]);
1684 find_longest_prefixes_1(out, prefix, patterns + i, end - i);
1685 strbuf_setlen(prefix, prefix->len - 1);
1686
1687 i = end;
1688 }
1689}
1690
1691static void find_longest_prefixes(struct string_list *out,
1692 const char **patterns)
1693{
1694 struct strvec sorted = STRVEC_INIT;
1695 struct strbuf prefix = STRBUF_INIT;
1696
1697 strvec_pushv(&sorted, patterns);
1698 QSORT(sorted.v, sorted.nr, qsort_strcmp);
1699
1700 find_longest_prefixes_1(out, &prefix, sorted.v, sorted.nr);
1701
1702 strvec_clear(&sorted);
1703 strbuf_release(&prefix);
1704}
1705
1706int for_each_fullref_in_prefixes(const char *namespace,
1707 const char **patterns,
67985e4e 1708 each_ref_fn fn, void *cb_data)
16b1985b
TB
1709{
1710 struct string_list prefixes = STRING_LIST_INIT_DUP;
1711 struct string_list_item *prefix;
1712 struct strbuf buf = STRBUF_INIT;
1713 int ret = 0, namespace_len;
1714
1715 find_longest_prefixes(&prefixes, patterns);
1716
1717 if (namespace)
1718 strbuf_addstr(&buf, namespace);
1719 namespace_len = buf.len;
1720
1721 for_each_string_list_item(prefix, &prefixes) {
1722 strbuf_addstr(&buf, prefix->string);
67985e4e 1723 ret = for_each_fullref_in(buf.buf, fn, cb_data);
16b1985b
TB
1724 if (ret)
1725 break;
1726 strbuf_setlen(&buf, namespace_len);
1727 }
1728
1729 string_list_clear(&prefixes, 0);
1730 strbuf_release(&buf);
1731 return ret;
1732}
1733
e8115302
HWN
1734static int refs_read_special_head(struct ref_store *ref_store,
1735 const char *refname, struct object_id *oid,
df3458e9
HWN
1736 struct strbuf *referent, unsigned int *type,
1737 int *failure_errno)
e8115302
HWN
1738{
1739 struct strbuf full_path = STRBUF_INIT;
1740 struct strbuf content = STRBUF_INIT;
1741 int result = -1;
1742 strbuf_addf(&full_path, "%s/%s", ref_store->gitdir, refname);
1743
1744 if (strbuf_read_file(&content, full_path.buf, 0) < 0)
1745 goto done;
1746
df3458e9
HWN
1747 result = parse_loose_ref_contents(content.buf, oid, referent, type,
1748 failure_errno);
e8115302
HWN
1749
1750done:
1751 strbuf_release(&full_path);
1752 strbuf_release(&content);
1753 return result;
1754}
1755
8b72fea7
HWN
1756int refs_read_raw_ref(struct ref_store *ref_store, const char *refname,
1757 struct object_id *oid, struct strbuf *referent,
1758 unsigned int *type, int *failure_errno)
470be518 1759{
8b72fea7 1760 assert(failure_errno);
e8115302
HWN
1761 if (!strcmp(refname, "FETCH_HEAD") || !strcmp(refname, "MERGE_HEAD")) {
1762 return refs_read_special_head(ref_store, refname, oid, referent,
df3458e9 1763 type, failure_errno);
e8115302
HWN
1764 }
1765
1766 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent,
8b72fea7 1767 type, failure_errno);
470be518
MH
1768}
1769
cd475b3b
PS
1770int refs_read_symbolic_ref(struct ref_store *ref_store, const char *refname,
1771 struct strbuf *referent)
1772{
5b875404 1773 return ref_store->be->read_symbolic_ref(ref_store, refname, referent);
cd475b3b
PS
1774}
1775
7d2df051 1776const char *refs_resolve_ref_unsafe(struct ref_store *refs,
3c0cb0cb
MH
1777 const char *refname,
1778 int resolve_flags,
ef18119d 1779 struct object_id *oid,
ce14de03 1780 int *flags)
2d0663b2
DT
1781{
1782 static struct strbuf sb_refname = STRBUF_INIT;
54fad661 1783 struct object_id unused_oid;
2d0663b2
DT
1784 int unused_flags;
1785 int symref_count;
1786
49e61479 1787 if (!oid)
1788 oid = &unused_oid;
2d0663b2
DT
1789 if (!flags)
1790 flags = &unused_flags;
1791
1792 *flags = 0;
1793
1794 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1795 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
ce14de03 1796 !refname_is_safe(refname))
2d0663b2 1797 return NULL;
2d0663b2
DT
1798
1799 /*
1800 * dwim_ref() uses REF_ISBROKEN to distinguish between
1801 * missing refs and refs that were present but invalid,
1802 * to complain about the latter to stderr.
1803 *
1804 * We don't know whether the ref exists, so don't set
1805 * REF_ISBROKEN yet.
1806 */
1807 *flags |= REF_BAD_NAME;
1808 }
1809
1810 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1811 unsigned int read_flags = 0;
ce14de03 1812 int failure_errno;
2d0663b2 1813
8b72fea7 1814 if (refs_read_raw_ref(refs, refname, oid, &sb_refname,
ce14de03 1815 &read_flags, &failure_errno)) {
2d0663b2 1816 *flags |= read_flags;
a1c1d817
JK
1817
1818 /* In reading mode, refs must eventually resolve */
1819 if (resolve_flags & RESOLVE_REF_READING)
1820 return NULL;
1821
1822 /*
1823 * Otherwise a missing ref is OK. But the files backend
1824 * may show errors besides ENOENT if there are
1825 * similarly-named refs.
1826 */
ce14de03
ÆAB
1827 if (failure_errno != ENOENT &&
1828 failure_errno != EISDIR &&
1829 failure_errno != ENOTDIR)
2d0663b2 1830 return NULL;
a1c1d817 1831
49e61479 1832 oidclr(oid);
2d0663b2
DT
1833 if (*flags & REF_BAD_NAME)
1834 *flags |= REF_ISBROKEN;
1835 return refname;
1836 }
1837
1838 *flags |= read_flags;
1839
1840 if (!(read_flags & REF_ISSYMREF)) {
1841 if (*flags & REF_BAD_NAME) {
49e61479 1842 oidclr(oid);
2d0663b2
DT
1843 *flags |= REF_ISBROKEN;
1844 }
1845 return refname;
1846 }
1847
1848 refname = sb_refname.buf;
1849 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
49e61479 1850 oidclr(oid);
2d0663b2
DT
1851 return refname;
1852 }
1853 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1854 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
ce14de03 1855 !refname_is_safe(refname))
2d0663b2 1856 return NULL;
2d0663b2
DT
1857
1858 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1859 }
1860 }
1861
2d0663b2
DT
1862 return NULL;
1863}
00eebe35 1864
6fb5acfd
DT
1865/* backend functions */
1866int refs_init_db(struct strbuf *err)
1867{
23a3f0cb 1868 struct ref_store *refs = get_main_ref_store(the_repository);
6fb5acfd
DT
1869
1870 return refs->be->init_db(refs, err);
1871}
1872
bd40dcda 1873const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
49e61479 1874 struct object_id *oid, int *flags)
bd40dcda 1875{
23a3f0cb 1876 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
ce14de03 1877 resolve_flags, oid, flags);
bd40dcda
MH
1878}
1879
a8355bb7 1880int resolve_gitlink_ref(const char *submodule, const char *refname,
a98e6101 1881 struct object_id *oid)
424dcc76 1882{
424dcc76
MH
1883 struct ref_store *refs;
1884 int flags;
1885
29babbee 1886 refs = get_submodule_ref_store(submodule);
48a8475f 1887
424dcc76
MH
1888 if (!refs)
1889 return -1;
1890
ce14de03
ÆAB
1891 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
1892 is_null_oid(oid))
424dcc76
MH
1893 return -1;
1894 return 0;
1895}
1896
0c064d90 1897struct ref_store_hash_entry
7d4558c4 1898{
e2b5038d 1899 struct hashmap_entry ent;
7d4558c4
MH
1900
1901 struct ref_store *refs;
1902
0c064d90
NTND
1903 /* NUL-terminated identifier of the ref store: */
1904 char name[FLEX_ARRAY];
7d4558c4
MH
1905};
1906
5cf88fd8 1907static int ref_store_hash_cmp(const void *cmp_data UNUSED,
939af16e
EW
1908 const struct hashmap_entry *eptr,
1909 const struct hashmap_entry *entry_or_key,
7d4558c4
MH
1910 const void *keydata)
1911{
939af16e
EW
1912 const struct ref_store_hash_entry *e1, *e2;
1913 const char *name;
1914
1915 e1 = container_of(eptr, const struct ref_store_hash_entry, ent);
1916 e2 = container_of(entry_or_key, const struct ref_store_hash_entry, ent);
1917 name = keydata ? keydata : e2->name;
7d4558c4 1918
0c064d90 1919 return strcmp(e1->name, name);
7d4558c4
MH
1920}
1921
0c064d90
NTND
1922static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1923 const char *name, struct ref_store *refs)
7d4558c4 1924{
0c064d90 1925 struct ref_store_hash_entry *entry;
7d4558c4 1926
0c064d90 1927 FLEX_ALLOC_STR(entry, name, name);
d22245a2 1928 hashmap_entry_init(&entry->ent, strhash(name));
7d4558c4
MH
1929 entry->refs = refs;
1930 return entry;
1931}
1932
7d4558c4
MH
1933/* A hashmap of ref_stores, stored by submodule name: */
1934static struct hashmap submodule_ref_stores;
00eebe35 1935
17eff96b
NTND
1936/* A hashmap of ref_stores, stored by worktree id: */
1937static struct hashmap worktree_ref_stores;
1938
c468da4e 1939/*
0c064d90
NTND
1940 * Look up a ref store by name. If that ref_store hasn't been
1941 * registered yet, return NULL.
c468da4e 1942 */
0c064d90
NTND
1943static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1944 const char *name)
00eebe35 1945{
0c064d90 1946 struct ref_store_hash_entry *entry;
f23a4651 1947 unsigned int hash;
00eebe35 1948
0c064d90 1949 if (!map->tablesize)
7d4558c4
MH
1950 /* It's initialized on demand in register_ref_store(). */
1951 return NULL;
620a66b9 1952
f23a4651
EW
1953 hash = strhash(name);
1954 entry = hashmap_get_entry_from_hash(map, hash, name,
1955 struct ref_store_hash_entry, ent);
7d4558c4 1956 return entry ? entry->refs : NULL;
00eebe35
MH
1957}
1958
c468da4e
MH
1959/*
1960 * Create, record, and return a ref_store instance for the specified
5d0bc90e 1961 * gitdir.
c468da4e 1962 */
34224e14
JT
1963static struct ref_store *ref_store_init(struct repository *repo,
1964 const char *gitdir,
9e7ec634 1965 unsigned int flags)
00eebe35
MH
1966{
1967 const char *be_name = "files";
1968 struct ref_storage_be *be = find_ref_storage_backend(be_name);
ba88add5 1969 struct ref_store *refs;
00eebe35
MH
1970
1971 if (!be)
033abf97 1972 BUG("reference backend %s is unknown", be_name);
00eebe35 1973
34224e14 1974 refs = be->init(repo, gitdir, flags);
ba88add5 1975 return refs;
00eebe35
MH
1976}
1977
64a74161 1978struct ref_store *get_main_ref_store(struct repository *r)
24c8407e 1979{
02204610
JK
1980 if (r->refs_private)
1981 return r->refs_private;
24c8407e 1982
2dc417ab
JK
1983 if (!r->gitdir)
1984 BUG("attempting to get main_ref_store outside of repository");
1985
34224e14 1986 r->refs_private = ref_store_init(r, r->gitdir, REF_STORE_ALL_CAPS);
4441f427 1987 r->refs_private = maybe_debug_wrap_ref_store(r->gitdir, r->refs_private);
02204610 1988 return r->refs_private;
378dc910
NTND
1989}
1990
1991/*
0c064d90
NTND
1992 * Associate a ref store with a name. It is a fatal error to call this
1993 * function twice for the same name.
378dc910 1994 */
0c064d90
NTND
1995static void register_ref_store_map(struct hashmap *map,
1996 const char *type,
1997 struct ref_store *refs,
1998 const char *name)
378dc910 1999{
26b455f2
EW
2000 struct ref_store_hash_entry *entry;
2001
0c064d90 2002 if (!map->tablesize)
7663cdc8 2003 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
378dc910 2004
26b455f2
EW
2005 entry = alloc_ref_store_hash_entry(name, refs);
2006 if (hashmap_put(map, &entry->ent))
033abf97 2007 BUG("%s ref_store '%s' initialized twice", type, name);
24c8407e
NTND
2008}
2009
18d0002d 2010struct ref_store *get_submodule_ref_store(const char *submodule)
00eebe35 2011{
126c9e05 2012 struct strbuf submodule_sb = STRBUF_INIT;
00eebe35 2013 struct ref_store *refs;
29babbee
NTND
2014 char *to_free = NULL;
2015 size_t len;
34224e14 2016 struct repository *subrepo;
00eebe35 2017
82a150f2
NTND
2018 if (!submodule)
2019 return NULL;
2020
873ea90d
NTND
2021 len = strlen(submodule);
2022 while (len && is_dir_sep(submodule[len - 1]))
2023 len--;
2024 if (!len)
2025 return NULL;
00eebe35 2026
29babbee
NTND
2027 if (submodule[len])
2028 /* We need to strip off one or more trailing slashes */
2029 submodule = to_free = xmemdupz(submodule, len);
00eebe35 2030
0c064d90 2031 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
126c9e05 2032 if (refs)
2c616c17 2033 goto done;
00eebe35 2034
126c9e05 2035 strbuf_addstr(&submodule_sb, submodule);
2c616c17
NTND
2036 if (!is_nonbare_repository_dir(&submodule_sb))
2037 goto done;
00eebe35 2038
2c616c17
NTND
2039 if (submodule_to_gitdir(&submodule_sb, submodule))
2040 goto done;
00eebe35 2041
34224e14
JT
2042 subrepo = xmalloc(sizeof(*subrepo));
2043 /*
2044 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2045 * superprojects other than the_repository. This probably should be
2046 * done by making it take a struct repository * parameter instead of a
2047 * submodule path.
2048 */
2049 if (repo_submodule_init(subrepo, the_repository, submodule,
2050 null_oid())) {
2051 free(subrepo);
2052 goto done;
2053 }
2054 refs = ref_store_init(subrepo, submodule_sb.buf,
9e7ec634 2055 REF_STORE_READ | REF_STORE_ODB);
0c064d90
NTND
2056 register_ref_store_map(&submodule_ref_stores, "submodule",
2057 refs, submodule);
5d0bc90e 2058
2c616c17 2059done:
5d0bc90e 2060 strbuf_release(&submodule_sb);
29babbee
NTND
2061 free(to_free);
2062
00eebe35
MH
2063 return refs;
2064}
2065
17eff96b
NTND
2066struct ref_store *get_worktree_ref_store(const struct worktree *wt)
2067{
2068 struct ref_store *refs;
2069 const char *id;
2070
2071 if (wt->is_current)
23a3f0cb 2072 return get_main_ref_store(the_repository);
17eff96b
NTND
2073
2074 id = wt->id ? wt->id : "/";
2075 refs = lookup_ref_store_map(&worktree_ref_stores, id);
2076 if (refs)
2077 return refs;
2078
2079 if (wt->id)
34224e14
JT
2080 refs = ref_store_init(the_repository,
2081 git_common_path("worktrees/%s", wt->id),
17eff96b
NTND
2082 REF_STORE_ALL_CAPS);
2083 else
34224e14
JT
2084 refs = ref_store_init(the_repository,
2085 get_git_common_dir(),
17eff96b
NTND
2086 REF_STORE_ALL_CAPS);
2087
2088 if (refs)
2089 register_ref_store_map(&worktree_ref_stores, "worktree",
2090 refs, id);
2091 return refs;
2092}
2093
f9f7fd3b
HWN
2094void base_ref_store_init(struct ref_store *refs, struct repository *repo,
2095 const char *path, const struct ref_storage_be *be)
00eebe35 2096{
620a66b9 2097 refs->be = be;
f9f7fd3b
HWN
2098 refs->repo = repo;
2099 refs->gitdir = xstrdup(path);
00eebe35 2100}
127b42a1
RS
2101
2102/* backend functions */
7d2df051 2103int refs_pack_refs(struct ref_store *refs, unsigned int flags)
8231527e 2104{
8231527e
MH
2105 return refs->be->pack_refs(refs, flags);
2106}
2107
36a31792 2108int peel_iterated_oid(const struct object_id *base, struct object_id *peeled)
7d2df051 2109{
36a31792
JK
2110 if (current_ref_iter &&
2111 (current_ref_iter->oid == base ||
2112 oideq(current_ref_iter->oid, base)))
2113 return ref_iterator_peel(current_ref_iter, peeled);
ba1c052f 2114
617480d7 2115 return peel_object(base, peeled) ? -1 : 0;
7d2df051 2116}
bd427cf2 2117
7d2df051
NTND
2118int refs_create_symref(struct ref_store *refs,
2119 const char *ref_target,
2120 const char *refs_heads_master,
2121 const char *logmsg)
2122{
523fa69c
JH
2123 char *msg;
2124 int retval;
2125
2126 msg = normalize_reflog_message(logmsg);
2127 retval = refs->be->create_symref(refs, ref_target, refs_heads_master,
2128 msg);
2129 free(msg);
2130 return retval;
bd427cf2
MH
2131}
2132
284689ba
MH
2133int create_symref(const char *ref_target, const char *refs_heads_master,
2134 const char *logmsg)
2135{
23a3f0cb 2136 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
7d2df051 2137 refs_heads_master, logmsg);
284689ba
MH
2138}
2139
2ced105c
MH
2140int ref_update_reject_duplicates(struct string_list *refnames,
2141 struct strbuf *err)
2142{
a552e50e 2143 size_t i, n = refnames->nr;
2ced105c
MH
2144
2145 assert(err);
2146
8556f8d6
MH
2147 for (i = 1; i < n; i++) {
2148 int cmp = strcmp(refnames->items[i - 1].string,
2149 refnames->items[i].string);
2150
2151 if (!cmp) {
2ced105c 2152 strbuf_addf(err,
661558f0 2153 _("multiple updates for ref '%s' not allowed"),
2ced105c
MH
2154 refnames->items[i].string);
2155 return 1;
8556f8d6 2156 } else if (cmp > 0) {
033abf97 2157 BUG("ref_update_reject_duplicates() received unsorted list");
2ced105c 2158 }
8556f8d6 2159 }
2ced105c
MH
2160 return 0;
2161}
2162
67541597
PS
2163static int run_transaction_hook(struct ref_transaction *transaction,
2164 const char *state)
2165{
2166 struct child_process proc = CHILD_PROCESS_INIT;
2167 struct strbuf buf = STRBUF_INIT;
0a0fbbe3 2168 const char *hook;
67541597
PS
2169 int ret = 0, i;
2170
0a0fbbe3 2171 hook = find_hook("reference-transaction");
67541597 2172 if (!hook)
67541597 2173 return ret;
67541597 2174
c972bf4c 2175 strvec_pushl(&proc.args, hook, state, NULL);
67541597
PS
2176 proc.in = -1;
2177 proc.stdout_to_stderr = 1;
2178 proc.trace2_hook_name = "reference-transaction";
2179
2180 ret = start_command(&proc);
2181 if (ret)
2182 return ret;
2183
2184 sigchain_push(SIGPIPE, SIG_IGN);
2185
2186 for (i = 0; i < transaction->nr; i++) {
2187 struct ref_update *update = transaction->updates[i];
2188
2189 strbuf_reset(&buf);
2190 strbuf_addf(&buf, "%s %s %s\n",
2191 oid_to_hex(&update->old_oid),
2192 oid_to_hex(&update->new_oid),
2193 update->refname);
2194
2195 if (write_in_full(proc.in, buf.buf, buf.len) < 0) {
4755d7df
ÆAB
2196 if (errno != EPIPE) {
2197 /* Don't leak errno outside this API */
2198 errno = 0;
67541597 2199 ret = -1;
4755d7df 2200 }
67541597
PS
2201 break;
2202 }
2203 }
2204
2205 close(proc.in);
2206 sigchain_pop(SIGPIPE);
2207 strbuf_release(&buf);
2208
2209 ret |= finish_command(&proc);
2210 return ret;
2211}
2212
30173b88
MH
2213int ref_transaction_prepare(struct ref_transaction *transaction,
2214 struct strbuf *err)
127b42a1 2215{
c0fe4e8b 2216 struct ref_store *refs = transaction->ref_store;
67541597 2217 int ret;
127b42a1 2218
8d4240d3
MH
2219 switch (transaction->state) {
2220 case REF_TRANSACTION_OPEN:
2221 /* Good. */
2222 break;
30173b88 2223 case REF_TRANSACTION_PREPARED:
033abf97 2224 BUG("prepare called twice on reference transaction");
30173b88 2225 break;
8d4240d3 2226 case REF_TRANSACTION_CLOSED:
033abf97 2227 BUG("prepare called on a closed reference transaction");
8d4240d3
MH
2228 break;
2229 default:
033abf97 2230 BUG("unexpected reference transaction state");
8d4240d3
MH
2231 break;
2232 }
2233
ecd81dfc 2234 if (refs->repo->objects->odb->disable_ref_updates) {
d8f4481c
JK
2235 strbuf_addstr(err,
2236 _("ref updates forbidden inside quarantine environment"));
2237 return -1;
2238 }
2239
67541597
PS
2240 ret = refs->be->transaction_prepare(refs, transaction, err);
2241 if (ret)
2242 return ret;
2243
2244 ret = run_transaction_hook(transaction, "prepared");
2245 if (ret) {
2246 ref_transaction_abort(transaction, err);
2247 die(_("ref updates aborted by hook"));
2248 }
2249
2250 return 0;
30173b88
MH
2251}
2252
2253int ref_transaction_abort(struct ref_transaction *transaction,
2254 struct strbuf *err)
2255{
2256 struct ref_store *refs = transaction->ref_store;
2257 int ret = 0;
2258
2259 switch (transaction->state) {
2260 case REF_TRANSACTION_OPEN:
2261 /* No need to abort explicitly. */
2262 break;
2263 case REF_TRANSACTION_PREPARED:
2264 ret = refs->be->transaction_abort(refs, transaction, err);
2265 break;
2266 case REF_TRANSACTION_CLOSED:
033abf97 2267 BUG("abort called on a closed reference transaction");
30173b88
MH
2268 break;
2269 default:
033abf97 2270 BUG("unexpected reference transaction state");
30173b88
MH
2271 break;
2272 }
2273
67541597
PS
2274 run_transaction_hook(transaction, "aborted");
2275
30173b88
MH
2276 ref_transaction_free(transaction);
2277 return ret;
2278}
2279
2280int ref_transaction_commit(struct ref_transaction *transaction,
2281 struct strbuf *err)
2282{
2283 struct ref_store *refs = transaction->ref_store;
2284 int ret;
2285
2286 switch (transaction->state) {
2287 case REF_TRANSACTION_OPEN:
2288 /* Need to prepare first. */
2289 ret = ref_transaction_prepare(transaction, err);
2290 if (ret)
2291 return ret;
2292 break;
2293 case REF_TRANSACTION_PREPARED:
2294 /* Fall through to finish. */
2295 break;
2296 case REF_TRANSACTION_CLOSED:
033abf97 2297 BUG("commit called on a closed reference transaction");
30173b88
MH
2298 break;
2299 default:
033abf97 2300 BUG("unexpected reference transaction state");
30173b88
MH
2301 break;
2302 }
2303
67541597
PS
2304 ret = refs->be->transaction_finish(refs, transaction, err);
2305 if (!ret)
2306 run_transaction_hook(transaction, "committed");
2307 return ret;
127b42a1 2308}
62665823 2309
7d2df051
NTND
2310int refs_verify_refname_available(struct ref_store *refs,
2311 const char *refname,
b05855b5 2312 const struct string_list *extras,
7d2df051
NTND
2313 const struct string_list *skip,
2314 struct strbuf *err)
62665823 2315{
b05855b5
MH
2316 const char *slash;
2317 const char *extra_refname;
2318 struct strbuf dirname = STRBUF_INIT;
2319 struct strbuf referent = STRBUF_INIT;
2320 struct object_id oid;
2321 unsigned int type;
2322 struct ref_iterator *iter;
2323 int ok;
2324 int ret = -1;
2325
2326 /*
2327 * For the sake of comments in this function, suppose that
2328 * refname is "refs/foo/bar".
2329 */
2330
2331 assert(err);
2332
2333 strbuf_grow(&dirname, strlen(refname) + 1);
2334 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
8b72fea7
HWN
2335 /*
2336 * Just saying "Is a directory" when we e.g. can't
2337 * lock some multi-level ref isn't very informative,
2338 * the user won't be told *what* is a directory, so
2339 * let's not use strerror() below.
2340 */
2341 int ignore_errno;
b05855b5
MH
2342 /* Expand dirname to the new prefix, not including the trailing slash: */
2343 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2344
2345 /*
2346 * We are still at a leading dir of the refname (e.g.,
2347 * "refs/foo"; if there is a reference with that name,
2348 * it is a conflict, *unless* it is in skip.
2349 */
2350 if (skip && string_list_has_string(skip, dirname.buf))
2351 continue;
2352
8b72fea7
HWN
2353 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent,
2354 &type, &ignore_errno)) {
661558f0 2355 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
b05855b5
MH
2356 dirname.buf, refname);
2357 goto cleanup;
2358 }
2359
2360 if (extras && string_list_has_string(extras, dirname.buf)) {
661558f0 2361 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
b05855b5
MH
2362 refname, dirname.buf);
2363 goto cleanup;
2364 }
2365 }
2366
2367 /*
2368 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2369 * There is no point in searching for a reference with that
2370 * name, because a refname isn't considered to conflict with
2371 * itself. But we still need to check for references whose
2372 * names are in the "refs/foo/bar/" namespace, because they
2373 * *do* conflict.
2374 */
2375 strbuf_addstr(&dirname, refname + dirname.len);
2376 strbuf_addch(&dirname, '/');
2377
2378 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
2379 DO_FOR_EACH_INCLUDE_BROKEN);
2380 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2381 if (skip &&
2382 string_list_has_string(skip, iter->refname))
2383 continue;
2384
661558f0 2385 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
b05855b5
MH
2386 iter->refname, refname);
2387 ref_iterator_abort(iter);
2388 goto cleanup;
2389 }
2390
2391 if (ok != ITER_DONE)
033abf97 2392 BUG("error while iterating over references");
b05855b5
MH
2393
2394 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2395 if (extra_refname)
661558f0 2396 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
b05855b5
MH
2397 refname, extra_refname);
2398 else
2399 ret = 0;
2400
2401cleanup:
2402 strbuf_release(&referent);
2403 strbuf_release(&dirname);
2404 return ret;
62665823 2405}
e3688bd6 2406
7d2df051 2407int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
e3688bd6 2408{
e3688bd6 2409 struct ref_iterator *iter;
4a6067cd 2410 struct do_for_each_ref_help hp = { fn, cb_data };
e3688bd6
DT
2411
2412 iter = refs->be->reflog_iterator_begin(refs);
2413
4a6067cd
SB
2414 return do_for_each_repo_ref_iterator(the_repository, iter,
2415 do_for_each_ref_helper, &hp);
e3688bd6
DT
2416}
2417
7d2df051 2418int for_each_reflog(each_ref_fn fn, void *cb_data)
e3688bd6 2419{
23a3f0cb 2420 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
7d2df051 2421}
e3688bd6 2422
7d2df051
NTND
2423int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2424 const char *refname,
2425 each_reflog_ent_fn fn,
2426 void *cb_data)
2427{
e3688bd6
DT
2428 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2429 fn, cb_data);
2430}
2431
7d2df051
NTND
2432int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2433 void *cb_data)
2434{
23a3f0cb 2435 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
7d2df051
NTND
2436 refname, fn, cb_data);
2437}
2438
2439int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2440 each_reflog_ent_fn fn, void *cb_data)
2441{
2442 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2443}
2444
e3688bd6
DT
2445int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2446 void *cb_data)
2447{
23a3f0cb 2448 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
7d2df051
NTND
2449 fn, cb_data);
2450}
e3688bd6 2451
7d2df051
NTND
2452int refs_reflog_exists(struct ref_store *refs, const char *refname)
2453{
2454 return refs->be->reflog_exists(refs, refname);
e3688bd6
DT
2455}
2456
2457int reflog_exists(const char *refname)
2458{
23a3f0cb 2459 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
7d2df051 2460}
e3688bd6 2461
7d2df051 2462int refs_create_reflog(struct ref_store *refs, const char *refname,
7b089120 2463 struct strbuf *err)
7d2df051 2464{
7b089120 2465 return refs->be->create_reflog(refs, refname, err);
e3688bd6
DT
2466}
2467
7b089120 2468int safe_create_reflog(const char *refname, struct strbuf *err)
e3688bd6 2469{
23a3f0cb 2470 return refs_create_reflog(get_main_ref_store(the_repository), refname,
7b089120 2471 err);
7d2df051 2472}
e3688bd6 2473
7d2df051
NTND
2474int refs_delete_reflog(struct ref_store *refs, const char *refname)
2475{
2476 return refs->be->delete_reflog(refs, refname);
e3688bd6
DT
2477}
2478
2479int delete_reflog(const char *refname)
2480{
23a3f0cb 2481 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
7d2df051 2482}
e3688bd6 2483
7d2df051 2484int refs_reflog_expire(struct ref_store *refs,
cc40b5ce 2485 const char *refname,
7d2df051
NTND
2486 unsigned int flags,
2487 reflog_expiry_prepare_fn prepare_fn,
2488 reflog_expiry_should_prune_fn should_prune_fn,
2489 reflog_expiry_cleanup_fn cleanup_fn,
2490 void *policy_cb_data)
2491{
cc40b5ce 2492 return refs->be->reflog_expire(refs, refname, flags,
7d2df051
NTND
2493 prepare_fn, should_prune_fn,
2494 cleanup_fn, policy_cb_data);
e3688bd6
DT
2495}
2496
cc40b5ce 2497int reflog_expire(const char *refname,
e3688bd6
DT
2498 unsigned int flags,
2499 reflog_expiry_prepare_fn prepare_fn,
2500 reflog_expiry_should_prune_fn should_prune_fn,
2501 reflog_expiry_cleanup_fn cleanup_fn,
2502 void *policy_cb_data)
2503{
23a3f0cb 2504 return refs_reflog_expire(get_main_ref_store(the_repository),
cc40b5ce 2505 refname, flags,
7d2df051
NTND
2506 prepare_fn, should_prune_fn,
2507 cleanup_fn, policy_cb_data);
e3688bd6 2508}
fc681463
DT
2509
2510int initial_ref_transaction_commit(struct ref_transaction *transaction,
2511 struct strbuf *err)
2512{
c0fe4e8b 2513 struct ref_store *refs = transaction->ref_store;
fc681463
DT
2514
2515 return refs->be->initial_transaction_commit(refs, transaction, err);
2516}
a27dcf89 2517
4f2ba2d0
PS
2518void ref_transaction_for_each_queued_update(struct ref_transaction *transaction,
2519 ref_transaction_for_each_queued_update_fn cb,
2520 void *cb_data)
2521{
2522 int i;
2523
2524 for (i = 0; i < transaction->nr; i++) {
2525 struct ref_update *update = transaction->updates[i];
2526
2527 cb(update->refname,
2528 (update->flags & REF_HAVE_OLD) ? &update->old_oid : NULL,
2529 (update->flags & REF_HAVE_NEW) ? &update->new_oid : NULL,
2530 cb_data);
2531 }
2532}
2533
523fa69c 2534int refs_delete_refs(struct ref_store *refs, const char *logmsg,
64da4199 2535 struct string_list *refnames, unsigned int flags)
a27dcf89 2536{
523fa69c
JH
2537 char *msg;
2538 int retval;
2539
2540 msg = normalize_reflog_message(logmsg);
2541 retval = refs->be->delete_refs(refs, msg, refnames, flags);
2542 free(msg);
2543 return retval;
a27dcf89 2544}
9b6b40d9 2545
64da4199
MH
2546int delete_refs(const char *msg, struct string_list *refnames,
2547 unsigned int flags)
9b6b40d9 2548{
23a3f0cb 2549 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
7d2df051 2550}
9b6b40d9 2551
7d2df051
NTND
2552int refs_rename_ref(struct ref_store *refs, const char *oldref,
2553 const char *newref, const char *logmsg)
2554{
523fa69c
JH
2555 char *msg;
2556 int retval;
2557
2558 msg = normalize_reflog_message(logmsg);
2559 retval = refs->be->rename_ref(refs, oldref, newref, msg);
2560 free(msg);
2561 return retval;
9b6b40d9 2562}
7d2df051
NTND
2563
2564int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2565{
23a3f0cb 2566 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
7d2df051 2567}
52d59cc6
SD
2568
2569int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2570 const char *newref, const char *logmsg)
2571{
523fa69c
JH
2572 char *msg;
2573 int retval;
2574
2575 msg = normalize_reflog_message(logmsg);
2576 retval = refs->be->copy_ref(refs, oldref, newref, msg);
2577 free(msg);
2578 return retval;
52d59cc6
SD
2579}
2580
2581int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2582{
23a3f0cb 2583 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
52d59cc6 2584}