blob: 1491ae937eb8c4d5be5dbe9678911fe39be390cd [file] [log] [blame]
Michael Haggerty7bd9bcf2015-11-09 14:34:01 +01001/*
2 * The backend-independent part of the reference module.
3 */
4
Daniel Barkalow95fc7512005-06-06 16:31:29 -04005#include "cache.h"
Brandon Williamsb2141fc2017-06-14 11:07:36 -07006#include "config.h"
Michael Haggerty7d4558c2017-02-10 12:16:15 +01007#include "hashmap.h"
Michael Haggerty697cc8e2014-10-01 12:28:42 +02008#include "lockfile.h"
Michael Haggertyb05855b2017-04-16 08:41:26 +02009#include "iterator.h"
Junio C Hamano85023572006-12-19 14:34:12 -080010#include "refs.h"
Michael Haggerty4cb77002015-11-10 12:42:36 +010011#include "refs/refs-internal.h"
Patrick Steinhardt67541592020-06-19 08:56:14 +020012#include "run-command.h"
Ævar Arnfjörð Bjarmason5e3aba32021-09-26 21:03:26 +020013#include "hook.h"
Stefan Bellercbd53a22018-05-15 16:42:15 -070014#include "object-store.h"
Junio C Hamanocf0adba2006-11-19 13:22:44 -080015#include "object.h"
16#include "tag.h"
Nguyễn Thái Ngọc Duy5d0bc902017-03-26 09:42:31 +070017#include "submodule.h"
Nguyễn Thái Ngọc Duy17eff962017-04-24 17:01:22 +070018#include "worktree.h"
Jeff Kingdbbcd442020-07-28 16:23:39 -040019#include "strvec.h"
Stefan Beller23a3f0c2018-04-11 17:21:09 -070020#include "repository.h"
Patrick Steinhardt67541592020-06-19 08:56:14 +020021#include "sigchain.h"
Ævar Arnfjörð Bjarmason88c7b4c2022-02-16 09:14:02 +010022#include "date.h"
Derrick Stoleeb9342b32022-08-05 17:58:36 +000023#include "commit.h"
Stefan Beller3581d792014-12-12 09:57:02 +010024
Michael Haggertybc5fd6d2012-04-10 07:30:13 +020025/*
Ronnie Sahlberg3dce4442016-09-04 18:08:10 +020026 * 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
Ronnie Sahlberg3dce4442016-09-04 18:08:10 +020039/*
David Turnerdde8a902014-06-03 23:38:10 -040040 * How to handle various characters in refnames:
41 * 0: An acceptable character for refs
Junio C Hamano5e650222014-07-28 10:41:53 -070042 * 1: End-of-component
43 * 2: ., look for a preceding . to reject .. in refs
44 * 3: {, look for a preceding @ to reject @{ in refs
Jacob Keller53a85552015-07-22 14:05:32 -070045 * 4: A bad character: ASCII control characters, and
Jacob Kellercd377f42015-07-22 14:05:33 -070046 * ":", "?", "[", "\", "^", "~", SP, or TAB
47 * 5: *, reject unless REFNAME_REFSPEC_PATTERN is set
David Turnerdde8a902014-06-03 23:38:10 -040048 */
49static unsigned char refname_disposition[256] = {
Junio C Hamano5e650222014-07-28 10:41:53 -070050 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,
Jacob Kellercd377f42015-07-22 14:05:33 -070052 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 1,
Junio C Hamano5e650222014-07-28 10:41:53 -070053 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
David Turnerdde8a902014-06-03 23:38:10 -040054 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
Junio C Hamano5e650222014-07-28 10:41:53 -070055 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
David Turnerdde8a902014-06-03 23:38:10 -040058};
59
Derrick Stoleeb9342b32022-08-05 17:58:36 +000060struct 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
David Turnerdde8a902014-06-03 23:38:10 -0400142/*
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:
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200147 *
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700148 * - it begins with ".", or
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200149 * - it has double dots "..", or
Jacob Keller53a85552015-07-22 14:05:32 -0700150 * - it has ASCII control characters, or
Jacob Kellercd377f42015-07-22 14:05:33 -0700151 * - it has ":", "?", "[", "\", "^", "~", SP, or TAB anywhere, or
152 * - it has "*" anywhere unless REFNAME_REFSPEC_PATTERN is set, or
Jacob Keller53a85552015-07-22 14:05:32 -0700153 * - it ends with a "/", or
154 * - it ends with ".lock", or
155 * - it contains a "@{" portion
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700156 *
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.
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200160 */
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700161static int check_refname_component(const char *refname, int *flags,
162 struct strbuf *sanitized)
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200163{
164 const char *cp;
165 char last = '\0';
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700166 size_t component_start = 0; /* garbage - not a reasonable initial value */
167
168 if (sanitized)
169 component_start = sanitized->len;
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200170
171 for (cp = refname; ; cp++) {
David Turnerdde8a902014-06-03 23:38:10 -0400172 int ch = *cp & 255;
173 unsigned char disp = refname_disposition[ch];
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700174
175 if (sanitized && disp != 1)
176 strbuf_addch(sanitized, ch);
177
David Turnerdde8a902014-06-03 23:38:10 -0400178 switch (disp) {
Junio C Hamano5e650222014-07-28 10:41:53 -0700179 case 1:
David Turnerdde8a902014-06-03 23:38:10 -0400180 goto out;
Junio C Hamano5e650222014-07-28 10:41:53 -0700181 case 2:
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700182 if (last == '.') { /* Refname contains "..". */
183 if (sanitized)
184 /* collapse ".." to single "." */
185 strbuf_setlen(sanitized, sanitized->len - 1);
186 else
187 return -1;
188 }
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200189 break;
Junio C Hamano5e650222014-07-28 10:41:53 -0700190 case 3:
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700191 if (last == '@') { /* Refname contains "@{". */
192 if (sanitized)
193 sanitized->buf[sanitized->len-1] = '-';
194 else
195 return -1;
196 }
David Turnerdde8a902014-06-03 23:38:10 -0400197 break;
Junio C Hamano5e650222014-07-28 10:41:53 -0700198 case 4:
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700199 /* forbidden char */
200 if (sanitized)
201 sanitized->buf[sanitized->len-1] = '-';
202 else
203 return -1;
204 break;
Jacob Kellercd377f42015-07-22 14:05:33 -0700205 case 5:
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700206 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 }
Jacob Kellercd377f42015-07-22 14:05:33 -0700213
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;
David Turnerdde8a902014-06-03 23:38:10 -0400220 }
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200221 last = ch;
222 }
David Turnerdde8a902014-06-03 23:38:10 -0400223out:
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200224 if (cp == refname)
Michael Haggertydac529e2012-04-10 07:30:22 +0200225 return 0; /* Component has zero length. */
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700226
227 if (refname[0] == '.') { /* Component starts with '.'. */
228 if (sanitized)
229 sanitized->buf[component_start] = '-';
230 else
231 return -1;
232 }
Michael Haggerty7108ad22014-10-01 12:28:15 +0200233 if (cp - refname >= LOCK_SUFFIX_LEN &&
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700234 !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 }
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200242 return cp - refname;
243}
244
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700245static int check_or_sanitize_refname(const char *refname, int flags,
246 struct strbuf *sanitized)
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200247{
248 int component_len, component_count = 0;
249
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700250 if (!strcmp(refname, "@")) {
Felipe Contreras9ba89f42013-09-02 01:34:30 -0500251 /* Refname is a single character '@'. */
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700252 if (sanitized)
253 strbuf_addch(sanitized, '-');
254 else
255 return -1;
256 }
Felipe Contreras9ba89f42013-09-02 01:34:30 -0500257
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200258 while (1) {
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700259 if (sanitized && sanitized->len)
260 strbuf_complete(sanitized, '/');
261
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200262 /* We are at the start of a path component. */
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700263 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)
Jacob Kellercd377f42015-07-22 14:05:33 -0700268 return -1;
269
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200270 component_count++;
271 if (refname[component_len] == '\0')
272 break;
273 /* Skip to next component. */
274 refname += component_len + 1;
275 }
276
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700277 if (refname[component_len - 1] == '.') {
278 /* Refname ends with '.'. */
279 if (sanitized)
280 ; /* omit ending dot */
281 else
282 return -1;
283 }
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200284 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
285 return -1; /* Refname has only one component. */
286 return 0;
287}
288
Nguyễn Thái Ngọc Duy1de16ae2019-03-08 16:28:34 +0700289int 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
Michael Haggerty4cb77002015-11-10 12:42:36 +0100300int refname_is_safe(const char *refname)
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700301{
Michael Haggerty39950fe2016-04-27 12:39:11 +0200302 const char *rest;
303
304 if (skip_prefix(refname, "refs/", &rest)) {
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700305 char *buf;
306 int result;
Michael Haggertye40f3552016-04-27 12:40:39 +0200307 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;
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700312
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700313 /*
314 * Does the refname try to escape refs/?
315 * For example: refs/foo/../bar is safe but refs/foo/../../bar
316 * is not.
317 */
Michael Haggertye40f3552016-04-27 12:40:39 +0200318 buf = xmallocz(restlen);
319 result = !normalize_path_copy(buf, rest) && !strcmp(buf, rest);
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700320 free(buf);
321 return result;
322 }
Michael Haggerty35db25c2016-04-27 12:42:27 +0200323
324 do {
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700325 if (!isupper(*refname) && *refname != '_')
326 return 0;
327 refname++;
Michael Haggerty35db25c2016-04-27 12:42:27 +0200328 } while (*refname);
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -0700329 return 1;
330}
331
Michael Haggerty67be7c52017-06-23 09:01:37 +0200332/*
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,
Jonathan Tan9bc45a22021-10-08 14:08:15 -0700338 struct repository *repo,
Michael Haggerty67be7c52017-06-23 09:01:37 +0200339 const struct object_id *oid,
340 unsigned int flags)
341{
342 if (flags & REF_ISBROKEN)
343 return 0;
Jonathan Tan9bc45a22021-10-08 14:08:15 -0700344 if (!repo_has_object_file(repo, oid)) {
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +0200345 error(_("%s does not point to a valid object!"), refname);
Michael Haggerty67be7c52017-06-23 09:01:37 +0200346 return 0;
347 }
348 return 1;
349}
350
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700351char *refs_resolve_refdup(struct ref_store *refs,
352 const char *refname, int resolve_flags,
brian m. carlson0f2dc722017-10-15 22:06:55 +0000353 struct object_id *oid, int *flags)
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700354{
355 const char *result;
356
357 result = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +0100358 oid, flags);
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700359 return xstrdup_or_null(result);
360}
361
Michael Haggertyfb58c8d2015-06-22 16:03:05 +0200362char *resolve_refdup(const char *refname, int resolve_flags,
brian m. carlson0f2dc722017-10-15 22:06:55 +0000363 struct object_id *oid, int *flags)
Nguyễn Thái Ngọc Duy96ec7b12011-12-13 21:17:48 +0700364{
Stefan Beller23a3f0c2018-04-11 17:21:09 -0700365 return refs_resolve_refdup(get_main_ref_store(the_repository),
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700366 refname, resolve_flags,
brian m. carlson0f2dc722017-10-15 22:06:55 +0000367 oid, flags);
Nguyễn Thái Ngọc Duy96ec7b12011-12-13 21:17:48 +0700368}
369
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200370/* The argument to filter_refs */
371struct ref_filter {
372 const char *pattern;
Rafael Ascensão9ab9b5d2018-11-12 13:25:44 +0000373 const char *prefix;
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200374 each_ref_fn *fn;
375 void *cb_data;
376};
377
brian m. carlson34c290a2017-10-15 22:06:56 +0000378int read_ref_full(const char *refname, int resolve_flags, struct object_id *oid, int *flags)
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700379{
Ævar Arnfjörð Bjarmason76887df2021-10-16 11:39:14 +0200380 struct ref_store *refs = get_main_ref_store(the_repository);
381
Ævar Arnfjörð Bjarmasonf1da24c2021-10-16 11:39:27 +0200382 if (refs_resolve_ref_unsafe(refs, refname, resolve_flags,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +0100383 oid, flags))
Ævar Arnfjörð Bjarmason76887df2021-10-16 11:39:14 +0200384 return 0;
385 return -1;
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700386}
387
brian m. carlson34c290a2017-10-15 22:06:56 +0000388int read_ref(const char *refname, struct object_id *oid)
Nguyễn Thái Ngọc Duyc6893322011-11-13 17:22:14 +0700389{
brian m. carlson34c290a2017-10-15 22:06:56 +0000390 return read_ref_full(refname, RESOLVE_REF_READING, oid, NULL);
Nguyễn Thái Ngọc Duyc6893322011-11-13 17:22:14 +0700391}
392
Han-Wen Nienhuys3f9f1ac2020-08-21 16:59:34 +0000393int refs_ref_exists(struct ref_store *refs, const char *refname)
Nguyễn Thái Ngọc Duyb3cd33d2019-04-06 18:34:24 +0700394{
Ævar Arnfjörð Bjarmasonf1da24c2021-10-16 11:39:27 +0200395 return !!refs_resolve_ref_unsafe(refs, refname, RESOLVE_REF_READING,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +0100396 NULL, NULL);
Nguyễn Thái Ngọc Duyb3cd33d2019-04-06 18:34:24 +0700397}
398
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200399int ref_exists(const char *refname)
Junio C Hamanoef06b912006-11-18 22:13:33 -0800400{
Nguyễn Thái Ngọc Duyb3cd33d2019-04-06 18:34:24 +0700401 return refs_ref_exists(get_main_ref_store(the_repository), refname);
Junio C Hamanoef06b912006-11-18 22:13:33 -0800402}
403
Michael Haggerty2b2a5be2015-05-25 18:38:28 +0000404static int filter_refs(const char *refname, const struct object_id *oid,
Michael Haggerty4e675d12015-05-25 18:39:21 +0000405 int flags, void *data)
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200406{
407 struct ref_filter *filter = (struct ref_filter *)data;
Michael Haggerty2b2a5be2015-05-25 18:38:28 +0000408
Ævar Arnfjörð Bjarmason55d34262017-06-22 21:38:08 +0000409 if (wildmatch(filter->pattern, refname, 0))
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200410 return 0;
Rafael Ascensão9ab9b5d2018-11-12 13:25:44 +0000411 if (filter->prefix)
412 skip_prefix(refname, filter->prefix, &refname);
Michael Haggerty2b2a5be2015-05-25 18:38:28 +0000413 return filter->fn(refname, oid, flags, filter->cb_data);
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200414}
415
brian m. carlsonac2ed0d2017-10-15 22:07:10 +0000416enum peel_status peel_object(const struct object_id *name, struct object_id *oid)
Michael Haggertycb2ae1c2013-04-22 21:52:19 +0200417{
Jeff King45a187c2021-04-13 03:16:36 -0400418 struct object *o = lookup_unknown_object(the_repository, name);
Michael Haggertycb2ae1c2013-04-22 21:52:19 +0200419
420 if (o->type == OBJ_NONE) {
Stefan Beller0df8e962018-04-25 11:20:59 -0700421 int type = oid_object_info(the_repository, name, NULL);
Abhishek Kumar6da43d92020-06-17 14:44:08 +0530422 if (type < 0 || !object_as_type(o, type, 0))
Michael Haggerty68cf8702013-04-22 21:52:20 +0200423 return PEEL_INVALID;
Michael Haggertycb2ae1c2013-04-22 21:52:19 +0200424 }
425
426 if (o->type != OBJ_TAG)
Michael Haggerty68cf8702013-04-22 21:52:20 +0200427 return PEEL_NON_TAG;
Michael Haggertycb2ae1c2013-04-22 21:52:19 +0200428
429 o = deref_tag_noverify(o);
430 if (!o)
Michael Haggerty68cf8702013-04-22 21:52:20 +0200431 return PEEL_INVALID;
Michael Haggertycb2ae1c2013-04-22 21:52:19 +0200432
brian m. carlsonac2ed0d2017-10-15 22:07:10 +0000433 oidcpy(oid, &o->oid);
Michael Haggerty68cf8702013-04-22 21:52:20 +0200434 return PEEL_PEELED;
Michael Haggertycb2ae1c2013-04-22 21:52:19 +0200435}
436
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200437struct warn_if_dangling_data {
438 FILE *fp;
439 const char *refname;
Jens Lindströme6bea662014-05-23 12:30:25 +0200440 const struct string_list *refnames;
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200441 const char *msg_fmt;
442};
443
Jeff King63e14ee2022-08-19 06:08:32 -0400444static int warn_if_dangling_symref(const char *refname,
Ævar Arnfjörð Bjarmason5cf88fd2022-08-25 19:09:48 +0200445 const struct object_id *oid UNUSED,
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200446 int flags, void *cb_data)
447{
448 struct warn_if_dangling_data *d = cb_data;
449 const char *resolves_to;
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200450
451 if (!(flags & REF_ISSYMREF))
452 return 0;
453
René Scharfe744c0402017-09-23 11:45:04 +0200454 resolves_to = resolve_ref_unsafe(refname, 0, NULL, NULL);
Jens Lindströme6bea662014-05-23 12:30:25 +0200455 if (!resolves_to
456 || (d->refname
457 ? strcmp(resolves_to, d->refname)
458 : !string_list_has_string(d->refnames, resolves_to))) {
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200459 return 0;
Jens Lindströme6bea662014-05-23 12:30:25 +0200460 }
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200461
462 fprintf(d->fp, d->msg_fmt, refname);
Junio C Hamano1be65ed2012-05-02 13:51:35 -0700463 fputc('\n', d->fp);
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200464 return 0;
465}
466
467void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
468{
469 struct warn_if_dangling_data data;
470
471 data.fp = fp;
472 data.refname = refname;
Jens Lindströme6bea662014-05-23 12:30:25 +0200473 data.refnames = NULL;
474 data.msg_fmt = msg_fmt;
475 for_each_rawref(warn_if_dangling_symref, &data);
476}
477
478void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
479{
480 struct warn_if_dangling_data data;
481
482 data.fp = fp;
483 data.refname = NULL;
484 data.refnames = refnames;
Michael Haggertybc5fd6d2012-04-10 07:30:13 +0200485 data.msg_fmt = msg_fmt;
486 for_each_rawref(warn_if_dangling_symref, &data);
487}
488
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700489int 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
Junio C Hamanocb5d7092006-09-20 21:47:42 -0700494int for_each_tag_ref(each_ref_fn fn, void *cb_data)
Seana62be772006-05-13 21:43:00 -0400495{
Stefan Beller23a3f0c2018-04-11 17:21:09 -0700496 return refs_for_each_tag_ref(get_main_ref_store(the_repository), fn, cb_data);
Seana62be772006-05-13 21:43:00 -0400497}
498
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700499int 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);
Heiko Voigt9ef6aeb2010-07-07 15:39:12 +0200502}
503
Junio C Hamanocb5d7092006-09-20 21:47:42 -0700504int for_each_branch_ref(each_ref_fn fn, void *cb_data)
Seana62be772006-05-13 21:43:00 -0400505{
Stefan Beller23a3f0c2018-04-11 17:21:09 -0700506 return refs_for_each_branch_ref(get_main_ref_store(the_repository), fn, cb_data);
Seana62be772006-05-13 21:43:00 -0400507}
508
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +0700509int 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);
Heiko Voigt9ef6aeb2010-07-07 15:39:12 +0200512}
513
Junio C Hamanocb5d7092006-09-20 21:47:42 -0700514int for_each_remote_ref(each_ref_fn fn, void *cb_data)
Seana62be772006-05-13 21:43:00 -0400515{
Stefan Beller23a3f0c2018-04-11 17:21:09 -0700516 return refs_for_each_remote_ref(get_main_ref_store(the_repository), fn, cb_data);
Junio C Hamanof8948e22009-02-08 23:27:10 -0800517}
518
Josh Tripletta1bea2c2011-07-05 10:54:44 -0700519int head_ref_namespaced(each_ref_fn fn, void *cb_data)
520{
521 struct strbuf buf = STRBUF_INIT;
522 int ret = 0;
Michael Haggerty2b2a5be2015-05-25 18:38:28 +0000523 struct object_id oid;
Josh Tripletta1bea2c2011-07-05 10:54:44 -0700524 int flag;
525
526 strbuf_addf(&buf, "%sHEAD", get_git_namespace());
brian m. carlson34c290a2017-10-15 22:06:56 +0000527 if (!read_ref_full(buf.buf, RESOLVE_REF_READING, &oid, &flag))
Michael Haggerty2b2a5be2015-05-25 18:38:28 +0000528 ret = fn(buf.buf, &oid, flag, cb_data);
Josh Tripletta1bea2c2011-07-05 10:54:44 -0700529 strbuf_release(&buf);
530
531 return ret;
532}
533
Rafael Ascensão65516f52017-11-21 21:33:41 +0000534void 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
Derrick Stoleeb877e612022-08-05 17:58:33 +0000542 if (prefix)
Rafael Ascensão65516f52017-11-21 21:33:41 +0000543 strbuf_addstr(&normalized_pattern, prefix);
Derrick Stoleeb877e612022-08-05 17:58:33 +0000544 else if (!starts_with(pattern, "refs/") &&
545 strcmp(pattern, "HEAD"))
Rafael Ascensão65516f52017-11-21 21:33:41 +0000546 strbuf_addstr(&normalized_pattern, "refs/");
Derrick Stoleeb877e612022-08-05 17:58:33 +0000547 /*
548 * NEEDSWORK: Special case other symrefs such as REBASE_HEAD,
549 * MERGE_HEAD, etc.
550 */
551
Rafael Ascensão65516f52017-11-21 21:33:41 +0000552 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
Ilari Liusvaarab09fe972010-01-20 11:48:26 +0200560int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
561 const char *prefix, void *cb_data)
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200562{
563 struct strbuf real_pattern = STRBUF_INIT;
564 struct ref_filter filter;
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200565 int ret;
566
Christian Couder59556542013-11-30 21:55:40 +0100567 if (!prefix && !starts_with(pattern, "refs/"))
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200568 strbuf_addstr(&real_pattern, "refs/");
Ilari Liusvaarab09fe972010-01-20 11:48:26 +0200569 else if (prefix)
570 strbuf_addstr(&real_pattern, prefix);
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200571 strbuf_addstr(&real_pattern, pattern);
572
Thomas Rast894a9d32010-03-12 18:04:26 +0100573 if (!has_glob_specials(pattern)) {
Junio C Hamano9517e6b2010-02-03 21:23:18 -0800574 /* Append implied '/' '*' if not present. */
Jeff King00b6c172015-09-24 17:08:35 -0400575 strbuf_complete(&real_pattern, '/');
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200576 /* No need to check for '*', there is none. */
577 strbuf_addch(&real_pattern, '*');
578 }
579
580 filter.pattern = real_pattern.buf;
Rafael Ascensão9ab9b5d2018-11-12 13:25:44 +0000581 filter.prefix = prefix;
Ilari Liusvaarad08bae72010-01-20 11:48:25 +0200582 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
Ilari Liusvaarab09fe972010-01-20 11:48:26 +0200590int 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
Felipe Contreras4577e482009-05-14 00:22:04 +0300595const char *prettify_refname(const char *name)
Daniel Barkalowa9c37a72009-03-08 21:06:05 -0400596{
SZEDER Gábor3e5b36c2017-03-23 16:50:12 +0100597 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;
Daniel Barkalowa9c37a72009-03-08 21:06:05 -0400602}
603
Michael Haggerty54457fe2014-01-14 04:16:07 +0100604static const char *ref_rev_parse_rules[] = {
Steffen Prohaska79803322007-11-11 15:01:46 +0100605 "%.*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
Junio C Hamano60650a42018-08-01 09:22:37 -0700614#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 */
Michael Haggerty54457fe2014-01-14 04:16:07 +0100623int refname_match(const char *abbrev_name, const char *full_name)
Steffen Prohaska79803322007-11-11 15:01:46 +0100624{
625 const char **p;
626 const int abbrev_name_len = strlen(abbrev_name);
Junio C Hamano60650a42018-08-01 09:22:37 -0700627 const int num_rules = NUM_REV_PARSE_RULES;
Steffen Prohaska79803322007-11-11 15:01:46 +0100628
Junio C Hamano60650a42018-08-01 09:22:37 -0700629 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;
Steffen Prohaska79803322007-11-11 15:01:46 +0100632
633 return 0;
634}
635
Michael Haggerty19b68b12011-12-12 06:38:12 +0100636/*
Brandon Williamsb4be7412018-03-15 10:31:24 -0700637 * Given a 'prefix' expand it by the rules in 'ref_rev_parse_rules' and add
638 * the results to 'prefixes'
639 */
Jeff Kingc972bf42020-07-28 16:25:12 -0400640void expand_ref_prefix(struct strvec *prefixes, const char *prefix)
Brandon Williamsb4be7412018-03-15 10:31:24 -0700641{
642 const char **p;
643 int len = strlen(prefix);
644
645 for (p = ref_rev_parse_rules; *p; p++)
Jeff Kingc972bf42020-07-28 16:25:12 -0400646 strvec_pushf(prefixes, *p, len, prefix);
Brandon Williamsb4be7412018-03-15 10:31:24 -0700647}
648
Johannes Schindelin675704c2020-12-11 11:36:57 +0000649static 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
Johannes Schindelincc0f13c2020-12-11 11:36:56 +0000662char *repo_default_branch_name(struct repository *r, int quiet)
Don Goodman-Wilson8747ebb2020-06-24 14:46:33 +0000663{
664 const char *config_key = "init.defaultbranch";
665 const char *config_display_key = "init.defaultBranch";
666 char *ret = NULL, *full_ref;
Johannes Schindelin704fed92020-10-23 14:00:00 +0000667 const char *env = getenv("GIT_TEST_DEFAULT_INITIAL_BRANCH_NAME");
Don Goodman-Wilson8747ebb2020-06-24 14:46:33 +0000668
Johannes Schindelin704fed92020-10-23 14:00:00 +0000669 if (env && *env)
670 ret = xstrdup(env);
671 else if (repo_config_get_string(r, config_key, &ret) < 0)
Don Goodman-Wilson8747ebb2020-06-24 14:46:33 +0000672 die(_("could not retrieve `%s`"), config_display_key);
673
Johannes Schindelin675704c2020-12-11 11:36:57 +0000674 if (!ret) {
Don Goodman-Wilson8747ebb2020-06-24 14:46:33 +0000675 ret = xstrdup("master");
Johannes Schindelin675704c2020-12-11 11:36:57 +0000676 if (!quiet)
677 advise(_(default_branch_name_advice), ret);
678 }
Don Goodman-Wilson8747ebb2020-06-24 14:46:33 +0000679
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
Johannes Schindelincc0f13c2020-12-11 11:36:56 +0000688const char *git_default_branch_name(int quiet)
Don Goodman-Wilson8747ebb2020-06-24 14:46:33 +0000689{
690 static char *ret;
691
692 if (!ret)
Johannes Schindelincc0f13c2020-12-11 11:36:56 +0000693 ret = repo_default_branch_name(the_repository, quiet);
Don Goodman-Wilson8747ebb2020-06-24 14:46:33 +0000694
695 return ret;
696}
697
Brandon Williamsb4be7412018-03-15 10:31:24 -0700698/*
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700699 * *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 */
Nguyễn Thái Ngọc Duy8f56e9d2019-04-06 18:34:26 +0700703static char *substitute_branch_name(struct repository *r,
Jonathan Tanf24c30e2020-09-01 15:28:09 -0700704 const char **string, int *len,
705 int nonfatal_dangling_mark)
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700706{
707 struct strbuf buf = STRBUF_INIT;
Jonathan Tanf24c30e2020-09-01 15:28:09 -0700708 struct interpret_branch_name_options options = {
709 .nonfatal_dangling_mark = nonfatal_dangling_mark
710 };
Jonathan Tana4f66a72020-09-01 15:28:07 -0700711 int ret = repo_interpret_branch_name(r, *string, *len, &buf, &options);
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700712
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
Nguyễn Thái Ngọc Duyd8984c52019-04-06 18:34:28 +0700723int repo_dwim_ref(struct repository *r, const char *str, int len,
Jonathan Tanf24c30e2020-09-01 15:28:09 -0700724 struct object_id *oid, char **ref, int nonfatal_dangling_mark)
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700725{
Jonathan Tanf24c30e2020-09-01 15:28:09 -0700726 char *last_branch = substitute_branch_name(r, &str, &len,
727 nonfatal_dangling_mark);
Nguyễn Thái Ngọc Duyd8984c52019-04-06 18:34:28 +0700728 int refs_found = expand_ref(r, str, len, oid, ref);
Nguyễn Thái Ngọc Duy41da7112016-06-12 17:54:02 +0700729 free(last_branch);
730 return refs_found;
731}
732
Nguyễn Thái Ngọc Duy0b1dbf52019-04-06 18:34:27 +0700733int expand_ref(struct repository *repo, const char *str, int len,
734 struct object_id *oid, char **ref)
Nguyễn Thái Ngọc Duy41da7112016-06-12 17:54:02 +0700735{
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700736 const char **p, *r;
737 int refs_found = 0;
Jeff King6cd4a892017-03-28 15:46:33 -0400738 struct strbuf fullref = STRBUF_INIT;
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700739
740 *ref = NULL;
741 for (p = ref_rev_parse_rules; *p; p++) {
brian m. carlsoncca5fa62017-10-15 22:06:57 +0000742 struct object_id oid_from_ref;
743 struct object_id *this_result;
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700744 int flag;
Ævar Arnfjörð Bjarmason6582bd32021-10-16 11:39:24 +0200745 struct ref_store *refs = get_main_ref_store(repo);
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700746
brian m. carlsoncca5fa62017-10-15 22:06:57 +0000747 this_result = refs_found ? &oid_from_ref : oid;
Jeff King6cd4a892017-03-28 15:46:33 -0400748 strbuf_reset(&fullref);
749 strbuf_addf(&fullref, *p, len, str);
Ævar Arnfjörð Bjarmasonf1da24c2021-10-16 11:39:27 +0200750 r = refs_resolve_ref_unsafe(refs, fullref.buf,
Ævar Arnfjörð Bjarmason6582bd32021-10-16 11:39:24 +0200751 RESOLVE_REF_READING,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +0100752 this_result, &flag);
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700753 if (r) {
754 if (!refs_found++)
755 *ref = xstrdup(r);
756 if (!warn_ambiguous_refs)
757 break;
Jeff King6cd4a892017-03-28 15:46:33 -0400758 } else if ((flag & REF_ISSYMREF) && strcmp(fullref.buf, "HEAD")) {
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +0200759 warning(_("ignoring dangling symref %s"), fullref.buf);
Jeff King6cd4a892017-03-28 15:46:33 -0400760 } else if ((flag & REF_ISBROKEN) && strchr(fullref.buf, '/')) {
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +0200761 warning(_("ignoring broken ref %s"), fullref.buf);
Junio C Hamano55956352011-10-19 13:55:49 -0700762 }
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700763 }
Jeff King6cd4a892017-03-28 15:46:33 -0400764 strbuf_release(&fullref);
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700765 return refs_found;
766}
767
Nguyễn Thái Ngọc Duy56700902019-04-06 18:34:29 +0700768int repo_dwim_log(struct repository *r, const char *str, int len,
769 struct object_id *oid, char **log)
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700770{
Nguyễn Thái Ngọc Duy56700902019-04-06 18:34:29 +0700771 struct ref_store *refs = get_main_ref_store(r);
Jonathan Tanf24c30e2020-09-01 15:28:09 -0700772 char *last_branch = substitute_branch_name(r, &str, &len, 0);
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700773 const char **p;
774 int logs_found = 0;
Jeff King6cd4a892017-03-28 15:46:33 -0400775 struct strbuf path = STRBUF_INIT;
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700776
777 *log = NULL;
778 for (p = ref_rev_parse_rules; *p; p++) {
brian m. carlson334dc522017-10-15 22:06:59 +0000779 struct object_id hash;
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700780 const char *ref, *it;
781
Jeff King6cd4a892017-03-28 15:46:33 -0400782 strbuf_reset(&path);
783 strbuf_addf(&path, *p, len, str);
Nguyễn Thái Ngọc Duy56700902019-04-06 18:34:29 +0700784 ref = refs_resolve_ref_unsafe(refs, path.buf,
785 RESOLVE_REF_READING,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +0100786 oid ? &hash : NULL, NULL);
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700787 if (!ref)
788 continue;
Nguyễn Thái Ngọc Duy56700902019-04-06 18:34:29 +0700789 if (refs_reflog_exists(refs, path.buf))
Jeff King6cd4a892017-03-28 15:46:33 -0400790 it = path.buf;
Nguyễn Thái Ngọc Duy56700902019-04-06 18:34:29 +0700791 else if (strcmp(ref, path.buf) &&
792 refs_reflog_exists(refs, ref))
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700793 it = ref;
794 else
795 continue;
796 if (!logs_found++) {
797 *log = xstrdup(it);
Ævar Arnfjörð Bjarmason6f45ec82021-08-23 13:36:08 +0200798 if (oid)
799 oidcpy(oid, &hash);
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700800 }
801 if (!warn_ambiguous_refs)
802 break;
803 }
Jeff King6cd4a892017-03-28 15:46:33 -0400804 strbuf_release(&path);
Junio C Hamanoff74f7f2011-10-12 10:35:38 -0700805 free(last_branch);
806 return logs_found;
807}
808
Nguyễn Thái Ngọc Duy56700902019-04-06 18:34:29 +0700809int 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
Han-Wen Nienhuys71e54732022-09-19 16:34:50 +0000814int is_per_worktree_ref(const char *refname)
David Turner266b1822015-07-31 02:06:18 -0400815{
Han-Wen Nienhuys55dd8b92020-07-27 16:25:47 +0000816 return starts_with(refname, "refs/worktree/") ||
817 starts_with(refname, "refs/bisect/") ||
818 starts_with(refname, "refs/rewritten/");
David Turner266b1822015-07-31 02:06:18 -0400819}
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
Han-Wen Nienhuys71e54732022-09-19 16:34:50 +0000830 /*
831 * HEAD is not a pseudoref, but it certainly uses the
832 * pseudoref syntax.
833 */
David Turner266b1822015-07-31 02:06:18 -0400834 return 1;
835}
836
Han-Wen Nienhuys71e54732022-09-19 16:34:50 +0000837static int is_current_worktree_ref(const char *ref) {
838 return is_pseudoref_syntax(ref) || is_per_worktree_ref(ref);
Nguyễn Thái Ngọc Duy3a3b9d82018-10-21 10:08:54 +0200839}
840
Han-Wen Nienhuys71e54732022-09-19 16:34:50 +0000841enum 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)
Nguyễn Thái Ngọc Duy3a3b9d82018-10-21 10:08:54 +0200844{
Han-Wen Nienhuys71e54732022-09-19 16:34:50 +0000845 const char *name_dummy;
846 int name_length_dummy;
847 const char *ref_dummy;
Nguyễn Thái Ngọc Duy3a3b9d82018-10-21 10:08:54 +0200848
Han-Wen Nienhuys71e54732022-09-19 16:34:50 +0000849 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;
David Turner266b1822015-07-31 02:06:18 -0400887}
888
Michael Haggerty4ff0f012017-08-21 13:51:34 +0200889long 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
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +0700904int refs_delete_ref(struct ref_store *refs, const char *msg,
905 const char *refname,
brian m. carlson2616a5e2017-10-15 22:06:50 +0000906 const struct object_id *old_oid,
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +0700907 unsigned int flags)
Junio C Hamanoc0277d12006-09-30 15:02:00 -0700908{
Ronnie Sahlberg7521cc42014-04-30 09:22:45 -0700909 struct ref_transaction *transaction;
910 struct strbuf err = STRBUF_INIT;
Junio C Hamanoc0277d12006-09-30 15:02:00 -0700911
Junio C Hamanoc6da34a2022-04-13 15:51:33 -0700912 transaction = ref_store_transaction_begin(refs, &err);
Ronnie Sahlberg7521cc42014-04-30 09:22:45 -0700913 if (!transaction ||
brian m. carlson89f3bbd2017-10-15 22:06:53 +0000914 ref_transaction_delete(transaction, refname, old_oid,
Kyle Meyer755b49a2017-02-20 20:10:32 -0500915 flags, msg, &err) ||
Ronnie Sahlbergdb7516a2014-04-30 12:22:42 -0700916 ref_transaction_commit(transaction, &err)) {
Ronnie Sahlberg7521cc42014-04-30 09:22:45 -0700917 error("%s", err.buf);
918 ref_transaction_free(transaction);
919 strbuf_release(&err);
Junio C Hamanoc0277d12006-09-30 15:02:00 -0700920 return 1;
Ronnie Sahlberg7521cc42014-04-30 09:22:45 -0700921 }
922 ref_transaction_free(transaction);
923 strbuf_release(&err);
924 return 0;
Shawn Pearce4bd18c42006-05-17 05:55:02 -0400925}
926
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +0700927int delete_ref(const char *msg, const char *refname,
brian m. carlson2616a5e2017-10-15 22:06:50 +0000928 const struct object_id *old_oid, unsigned int flags)
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +0700929{
Stefan Beller23a3f0c2018-04-11 17:21:09 -0700930 return refs_delete_ref(get_main_ref_store(the_repository), msg, refname,
brian m. carlson2616a5e2017-10-15 22:06:50 +0000931 old_oid, flags);
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +0700932}
933
Junio C Hamano523fa692020-07-10 17:19:53 +0000934static void copy_reflog_msg(struct strbuf *sb, const char *msg)
Junio C Hamano0ec29a42007-07-28 17:17:17 -0700935{
Junio C Hamano0ec29a42007-07-28 17:17:17 -0700936 char c;
937 int wasspace = 1;
938
Junio C Hamano0ec29a42007-07-28 17:17:17 -0700939 while ((c = *msg++)) {
940 if (wasspace && isspace(c))
941 continue;
942 wasspace = isspace(c);
943 if (wasspace)
944 c = ' ';
Ben Peart80a6c202018-07-10 21:08:22 +0000945 strbuf_addch(sb, c);
Junio C Hamano0ec29a42007-07-28 17:17:17 -0700946 }
Ben Peart80a6c202018-07-10 21:08:22 +0000947 strbuf_rtrim(sb);
Junio C Hamano0ec29a42007-07-28 17:17:17 -0700948}
949
Junio C Hamano523fa692020-07-10 17:19:53 +0000950static 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
Michael Haggerty4cb77002015-11-10 12:42:36 +0100959int should_autocreate_reflog(const char *refname)
David Turner4e2bef52015-07-21 17:04:51 -0400960{
Cornelius Weig341fb282017-01-27 11:09:47 +0100961 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:
David Turner4e2bef52015-07-21 17:04:51 -0400970 return 0;
Cornelius Weig341fb282017-01-27 11:09:47 +0100971 }
David Turner4e2bef52015-07-21 17:04:51 -0400972}
973
Ronnie Sahlberge7e0f262014-07-15 16:02:38 -0700974int is_branch(const char *refname)
Linus Torvaldsc3b0dec2008-01-15 15:50:17 -0800975{
Christian Couder59556542013-11-30 21:55:40 +0100976 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
Linus Torvaldsc3b0dec2008-01-15 15:50:17 -0800977}
978
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -0700979struct read_ref_at_cb {
980 const char *refname;
Johannes Schindelindddbad72017-04-26 21:29:31 +0200981 timestamp_t at_time;
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -0700982 int cnt;
983 int reccnt;
brian m. carlson8eb36d92017-10-15 22:07:03 +0000984 struct object_id *oid;
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -0700985 int found_it;
986
brian m. carlson8eb36d92017-10-15 22:07:03 +0000987 struct object_id ooid;
988 struct object_id noid;
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -0700989 int tz;
Johannes Schindelindddbad72017-04-26 21:29:31 +0200990 timestamp_t date;
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -0700991 char **msg;
Johannes Schindelindddbad72017-04-26 21:29:31 +0200992 timestamp_t *cutoff_time;
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -0700993 int *cutoff_tz;
994 int *cutoff_cnt;
995};
996
Denton Liu95c2a712021-01-06 01:01:53 -0800997static 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
brian m. carlson9461d272017-02-21 23:47:32 +00001010static int read_ref_at_ent(struct object_id *ooid, struct object_id *noid,
Ævar Arnfjörð Bjarmason5cf88fd2022-08-25 19:09:48 +02001011 const char *email UNUSED,
Jeff Kingc006e9f2022-08-19 06:08:35 -04001012 timestamp_t timestamp, int tz,
1013 const char *message, void *cb_data)
Junio C Hamano16d7cc92007-01-19 01:19:05 -08001014{
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001015 struct read_ref_at_cb *cb = cb_data;
Denton Liu6436a202021-01-07 02:36:59 -08001016 int reached_count;
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001017
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001018 cb->tz = tz;
1019 cb->date = timestamp;
1020
Denton Liu6436a202021-01-07 02:36:59 -08001021 /*
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) {
Denton Liu95c2a712021-01-06 01:01:53 -08001029 set_read_ref_cutoffs(cb, timestamp, tz, message);
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001030 /*
Michael Haggerty78fb4572017-11-05 09:42:09 +01001031 * we have not yet updated cb->[n|o]oid so they still
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001032 * hold the values for the previous record.
1033 */
Denton Liu6436a202021-01-07 02:36:59 -08001034 if (!is_null_oid(&cb->ooid) && !oideq(&cb->ooid, noid))
1035 warning(_("log for ref %s has gap after %s"),
Jeff Kinga5481a62015-06-25 12:55:02 -04001036 cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
Denton Liu6436a202021-01-07 02:36:59 -08001037 if (reached_count)
1038 oidcpy(cb->oid, ooid);
1039 else if (!is_null_oid(&cb->ooid) || cb->date == cb->at_time)
brian m. carlson8eb36d92017-10-15 22:07:03 +00001040 oidcpy(cb->oid, noid);
Jeff King9001dc22018-08-28 17:22:48 -04001041 else if (!oideq(noid, cb->oid))
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02001042 warning(_("log for ref %s unexpectedly ended on %s"),
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001043 cb->refname, show_date(cb->date, cb->tz,
Jeff Kinga5481a62015-06-25 12:55:02 -04001044 DATE_MODE(RFC2822)));
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001045 cb->found_it = 1;
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001046 }
Denton Liu95c2a712021-01-06 01:01:53 -08001047 cb->reccnt++;
brian m. carlson8eb36d92017-10-15 22:07:03 +00001048 oidcpy(&cb->ooid, ooid);
1049 oidcpy(&cb->noid, noid);
Denton Liu6436a202021-01-07 02:36:59 -08001050 return cb->found_it;
1051}
1052
Ævar Arnfjörð Bjarmason5cf88fd2022-08-25 19:09:48 +02001053static int read_ref_at_ent_newest(struct object_id *ooid UNUSED,
Jeff King63e14ee2022-08-19 06:08:32 -04001054 struct object_id *noid,
Ævar Arnfjörð Bjarmason5cf88fd2022-08-25 19:09:48 +02001055 const char *email UNUSED,
Jeff King63e14ee2022-08-19 06:08:32 -04001056 timestamp_t timestamp, int tz,
1057 const char *message, void *cb_data)
Denton Liu6436a202021-01-07 02:36:59 -08001058{
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;
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001065}
1066
brian m. carlson9461d272017-02-21 23:47:32 +00001067static int read_ref_at_ent_oldest(struct object_id *ooid, struct object_id *noid,
Ævar Arnfjörð Bjarmason5cf88fd2022-08-25 19:09:48 +02001068 const char *email UNUSED,
Jeff Kingc006e9f2022-08-19 06:08:35 -04001069 timestamp_t timestamp, int tz,
1070 const char *message, void *cb_data)
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001071{
1072 struct read_ref_at_cb *cb = cb_data;
1073
Denton Liu95c2a712021-01-06 01:01:53 -08001074 set_read_ref_cutoffs(cb, timestamp, tz, message);
brian m. carlson8eb36d92017-10-15 22:07:03 +00001075 oidcpy(cb->oid, ooid);
1076 if (is_null_oid(cb->oid))
1077 oidcpy(cb->oid, noid);
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001078 /* We just want the first entry */
1079 return 1;
Junio C Hamano16d7cc92007-01-19 01:19:05 -08001080}
1081
Nguyễn Thái Ngọc Duy7fdff472019-04-06 18:34:30 +07001082int read_ref_at(struct ref_store *refs, const char *refname,
1083 unsigned int flags, timestamp_t at_time, int cnt,
brian m. carlson8eb36d92017-10-15 22:07:03 +00001084 struct object_id *oid, char **msg,
Johannes Schindelindddbad72017-04-26 21:29:31 +02001085 timestamp_t *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
Shawn Pearced556fae2006-05-17 05:56:09 -04001086{
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001087 struct read_ref_at_cb cb;
Shawn Pearced556fae2006-05-17 05:56:09 -04001088
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001089 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;
brian m. carlson8eb36d92017-10-15 22:07:03 +00001097 cb.oid = oid;
Shawn Pearced556fae2006-05-17 05:56:09 -04001098
Denton Liu6436a202021-01-07 02:36:59 -08001099 if (cb.cnt == 0) {
1100 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent_newest, &cb);
1101 return 0;
1102 }
1103
Nguyễn Thái Ngọc Duy7fdff472019-04-06 18:34:30 +07001104 refs_for_each_reflog_ent_reverse(refs, refname, read_ref_at_ent, &cb);
Shawn Pearced556fae2006-05-17 05:56:09 -04001105
David Aguilarc41a87d2014-09-18 20:45:37 -07001106 if (!cb.reccnt) {
brian m. carlson321c89b2017-07-13 23:49:29 +00001107 if (flags & GET_OID_QUIETLY)
David Aguilarc41a87d2014-09-18 20:45:37 -07001108 exit(128);
1109 else
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02001110 die(_("log for %s is empty"), refname);
David Aguilarc41a87d2014-09-18 20:45:37 -07001111 }
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001112 if (cb.found_it)
1113 return 0;
Junio C Hamano16d7cc92007-01-19 01:19:05 -08001114
Nguyễn Thái Ngọc Duy7fdff472019-04-06 18:34:30 +07001115 refs_for_each_reflog_ent(refs, refname, read_ref_at_ent_oldest, &cb);
Ronnie Sahlberg4207ed22014-06-03 09:09:59 -07001116
Junio C Hamano16d7cc92007-01-19 01:19:05 -08001117 return 1;
Shawn Pearced556fae2006-05-17 05:56:09 -04001118}
Junio C Hamano2ff81662006-12-18 01:18:16 -08001119
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07001120struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
1121 struct strbuf *err)
Michael Haggertycaa40462014-04-07 15:48:10 +02001122{
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07001123 struct ref_transaction *tr;
Jonathan Nieder5a603b02014-08-28 16:42:37 -07001124 assert(err);
1125
René Scharfeca56dad2021-03-13 17:17:22 +01001126 CALLOC_ARRAY(tr, 1);
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07001127 tr->ref_store = refs;
1128 return tr;
1129}
1130
1131struct ref_transaction *ref_transaction_begin(struct strbuf *err)
1132{
Junio C Hamanoc6da34a2022-04-13 15:51:33 -07001133 return ref_store_transaction_begin(get_main_ref_store(the_repository), err);
Michael Haggertycaa40462014-04-07 15:48:10 +02001134}
1135
Ronnie Sahlberg026bd1d2014-06-20 07:42:42 -07001136void ref_transaction_free(struct ref_transaction *transaction)
Michael Haggertycaa40462014-04-07 15:48:10 +02001137{
Michael Haggerty43a2dfd2017-05-22 16:17:37 +02001138 size_t i;
Michael Haggertycaa40462014-04-07 15:48:10 +02001139
Ronnie Sahlberg1b072552014-06-20 07:42:45 -07001140 if (!transaction)
1141 return;
1142
Michael Haggerty30173b82017-05-22 16:17:44 +02001143 switch (transaction->state) {
1144 case REF_TRANSACTION_OPEN:
1145 case REF_TRANSACTION_CLOSED:
1146 /* OK */
1147 break;
1148 case REF_TRANSACTION_PREPARED:
Johannes Schindelin033abf92018-05-02 11:38:39 +02001149 BUG("free called on a prepared reference transaction");
Michael Haggerty30173b82017-05-22 16:17:44 +02001150 break;
1151 default:
Johannes Schindelin033abf92018-05-02 11:38:39 +02001152 BUG("unexpected reference transaction state");
Michael Haggerty30173b82017-05-22 16:17:44 +02001153 break;
1154 }
1155
Ronnie Sahlbergdb7516a2014-04-30 12:22:42 -07001156 for (i = 0; i < transaction->nr; i++) {
1157 free(transaction->updates[i]->msg);
Michael Haggerty88615912014-04-07 15:48:14 +02001158 free(transaction->updates[i]);
Ronnie Sahlbergdb7516a2014-04-30 12:22:42 -07001159 }
Michael Haggertycaa40462014-04-07 15:48:10 +02001160 free(transaction->updates);
1161 free(transaction);
1162}
1163
Michael Haggerty71564512016-04-25 11:39:54 +02001164struct ref_update *ref_transaction_add_update(
1165 struct ref_transaction *transaction,
1166 const char *refname, unsigned int flags,
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001167 const struct object_id *new_oid,
1168 const struct object_id *old_oid,
Michael Haggerty71564512016-04-25 11:39:54 +02001169 const char *msg)
Michael Haggertycaa40462014-04-07 15:48:10 +02001170{
Jeff King96ffc062016-02-22 17:44:32 -05001171 struct ref_update *update;
Michael Haggerty71564512016-04-25 11:39:54 +02001172
1173 if (transaction->state != REF_TRANSACTION_OPEN)
Johannes Schindelin033abf92018-05-02 11:38:39 +02001174 BUG("update called for transaction that is not open");
Michael Haggerty71564512016-04-25 11:39:54 +02001175
Jeff King96ffc062016-02-22 17:44:32 -05001176 FLEX_ALLOC_STR(update, refname, refname);
Michael Haggertycaa40462014-04-07 15:48:10 +02001177 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
1178 transaction->updates[transaction->nr++] = update;
Michael Haggerty71564512016-04-25 11:39:54 +02001179
1180 update->flags = flags;
1181
1182 if (flags & REF_HAVE_NEW)
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001183 oidcpy(&update->new_oid, new_oid);
Michael Haggerty71564512016-04-25 11:39:54 +02001184 if (flags & REF_HAVE_OLD)
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001185 oidcpy(&update->old_oid, old_oid);
Junio C Hamano523fa692020-07-10 17:19:53 +00001186 update->msg = normalize_reflog_message(msg);
Michael Haggertycaa40462014-04-07 15:48:10 +02001187 return update;
1188}
1189
Ronnie Sahlberg8e348002014-06-20 07:43:00 -07001190int ref_transaction_update(struct ref_transaction *transaction,
1191 const char *refname,
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001192 const struct object_id *new_oid,
1193 const struct object_id *old_oid,
Michael Haggerty1d147bd2015-02-17 18:00:15 +01001194 unsigned int flags, const char *msg,
Ronnie Sahlberg8e348002014-06-20 07:43:00 -07001195 struct strbuf *err)
Michael Haggertycaa40462014-04-07 15:48:10 +02001196{
Jonathan Nieder5a603b02014-08-28 16:42:37 -07001197 assert(err);
1198
Han-Wen Nienhuys3c966c72021-12-07 13:38:18 +00001199 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))) {
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02001203 strbuf_addf(err, _("refusing to update ref with bad name '%s'"),
Ronnie Sahlbergd0f810f2014-09-03 11:45:43 -07001204 refname);
1205 return -1;
1206 }
1207
Michael Haggertya9bbbce2017-11-05 09:42:03 +01001208 if (flags & ~REF_TRANSACTION_UPDATE_ALLOWED_FLAGS)
1209 BUG("illegal flags 0x%x passed to ref_transaction_update()", flags);
Thomas Gummererc788c542017-09-12 23:59:21 +01001210
Jeff King49f1eb32021-11-19 16:28:30 -05001211 /*
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
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001218 flags |= (new_oid ? REF_HAVE_NEW : 0) | (old_oid ? REF_HAVE_OLD : 0);
Michael Haggerty71564512016-04-25 11:39:54 +02001219
1220 ref_transaction_add_update(transaction, refname, flags,
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001221 new_oid, old_oid, msg);
Ronnie Sahlberg8e348002014-06-20 07:43:00 -07001222 return 0;
Michael Haggertycaa40462014-04-07 15:48:10 +02001223}
1224
Ronnie Sahlbergb416af52014-04-16 15:26:44 -07001225int ref_transaction_create(struct ref_transaction *transaction,
1226 const char *refname,
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001227 const struct object_id *new_oid,
Michael Haggertyfec14ec2015-02-17 18:00:13 +01001228 unsigned int flags, const char *msg,
Ronnie Sahlbergb416af52014-04-16 15:26:44 -07001229 struct strbuf *err)
Michael Haggertycaa40462014-04-07 15:48:10 +02001230{
Derrick Stoleed097a232022-04-25 13:47:30 +00001231 if (!new_oid || is_null_oid(new_oid)) {
1232 strbuf_addf(err, "'%s' has a null OID", refname);
1233 return 1;
1234 }
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001235 return ref_transaction_update(transaction, refname, new_oid,
brian m. carlson14228442021-04-26 01:02:56 +00001236 null_oid(), flags, msg, err);
Michael Haggertycaa40462014-04-07 15:48:10 +02001237}
1238
Ronnie Sahlberg8c8bdc02014-04-16 15:27:45 -07001239int ref_transaction_delete(struct ref_transaction *transaction,
1240 const char *refname,
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001241 const struct object_id *old_oid,
Michael Haggertyfb5a6bb2015-02-17 18:00:16 +01001242 unsigned int flags, const char *msg,
Ronnie Sahlberg8c8bdc02014-04-16 15:27:45 -07001243 struct strbuf *err)
Michael Haggertycaa40462014-04-07 15:48:10 +02001244{
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001245 if (old_oid && is_null_oid(old_oid))
Johannes Schindelin033abf92018-05-02 11:38:39 +02001246 BUG("delete called with old_oid set to zeros");
Michael Haggerty1d147bd2015-02-17 18:00:15 +01001247 return ref_transaction_update(transaction, refname,
brian m. carlson14228442021-04-26 01:02:56 +00001248 null_oid(), old_oid,
Michael Haggerty1d147bd2015-02-17 18:00:15 +01001249 flags, msg, err);
Michael Haggertycaa40462014-04-07 15:48:10 +02001250}
1251
Michael Haggerty16180332015-02-17 18:00:21 +01001252int ref_transaction_verify(struct ref_transaction *transaction,
1253 const char *refname,
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001254 const struct object_id *old_oid,
Michael Haggerty16180332015-02-17 18:00:21 +01001255 unsigned int flags,
1256 struct strbuf *err)
1257{
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001258 if (!old_oid)
Johannes Schindelin033abf92018-05-02 11:38:39 +02001259 BUG("verify called with old_oid set to NULL");
Michael Haggerty16180332015-02-17 18:00:21 +01001260 return ref_transaction_update(transaction, refname,
brian m. carlson89f3bbd2017-10-15 22:06:53 +00001261 NULL, old_oid,
Michael Haggerty16180332015-02-17 18:00:21 +01001262 flags, NULL, err);
1263}
1264
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07001265int refs_update_ref(struct ref_store *refs, const char *msg,
brian m. carlsonae077772017-10-15 22:06:51 +00001266 const char *refname, const struct object_id *new_oid,
1267 const struct object_id *old_oid, unsigned int flags,
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07001268 enum action_on_err onerr)
Brad King4738a332013-09-04 11:22:40 -04001269{
David Turner74ec19d2015-07-31 02:06:19 -04001270 struct ref_transaction *t = NULL;
Ronnie Sahlbergb4d75ac2014-04-24 16:36:55 -07001271 struct strbuf err = STRBUF_INIT;
David Turner74ec19d2015-07-31 02:06:19 -04001272 int ret = 0;
Ronnie Sahlbergb4d75ac2014-04-24 16:36:55 -07001273
Junio C Hamanoc6da34a2022-04-13 15:51:33 -07001274 t = ref_store_transaction_begin(refs, &err);
Han-Wen Nienhuys09743412020-07-27 16:25:46 +00001275 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);
David Turner74ec19d2015-07-31 02:06:19 -04001281 }
1282 if (ret) {
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02001283 const char *str = _("update_ref failed for ref '%s': %s");
Ronnie Sahlbergb4d75ac2014-04-24 16:36:55 -07001284
Ronnie Sahlbergb4d75ac2014-04-24 16:36:55 -07001285 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);
Brad King4738a332013-09-04 11:22:40 -04001296 return 1;
Ronnie Sahlbergb4d75ac2014-04-24 16:36:55 -07001297 }
1298 strbuf_release(&err);
David Turner74ec19d2015-07-31 02:06:19 -04001299 if (t)
1300 ref_transaction_free(t);
Ronnie Sahlbergb4d75ac2014-04-24 16:36:55 -07001301 return 0;
Brad King4738a332013-09-04 11:22:40 -04001302}
1303
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07001304int update_ref(const char *msg, const char *refname,
brian m. carlsonae077772017-10-15 22:06:51 +00001305 const struct object_id *new_oid,
1306 const struct object_id *old_oid,
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07001307 unsigned int flags, enum action_on_err onerr)
1308{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001309 return refs_update_ref(get_main_ref_store(the_repository), msg, refname, new_oid,
brian m. carlsonae077772017-10-15 22:06:51 +00001310 old_oid, flags, onerr);
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07001311}
1312
Nguyễn Thái Ngọc Duy546edf32019-04-06 18:34:25 +07001313char *refs_shorten_unambiguous_ref(struct ref_store *refs,
1314 const char *refname, int strict)
Jeff King7c2b3022009-04-07 03:14:20 -04001315{
1316 int i;
1317 static char **scanf_fmts;
1318 static int nr_rules;
1319 char *short_name;
Jeff King6cd4a892017-03-28 15:46:33 -04001320 struct strbuf resolved_buf = STRBUF_INIT;
Jeff King7c2b3022009-04-07 03:14:20 -04001321
Jeff King7c2b3022009-04-07 03:14:20 -04001322 if (!nr_rules) {
Michael Haggerty43466632014-01-08 15:43:39 +01001323 /*
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 */
Jeff King7c2b3022009-04-07 03:14:20 -04001329 size_t total_len = 0;
Michael Haggerty84d56332014-01-08 15:43:38 +01001330 size_t offset = 0;
Jeff King7c2b3022009-04-07 03:14:20 -04001331
1332 /* the rule list is NULL terminated, count them first */
Jeff Kinga4165852013-10-24 04:45:13 -04001333 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
Michael Haggerty7902fe02014-01-08 15:43:40 +01001334 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1335 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
Jeff King7c2b3022009-04-07 03:14:20 -04001336
René Scharfe50492f72016-07-30 20:18:31 +02001337 scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
Jeff King7c2b3022009-04-07 03:14:20 -04001338
Michael Haggerty84d56332014-01-08 15:43:38 +01001339 offset = 0;
Jeff King7c2b3022009-04-07 03:14:20 -04001340 for (i = 0; i < nr_rules; i++) {
Michael Haggerty43466632014-01-08 15:43:39 +01001341 assert(offset < total_len);
Michael Haggerty84d56332014-01-08 15:43:38 +01001342 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
Jeff Kingbf4baf12018-05-18 18:58:20 -07001343 offset += xsnprintf(scanf_fmts[i], total_len - offset,
1344 ref_rev_parse_rules[i], 2, "%s") + 1;
Jeff King7c2b3022009-04-07 03:14:20 -04001345 }
1346 }
1347
1348 /* bail out if there are no rules */
1349 if (!nr_rules)
Michael Haggertydfefa932011-12-12 06:38:09 +01001350 return xstrdup(refname);
Jeff King7c2b3022009-04-07 03:14:20 -04001351
Michael Haggertydfefa932011-12-12 06:38:09 +01001352 /* buffer for scanf result, at most refname must fit */
1353 short_name = xstrdup(refname);
Jeff King7c2b3022009-04-07 03:14:20 -04001354
1355 /* skip first rule, it will always match */
1356 for (i = nr_rules - 1; i > 0 ; --i) {
1357 int j;
Bert Wesarg6e7b3302009-04-13 12:25:46 +02001358 int rules_to_fail = i;
Jeff King7c2b3022009-04-07 03:14:20 -04001359 int short_name_len;
1360
Michael Haggertydfefa932011-12-12 06:38:09 +01001361 if (1 != sscanf(refname, scanf_fmts[i], short_name))
Jeff King7c2b3022009-04-07 03:14:20 -04001362 continue;
1363
1364 short_name_len = strlen(short_name);
1365
1366 /*
Bert Wesarg6e7b3302009-04-13 12:25:46 +02001367 * 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
1373 /*
Jeff King7c2b3022009-04-07 03:14:20 -04001374 * check if the short name resolves to a valid ref,
1375 * but use only rules prior to the matched one
1376 */
Bert Wesarg6e7b3302009-04-13 12:25:46 +02001377 for (j = 0; j < rules_to_fail; j++) {
Jeff King7c2b3022009-04-07 03:14:20 -04001378 const char *rule = ref_rev_parse_rules[j];
Jeff King7c2b3022009-04-07 03:14:20 -04001379
Bert Wesarg6e7b3302009-04-13 12:25:46 +02001380 /* skip matched rule */
1381 if (i == j)
1382 continue;
1383
Jeff King7c2b3022009-04-07 03:14:20 -04001384 /*
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 */
Jeff King6cd4a892017-03-28 15:46:33 -04001389 strbuf_reset(&resolved_buf);
1390 strbuf_addf(&resolved_buf, rule,
1391 short_name_len, short_name);
Nguyễn Thái Ngọc Duy546edf32019-04-06 18:34:25 +07001392 if (refs_ref_exists(refs, resolved_buf.buf))
Jeff King7c2b3022009-04-07 03:14:20 -04001393 break;
1394 }
1395
1396 /*
1397 * short name is non-ambiguous if all previous rules
1398 * haven't resolved to a valid ref
1399 */
Jeff King6cd4a892017-03-28 15:46:33 -04001400 if (j == rules_to_fail) {
1401 strbuf_release(&resolved_buf);
Jeff King7c2b3022009-04-07 03:14:20 -04001402 return short_name;
Jeff King6cd4a892017-03-28 15:46:33 -04001403 }
Jeff King7c2b3022009-04-07 03:14:20 -04001404 }
1405
Jeff King6cd4a892017-03-28 15:46:33 -04001406 strbuf_release(&resolved_buf);
Jeff King7c2b3022009-04-07 03:14:20 -04001407 free(short_name);
Michael Haggertydfefa932011-12-12 06:38:09 +01001408 return xstrdup(refname);
Jeff King7c2b3022009-04-07 03:14:20 -04001409}
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001410
Nguyễn Thái Ngọc Duy546edf32019-04-06 18:34:25 +07001411char *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
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001417static struct string_list *hide_refs;
1418
1419int parse_hide_refs_config(const char *var, const char *value, const char *section)
1420{
Jeff Kingad8c7cd2017-02-24 16:08:16 -05001421 const char *key;
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001422 if (!strcmp("transfer.hiderefs", var) ||
Jeff Kingad8c7cd2017-02-24 16:08:16 -05001423 (!parse_config_key(var, section, NULL, NULL, &key) &&
1424 !strcmp(key, "hiderefs"))) {
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001425 char *ref;
1426 int len;
1427
1428 if (!value)
1429 return config_error_nonbool(var);
1430 ref = xstrdup(value);
1431 len = strlen(ref);
1432 while (len && ref[len - 1] == '/')
1433 ref[--len] = '\0';
1434 if (!hide_refs) {
René Scharfeca56dad2021-03-13 17:17:22 +01001435 CALLOC_ARRAY(hide_refs, 1);
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001436 hide_refs->strdup_strings = 1;
1437 }
1438 string_list_append(hide_refs, ref);
1439 }
1440 return 0;
1441}
1442
Lukas Fleischer78a766a2015-11-03 08:58:16 +01001443int ref_is_hidden(const char *refname, const char *refname_full)
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001444{
Jeff King2bc31d12015-07-28 16:23:26 -04001445 int i;
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001446
1447 if (!hide_refs)
1448 return 0;
Jeff King2bc31d12015-07-28 16:23:26 -04001449 for (i = hide_refs->nr - 1; i >= 0; i--) {
1450 const char *match = hide_refs->items[i].string;
Lukas Fleischer78a766a2015-11-03 08:58:16 +01001451 const char *subject;
Jeff King2bc31d12015-07-28 16:23:26 -04001452 int neg = 0;
Christian Couder7a40a952017-07-22 06:39:12 +02001453 const char *p;
Jeff King2bc31d12015-07-28 16:23:26 -04001454
1455 if (*match == '!') {
1456 neg = 1;
1457 match++;
1458 }
1459
Lukas Fleischer78a766a2015-11-03 08:58:16 +01001460 if (*match == '^') {
1461 subject = refname_full;
1462 match++;
1463 } else {
1464 subject = refname;
1465 }
1466
1467 /* refname can be NULL when namespaces are used. */
Christian Couder7a40a952017-07-22 06:39:12 +02001468 if (subject &&
1469 skip_prefix(subject, match, &p) &&
1470 (!*p || *p == '/'))
Jeff King2bc31d12015-07-28 16:23:26 -04001471 return !neg;
Junio C Hamanodaebaa72013-01-18 16:08:30 -08001472 }
1473 return 0;
1474}
Michael Haggertyfa5b1832014-12-12 09:56:59 +01001475
David Turner08451222015-11-10 12:42:40 +01001476const char *find_descendant_ref(const char *dirname,
1477 const struct string_list *extras,
1478 const struct string_list *skip)
Michael Haggertyfa5b1832014-12-12 09:56:59 +01001479{
David Turner08451222015-11-10 12:42:40 +01001480 int pos;
Michael Haggertyfa5b1832014-12-12 09:56:59 +01001481
David Turner08451222015-11-10 12:42:40 +01001482 if (!extras)
1483 return NULL;
Michael Haggertyfa5b1832014-12-12 09:56:59 +01001484
1485 /*
David Turner08451222015-11-10 12:42:40 +01001486 * Look at the place where dirname would be inserted into
1487 * extras. If there is an entry at that position that starts
1488 * with dirname (remember, dirname includes the trailing
1489 * slash) and is not in skip, then we have a conflict.
Michael Haggertyfa5b1832014-12-12 09:56:59 +01001490 */
David Turner08451222015-11-10 12:42:40 +01001491 for (pos = string_list_find_insert_index(extras, dirname, 0);
1492 pos < extras->nr; pos++) {
1493 const char *extra_refname = extras->items[pos].string;
1494
1495 if (!starts_with(extra_refname, dirname))
1496 break;
1497
1498 if (!skip || !string_list_has_string(skip, extra_refname))
1499 return extra_refname;
Michael Haggerty4a32b2e2015-05-11 17:25:15 +02001500 }
David Turner08451222015-11-10 12:42:40 +01001501 return NULL;
1502}
Michael Haggertyfa5b1832014-12-12 09:56:59 +01001503
Nguyễn Thái Ngọc Duy62f0b392017-08-23 19:36:55 +07001504int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
David Turner2bf68ed2016-04-07 15:02:48 -04001505{
1506 struct object_id oid;
1507 int flag;
1508
Ævar Arnfjörð Bjarmasonf1da24c2021-10-16 11:39:27 +02001509 if (refs_resolve_ref_unsafe(refs, "HEAD", RESOLVE_REF_READING,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001510 &oid, &flag))
David Turner2bf68ed2016-04-07 15:02:48 -04001511 return fn("HEAD", &oid, flag, cb_data);
1512
1513 return 0;
1514}
1515
1516int head_ref(each_ref_fn fn, void *cb_data)
1517{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001518 return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
David Turner2bf68ed2016-04-07 15:02:48 -04001519}
David Turner93770592016-04-07 15:02:49 -04001520
Michael Haggertye121b9c2017-03-20 17:33:08 +01001521struct ref_iterator *refs_ref_iterator_begin(
1522 struct ref_store *refs,
Jeff King9aab9522021-09-24 14:39:44 -04001523 const char *prefix, int trim,
1524 enum do_for_each_ref_flags flags)
Michael Haggertye121b9c2017-03-20 17:33:08 +01001525{
1526 struct ref_iterator *iter;
1527
Jeff King6d751be2021-09-24 14:42:38 -04001528 if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) {
Jeff King5d1f5b82021-09-24 14:46:37 -04001529 static int ref_paranoia = -1;
1530
Jeff King6d751be2021-09-24 14:42:38 -04001531 if (ref_paranoia < 0)
Jeff King968f12f2021-09-24 14:46:13 -04001532 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 1);
Jeff King6d751be2021-09-24 14:42:38 -04001533 if (ref_paranoia) {
1534 flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1535 flags |= DO_FOR_EACH_OMIT_DANGLING_SYMREFS;
1536 }
1537 }
Michael Haggerty0a0865b2017-05-22 16:17:52 +02001538
Michael Haggertye121b9c2017-03-20 17:33:08 +01001539 iter = refs->be->iterator_begin(refs, prefix, flags);
Michael Haggertyc7599712017-05-22 16:17:36 +02001540
1541 /*
1542 * `iterator_begin()` already takes care of prefix, but we
1543 * might need to do some trimming:
1544 */
1545 if (trim)
1546 iter = prefix_ref_iterator_begin(iter, "", trim);
Michael Haggertye121b9c2017-03-20 17:33:08 +01001547
Michael Haggerty8738a8a2017-09-13 19:15:55 +02001548 /* Sanity check for subclasses: */
1549 if (!iter->ordered)
1550 BUG("reference iterator is not ordered");
1551
Michael Haggertye121b9c2017-03-20 17:33:08 +01001552 return iter;
1553}
1554
Michael Haggerty4c4de892016-06-18 06:15:16 +02001555/*
1556 * Call fn for each reference in the specified submodule for which the
1557 * refname begins with prefix. If trim is non-zero, then trim that
1558 * many characters off the beginning of each refname before passing
1559 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1560 * include broken references in the iteration. If fn ever returns a
1561 * non-zero value, stop the iteration and return that value;
1562 * otherwise, return 0.
1563 */
Stefan Beller4a6067c2018-08-20 18:24:16 +00001564static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1565 each_repo_ref_fn fn, int trim, int flags,
1566 void *cb_data)
Michael Haggerty4c4de892016-06-18 06:15:16 +02001567{
1568 struct ref_iterator *iter;
Stefan Beller4a6067c2018-08-20 18:24:16 +00001569 struct ref_store *refs = get_main_ref_store(r);
Michael Haggerty4c4de892016-06-18 06:15:16 +02001570
Michael Haggerty00eebe32016-09-04 18:08:11 +02001571 if (!refs)
1572 return 0;
1573
Michael Haggertye121b9c2017-03-20 17:33:08 +01001574 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
Michael Haggerty4c4de892016-06-18 06:15:16 +02001575
Stefan Beller4a6067c2018-08-20 18:24:16 +00001576 return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1577}
1578
1579struct do_for_each_ref_help {
1580 each_ref_fn *fn;
1581 void *cb_data;
1582};
1583
1584static int do_for_each_ref_helper(struct repository *r,
1585 const char *refname,
1586 const struct object_id *oid,
1587 int flags,
1588 void *cb_data)
1589{
1590 struct do_for_each_ref_help *hp = cb_data;
1591
1592 return hp->fn(refname, oid, flags, hp->cb_data);
1593}
1594
1595static int do_for_each_ref(struct ref_store *refs, const char *prefix,
Jeff King9aab9522021-09-24 14:39:44 -04001596 each_ref_fn fn, int trim,
1597 enum do_for_each_ref_flags flags, void *cb_data)
Stefan Beller4a6067c2018-08-20 18:24:16 +00001598{
1599 struct ref_iterator *iter;
1600 struct do_for_each_ref_help hp = { fn, cb_data };
1601
1602 if (!refs)
1603 return 0;
1604
1605 iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1606
1607 return do_for_each_repo_ref_iterator(the_repository, iter,
1608 do_for_each_ref_helper, &hp);
Michael Haggerty4c4de892016-06-18 06:15:16 +02001609}
1610
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07001611int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1612{
1613 return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1614}
1615
David Turner93770592016-04-07 15:02:49 -04001616int for_each_ref(each_ref_fn fn, void *cb_data)
1617{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001618 return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
David Turner93770592016-04-07 15:02:49 -04001619}
1620
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07001621int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1622 each_ref_fn fn, void *cb_data)
1623{
1624 return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
David Turner93770592016-04-07 15:02:49 -04001625}
1626
1627int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1628{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001629 return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
David Turner93770592016-04-07 15:02:49 -04001630}
1631
Jeff King67985e42021-09-24 14:48:48 -04001632int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data)
David Turner93770592016-04-07 15:02:49 -04001633{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001634 return do_for_each_ref(get_main_ref_store(the_repository),
Jeff King67985e42021-09-24 14:48:48 -04001635 prefix, fn, 0, 0, cb_data);
David Turner93770592016-04-07 15:02:49 -04001636}
1637
Nguyễn Thái Ngọc Duy073cf632017-08-23 19:36:56 +07001638int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
Jeff King67985e42021-09-24 14:48:48 -04001639 each_ref_fn fn, void *cb_data)
Michael Haggerty03df5672017-06-18 15:39:41 +02001640{
Jeff King67985e42021-09-24 14:48:48 -04001641 return do_for_each_ref(refs, prefix, fn, 0, 0, cb_data);
Michael Haggerty03df5672017-06-18 15:39:41 +02001642}
1643
Stefan Beller212e0f72018-08-20 18:24:19 +00001644int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
David Turner93770592016-04-07 15:02:49 -04001645{
Derrick Stolee97e61e02022-08-05 17:58:37 +00001646 const char *git_replace_ref_base = ref_namespace[NAMESPACE_REPLACE].ref;
Stefan Beller212e0f72018-08-20 18:24:19 +00001647 return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1648 strlen(git_replace_ref_base),
1649 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
David Turner93770592016-04-07 15:02:49 -04001650}
1651
1652int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1653{
1654 struct strbuf buf = STRBUF_INIT;
1655 int ret;
1656 strbuf_addf(&buf, "%srefs/", get_git_namespace());
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001657 ret = do_for_each_ref(get_main_ref_store(the_repository),
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07001658 buf.buf, fn, 0, 0, cb_data);
David Turner93770592016-04-07 15:02:49 -04001659 strbuf_release(&buf);
1660 return ret;
1661}
1662
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07001663int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
David Turner93770592016-04-07 15:02:49 -04001664{
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07001665 return do_for_each_ref(refs, "", fn, 0,
David Turner93770592016-04-07 15:02:49 -04001666 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1667}
David Turner2d0663b2016-04-07 15:03:10 -04001668
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07001669int for_each_rawref(each_ref_fn fn, void *cb_data)
1670{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001671 return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07001672}
1673
Taylor Blau16b19852021-01-20 11:04:21 -05001674static int qsort_strcmp(const void *va, const void *vb)
1675{
1676 const char *a = *(const char **)va;
1677 const char *b = *(const char **)vb;
1678
1679 return strcmp(a, b);
1680}
1681
1682static void find_longest_prefixes_1(struct string_list *out,
1683 struct strbuf *prefix,
1684 const char **patterns, size_t nr)
1685{
1686 size_t i;
1687
1688 for (i = 0; i < nr; i++) {
1689 char c = patterns[i][prefix->len];
1690 if (!c || is_glob_special(c)) {
1691 string_list_append(out, prefix->buf);
1692 return;
1693 }
1694 }
1695
1696 i = 0;
1697 while (i < nr) {
1698 size_t end;
1699
1700 /*
1701 * Set "end" to the index of the element _after_ the last one
1702 * in our group.
1703 */
1704 for (end = i + 1; end < nr; end++) {
1705 if (patterns[i][prefix->len] != patterns[end][prefix->len])
1706 break;
1707 }
1708
1709 strbuf_addch(prefix, patterns[i][prefix->len]);
1710 find_longest_prefixes_1(out, prefix, patterns + i, end - i);
1711 strbuf_setlen(prefix, prefix->len - 1);
1712
1713 i = end;
1714 }
1715}
1716
1717static void find_longest_prefixes(struct string_list *out,
1718 const char **patterns)
1719{
1720 struct strvec sorted = STRVEC_INIT;
1721 struct strbuf prefix = STRBUF_INIT;
1722
1723 strvec_pushv(&sorted, patterns);
1724 QSORT(sorted.v, sorted.nr, qsort_strcmp);
1725
1726 find_longest_prefixes_1(out, &prefix, sorted.v, sorted.nr);
1727
1728 strvec_clear(&sorted);
1729 strbuf_release(&prefix);
1730}
1731
1732int for_each_fullref_in_prefixes(const char *namespace,
1733 const char **patterns,
Jeff King67985e42021-09-24 14:48:48 -04001734 each_ref_fn fn, void *cb_data)
Taylor Blau16b19852021-01-20 11:04:21 -05001735{
1736 struct string_list prefixes = STRING_LIST_INIT_DUP;
1737 struct string_list_item *prefix;
1738 struct strbuf buf = STRBUF_INIT;
1739 int ret = 0, namespace_len;
1740
1741 find_longest_prefixes(&prefixes, patterns);
1742
1743 if (namespace)
1744 strbuf_addstr(&buf, namespace);
1745 namespace_len = buf.len;
1746
1747 for_each_string_list_item(prefix, &prefixes) {
1748 strbuf_addstr(&buf, prefix->string);
Jeff King67985e42021-09-24 14:48:48 -04001749 ret = for_each_fullref_in(buf.buf, fn, cb_data);
Taylor Blau16b19852021-01-20 11:04:21 -05001750 if (ret)
1751 break;
1752 strbuf_setlen(&buf, namespace_len);
1753 }
1754
1755 string_list_clear(&prefixes, 0);
1756 strbuf_release(&buf);
1757 return ret;
1758}
1759
Han-Wen Nienhuyse8115302020-08-19 14:27:58 +00001760static int refs_read_special_head(struct ref_store *ref_store,
1761 const char *refname, struct object_id *oid,
Han-Wen Nienhuysdf3458e2021-10-16 11:39:10 +02001762 struct strbuf *referent, unsigned int *type,
1763 int *failure_errno)
Han-Wen Nienhuyse8115302020-08-19 14:27:58 +00001764{
1765 struct strbuf full_path = STRBUF_INIT;
1766 struct strbuf content = STRBUF_INIT;
1767 int result = -1;
1768 strbuf_addf(&full_path, "%s/%s", ref_store->gitdir, refname);
1769
1770 if (strbuf_read_file(&content, full_path.buf, 0) < 0)
1771 goto done;
1772
Han-Wen Nienhuysdf3458e2021-10-16 11:39:10 +02001773 result = parse_loose_ref_contents(content.buf, oid, referent, type,
1774 failure_errno);
Han-Wen Nienhuyse8115302020-08-19 14:27:58 +00001775
1776done:
1777 strbuf_release(&full_path);
1778 strbuf_release(&content);
1779 return result;
1780}
1781
Han-Wen Nienhuys8b72fea2021-10-16 11:39:09 +02001782int refs_read_raw_ref(struct ref_store *ref_store, const char *refname,
1783 struct object_id *oid, struct strbuf *referent,
1784 unsigned int *type, int *failure_errno)
Michael Haggerty470be512017-03-20 17:33:07 +01001785{
Han-Wen Nienhuys8b72fea2021-10-16 11:39:09 +02001786 assert(failure_errno);
Han-Wen Nienhuyse8115302020-08-19 14:27:58 +00001787 if (!strcmp(refname, "FETCH_HEAD") || !strcmp(refname, "MERGE_HEAD")) {
1788 return refs_read_special_head(ref_store, refname, oid, referent,
Han-Wen Nienhuysdf3458e2021-10-16 11:39:10 +02001789 type, failure_errno);
Han-Wen Nienhuyse8115302020-08-19 14:27:58 +00001790 }
1791
1792 return ref_store->be->read_raw_ref(ref_store, refname, oid, referent,
Han-Wen Nienhuys8b72fea2021-10-16 11:39:09 +02001793 type, failure_errno);
Michael Haggerty470be512017-03-20 17:33:07 +01001794}
1795
Patrick Steinhardtcd475b32022-03-01 10:33:46 +01001796int refs_read_symbolic_ref(struct ref_store *ref_store, const char *refname,
1797 struct strbuf *referent)
1798{
Ævar Arnfjörð Bjarmason5b875402022-03-17 18:27:19 +01001799 return ref_store->be->read_symbolic_ref(ref_store, refname, referent);
Patrick Steinhardtcd475b32022-03-01 10:33:46 +01001800}
1801
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07001802const char *refs_resolve_ref_unsafe(struct ref_store *refs,
Michael Haggerty3c0cb0c2017-02-09 21:53:52 +01001803 const char *refname,
1804 int resolve_flags,
Ævar Arnfjörð Bjarmasonef181192021-10-16 11:39:08 +02001805 struct object_id *oid,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001806 int *flags)
David Turner2d0663b2016-04-07 15:03:10 -04001807{
1808 static struct strbuf sb_refname = STRBUF_INIT;
René Scharfe54fad662017-09-23 11:41:45 +02001809 struct object_id unused_oid;
David Turner2d0663b2016-04-07 15:03:10 -04001810 int unused_flags;
1811 int symref_count;
1812
brian m. carlson49e61472017-10-15 22:07:09 +00001813 if (!oid)
1814 oid = &unused_oid;
David Turner2d0663b2016-04-07 15:03:10 -04001815 if (!flags)
1816 flags = &unused_flags;
1817
1818 *flags = 0;
1819
1820 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1821 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001822 !refname_is_safe(refname))
David Turner2d0663b2016-04-07 15:03:10 -04001823 return NULL;
David Turner2d0663b2016-04-07 15:03:10 -04001824
1825 /*
1826 * dwim_ref() uses REF_ISBROKEN to distinguish between
1827 * missing refs and refs that were present but invalid,
1828 * to complain about the latter to stderr.
1829 *
1830 * We don't know whether the ref exists, so don't set
1831 * REF_ISBROKEN yet.
1832 */
1833 *flags |= REF_BAD_NAME;
1834 }
1835
1836 for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1837 unsigned int read_flags = 0;
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001838 int failure_errno;
David Turner2d0663b2016-04-07 15:03:10 -04001839
Han-Wen Nienhuys8b72fea2021-10-16 11:39:09 +02001840 if (refs_read_raw_ref(refs, refname, oid, &sb_refname,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001841 &read_flags, &failure_errno)) {
David Turner2d0663b2016-04-07 15:03:10 -04001842 *flags |= read_flags;
Jeff Kinga1c1d812017-10-06 10:42:17 -04001843
1844 /* In reading mode, refs must eventually resolve */
1845 if (resolve_flags & RESOLVE_REF_READING)
David Turner2d0663b2016-04-07 15:03:10 -04001846 return NULL;
Jeff Kinga1c1d812017-10-06 10:42:17 -04001847
1848 /*
1849 * Otherwise a missing ref is OK. But the files backend
1850 * may show errors besides ENOENT if there are
1851 * similarly-named refs.
1852 */
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001853 if (failure_errno != ENOENT &&
1854 failure_errno != EISDIR &&
1855 failure_errno != ENOTDIR)
Jeff Kinga1c1d812017-10-06 10:42:17 -04001856 return NULL;
1857
brian m. carlson49e61472017-10-15 22:07:09 +00001858 oidclr(oid);
David Turner2d0663b2016-04-07 15:03:10 -04001859 if (*flags & REF_BAD_NAME)
1860 *flags |= REF_ISBROKEN;
1861 return refname;
1862 }
1863
1864 *flags |= read_flags;
1865
1866 if (!(read_flags & REF_ISSYMREF)) {
1867 if (*flags & REF_BAD_NAME) {
brian m. carlson49e61472017-10-15 22:07:09 +00001868 oidclr(oid);
David Turner2d0663b2016-04-07 15:03:10 -04001869 *flags |= REF_ISBROKEN;
1870 }
1871 return refname;
1872 }
1873
1874 refname = sb_refname.buf;
1875 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
brian m. carlson49e61472017-10-15 22:07:09 +00001876 oidclr(oid);
David Turner2d0663b2016-04-07 15:03:10 -04001877 return refname;
1878 }
1879 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1880 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001881 !refname_is_safe(refname))
David Turner2d0663b2016-04-07 15:03:10 -04001882 return NULL;
David Turner2d0663b2016-04-07 15:03:10 -04001883
1884 *flags |= REF_ISBROKEN | REF_BAD_NAME;
1885 }
1886 }
1887
David Turner2d0663b2016-04-07 15:03:10 -04001888 return NULL;
1889}
Michael Haggerty00eebe32016-09-04 18:08:11 +02001890
David Turner6fb5acf2016-09-04 18:08:41 +02001891/* backend functions */
1892int refs_init_db(struct strbuf *err)
1893{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001894 struct ref_store *refs = get_main_ref_store(the_repository);
David Turner6fb5acf2016-09-04 18:08:41 +02001895
1896 return refs->be->init_db(refs, err);
1897}
1898
Michael Haggertybd40dcd2016-09-04 18:08:21 +02001899const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
brian m. carlson49e61472017-10-15 22:07:09 +00001900 struct object_id *oid, int *flags)
Michael Haggertybd40dcd2016-09-04 18:08:21 +02001901{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07001902 return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001903 resolve_flags, oid, flags);
Michael Haggertybd40dcd2016-09-04 18:08:21 +02001904}
1905
Michael Haggertya8355bb2016-09-04 18:08:24 +02001906int resolve_gitlink_ref(const char *submodule, const char *refname,
brian m. carlsona98e6102017-10-15 22:07:07 +00001907 struct object_id *oid)
Michael Haggerty424dcc72016-09-04 18:08:22 +02001908{
Michael Haggerty424dcc72016-09-04 18:08:22 +02001909 struct ref_store *refs;
1910 int flags;
1911
Nguyễn Thái Ngọc Duy29babbe2017-08-23 19:36:54 +07001912 refs = get_submodule_ref_store(submodule);
Michael Haggerty48a84752016-09-04 18:08:23 +02001913
Michael Haggerty424dcc72016-09-04 18:08:22 +02001914 if (!refs)
1915 return -1;
1916
Ævar Arnfjörð Bjarmasonce14de02022-01-26 15:37:01 +01001917 if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
1918 is_null_oid(oid))
Michael Haggerty424dcc72016-09-04 18:08:22 +02001919 return -1;
1920 return 0;
1921}
1922
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001923struct ref_store_hash_entry
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001924{
Eric Wonge2b50382019-10-06 23:30:43 +00001925 struct hashmap_entry ent;
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001926
1927 struct ref_store *refs;
1928
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001929 /* NUL-terminated identifier of the ref store: */
1930 char name[FLEX_ARRAY];
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001931};
1932
Ævar Arnfjörð Bjarmason5cf88fd2022-08-25 19:09:48 +02001933static int ref_store_hash_cmp(const void *cmp_data UNUSED,
Eric Wong939af162019-10-06 23:30:37 +00001934 const struct hashmap_entry *eptr,
1935 const struct hashmap_entry *entry_or_key,
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001936 const void *keydata)
1937{
Eric Wong939af162019-10-06 23:30:37 +00001938 const struct ref_store_hash_entry *e1, *e2;
1939 const char *name;
1940
1941 e1 = container_of(eptr, const struct ref_store_hash_entry, ent);
1942 e2 = container_of(entry_or_key, const struct ref_store_hash_entry, ent);
1943 name = keydata ? keydata : e2->name;
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001944
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001945 return strcmp(e1->name, name);
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001946}
1947
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001948static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1949 const char *name, struct ref_store *refs)
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001950{
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001951 struct ref_store_hash_entry *entry;
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001952
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001953 FLEX_ALLOC_STR(entry, name, name);
Eric Wongd22245a2019-10-06 23:30:27 +00001954 hashmap_entry_init(&entry->ent, strhash(name));
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001955 entry->refs = refs;
1956 return entry;
1957}
1958
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001959/* A hashmap of ref_stores, stored by submodule name: */
1960static struct hashmap submodule_ref_stores;
Michael Haggerty00eebe32016-09-04 18:08:11 +02001961
Nguyễn Thái Ngọc Duy17eff962017-04-24 17:01:22 +07001962/* A hashmap of ref_stores, stored by worktree id: */
1963static struct hashmap worktree_ref_stores;
Michael Haggerty00eebe32016-09-04 18:08:11 +02001964
Michael Haggerty00eebe32016-09-04 18:08:11 +02001965/*
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001966 * Look up a ref store by name. If that ref_store hasn't been
1967 * registered yet, return NULL.
Michael Haggerty00eebe32016-09-04 18:08:11 +02001968 */
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001969static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1970 const char *name)
Michael Haggerty00eebe32016-09-04 18:08:11 +02001971{
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001972 struct ref_store_hash_entry *entry;
Eric Wongf23a4652019-10-06 23:30:36 +00001973 unsigned int hash;
Michael Haggerty00eebe32016-09-04 18:08:11 +02001974
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07001975 if (!map->tablesize)
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001976 /* It's initialized on demand in register_ref_store(). */
1977 return NULL;
Michael Haggerty620a66b2017-02-10 12:16:11 +01001978
Eric Wongf23a4652019-10-06 23:30:36 +00001979 hash = strhash(name);
1980 entry = hashmap_get_entry_from_hash(map, hash, name,
1981 struct ref_store_hash_entry, ent);
Michael Haggerty7d4558c2017-02-10 12:16:15 +01001982 return entry ? entry->refs : NULL;
Michael Haggerty00eebe32016-09-04 18:08:11 +02001983}
1984
Michael Haggertyc468da42017-02-10 12:16:12 +01001985/*
1986 * Create, record, and return a ref_store instance for the specified
Nguyễn Thái Ngọc Duy5d0bc902017-03-26 09:42:31 +07001987 * gitdir.
Michael Haggertyc468da42017-02-10 12:16:12 +01001988 */
Jonathan Tan34224e12021-10-08 14:08:14 -07001989static struct ref_store *ref_store_init(struct repository *repo,
1990 const char *gitdir,
Nguyễn Thái Ngọc Duy9e7ec632017-03-26 09:42:32 +07001991 unsigned int flags)
Michael Haggerty00eebe32016-09-04 18:08:11 +02001992{
1993 const char *be_name = "files";
1994 struct ref_storage_be *be = find_ref_storage_backend(be_name);
Michael Haggertyba88add2017-02-10 12:16:14 +01001995 struct ref_store *refs;
Michael Haggerty00eebe32016-09-04 18:08:11 +02001996
1997 if (!be)
Johannes Schindelin033abf92018-05-02 11:38:39 +02001998 BUG("reference backend %s is unknown", be_name);
Michael Haggerty00eebe32016-09-04 18:08:11 +02001999
Jonathan Tan34224e12021-10-08 14:08:14 -07002000 refs = be->init(repo, gitdir, flags);
Michael Haggertyba88add2017-02-10 12:16:14 +01002001 return refs;
Michael Haggerty00eebe32016-09-04 18:08:11 +02002002}
2003
Stefan Beller64a74162018-04-11 17:21:14 -07002004struct ref_store *get_main_ref_store(struct repository *r)
Michael Haggerty00eebe32016-09-04 18:08:11 +02002005{
Jeff King02204612020-04-09 23:04:11 -04002006 if (r->refs_private)
2007 return r->refs_private;
Nguyễn Thái Ngọc Duy24c84072017-03-26 09:42:25 +07002008
Jeff King2dc417a2018-05-18 15:25:53 -07002009 if (!r->gitdir)
2010 BUG("attempting to get main_ref_store outside of repository");
2011
Jonathan Tan34224e12021-10-08 14:08:14 -07002012 r->refs_private = ref_store_init(r, r->gitdir, REF_STORE_ALL_CAPS);
Han-Wen Nienhuys4441f422020-09-09 10:15:08 +00002013 r->refs_private = maybe_debug_wrap_ref_store(r->gitdir, r->refs_private);
Jeff King02204612020-04-09 23:04:11 -04002014 return r->refs_private;
Nguyễn Thái Ngọc Duy378dc912017-03-26 09:42:28 +07002015}
2016
2017/*
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07002018 * Associate a ref store with a name. It is a fatal error to call this
2019 * function twice for the same name.
Nguyễn Thái Ngọc Duy378dc912017-03-26 09:42:28 +07002020 */
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07002021static void register_ref_store_map(struct hashmap *map,
2022 const char *type,
2023 struct ref_store *refs,
2024 const char *name)
Nguyễn Thái Ngọc Duy378dc912017-03-26 09:42:28 +07002025{
Eric Wong26b455f2019-10-06 23:30:32 +00002026 struct ref_store_hash_entry *entry;
2027
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07002028 if (!map->tablesize)
Stefan Beller7663cdc2017-06-30 12:14:05 -07002029 hashmap_init(map, ref_store_hash_cmp, NULL, 0);
Nguyễn Thái Ngọc Duy378dc912017-03-26 09:42:28 +07002030
Eric Wong26b455f2019-10-06 23:30:32 +00002031 entry = alloc_ref_store_hash_entry(name, refs);
2032 if (hashmap_put(map, &entry->ent))
Johannes Schindelin033abf92018-05-02 11:38:39 +02002033 BUG("%s ref_store '%s' initialized twice", type, name);
Nguyễn Thái Ngọc Duy24c84072017-03-26 09:42:25 +07002034}
2035
Nguyễn Thái Ngọc Duy18d00022017-03-26 09:42:33 +07002036struct ref_store *get_submodule_ref_store(const char *submodule)
Michael Haggerty00eebe32016-09-04 18:08:11 +02002037{
Nguyễn Thái Ngọc Duy126c9e02017-03-26 09:42:27 +07002038 struct strbuf submodule_sb = STRBUF_INIT;
Michael Haggerty00eebe32016-09-04 18:08:11 +02002039 struct ref_store *refs;
Nguyễn Thái Ngọc Duy29babbe2017-08-23 19:36:54 +07002040 char *to_free = NULL;
2041 size_t len;
Jonathan Tan34224e12021-10-08 14:08:14 -07002042 struct repository *subrepo;
Michael Haggerty00eebe32016-09-04 18:08:11 +02002043
Nguyễn Thái Ngọc Duy82a150f2017-08-23 19:37:03 +07002044 if (!submodule)
2045 return NULL;
2046
Nguyễn Thái Ngọc Duy873ea902017-08-23 19:37:04 +07002047 len = strlen(submodule);
2048 while (len && is_dir_sep(submodule[len - 1]))
2049 len--;
2050 if (!len)
2051 return NULL;
Michael Haggerty00eebe32016-09-04 18:08:11 +02002052
Nguyễn Thái Ngọc Duy29babbe2017-08-23 19:36:54 +07002053 if (submodule[len])
2054 /* We need to strip off one or more trailing slashes */
2055 submodule = to_free = xmemdupz(submodule, len);
Michael Haggerty00eebe32016-09-04 18:08:11 +02002056
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07002057 refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
Nguyễn Thái Ngọc Duy126c9e02017-03-26 09:42:27 +07002058 if (refs)
Nguyễn Thái Ngọc Duy2c616c12017-08-23 19:36:53 +07002059 goto done;
Nguyễn Thái Ngọc Duy126c9e02017-03-26 09:42:27 +07002060
2061 strbuf_addstr(&submodule_sb, submodule);
Nguyễn Thái Ngọc Duy2c616c12017-08-23 19:36:53 +07002062 if (!is_nonbare_repository_dir(&submodule_sb))
2063 goto done;
Nguyễn Thái Ngọc Duy126c9e02017-03-26 09:42:27 +07002064
Nguyễn Thái Ngọc Duy2c616c12017-08-23 19:36:53 +07002065 if (submodule_to_gitdir(&submodule_sb, submodule))
2066 goto done;
Nguyễn Thái Ngọc Duy5d0bc902017-03-26 09:42:31 +07002067
Jonathan Tan34224e12021-10-08 14:08:14 -07002068 subrepo = xmalloc(sizeof(*subrepo));
2069 /*
2070 * NEEDSWORK: Make get_submodule_ref_store() work with arbitrary
2071 * superprojects other than the_repository. This probably should be
2072 * done by making it take a struct repository * parameter instead of a
2073 * submodule path.
2074 */
2075 if (repo_submodule_init(subrepo, the_repository, submodule,
2076 null_oid())) {
2077 free(subrepo);
2078 goto done;
2079 }
2080 refs = ref_store_init(subrepo, submodule_sb.buf,
Nguyễn Thái Ngọc Duy9e7ec632017-03-26 09:42:32 +07002081 REF_STORE_READ | REF_STORE_ODB);
Nguyễn Thái Ngọc Duy0c064d92017-04-04 17:21:20 +07002082 register_ref_store_map(&submodule_ref_stores, "submodule",
2083 refs, submodule);
Nguyễn Thái Ngọc Duy5d0bc902017-03-26 09:42:31 +07002084
Nguyễn Thái Ngọc Duy2c616c12017-08-23 19:36:53 +07002085done:
Nguyễn Thái Ngọc Duy5d0bc902017-03-26 09:42:31 +07002086 strbuf_release(&submodule_sb);
Nguyễn Thái Ngọc Duy29babbe2017-08-23 19:36:54 +07002087 free(to_free);
2088
Michael Haggerty00eebe32016-09-04 18:08:11 +02002089 return refs;
2090}
2091
Nguyễn Thái Ngọc Duy17eff962017-04-24 17:01:22 +07002092struct ref_store *get_worktree_ref_store(const struct worktree *wt)
2093{
2094 struct ref_store *refs;
2095 const char *id;
2096
2097 if (wt->is_current)
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002098 return get_main_ref_store(the_repository);
Nguyễn Thái Ngọc Duy17eff962017-04-24 17:01:22 +07002099
2100 id = wt->id ? wt->id : "/";
2101 refs = lookup_ref_store_map(&worktree_ref_stores, id);
2102 if (refs)
2103 return refs;
2104
2105 if (wt->id)
Jonathan Tan34224e12021-10-08 14:08:14 -07002106 refs = ref_store_init(the_repository,
2107 git_common_path("worktrees/%s", wt->id),
Nguyễn Thái Ngọc Duy17eff962017-04-24 17:01:22 +07002108 REF_STORE_ALL_CAPS);
2109 else
Jonathan Tan34224e12021-10-08 14:08:14 -07002110 refs = ref_store_init(the_repository,
2111 get_git_common_dir(),
Nguyễn Thái Ngọc Duy17eff962017-04-24 17:01:22 +07002112 REF_STORE_ALL_CAPS);
2113
2114 if (refs)
2115 register_ref_store_map(&worktree_ref_stores, "worktree",
2116 refs, id);
2117 return refs;
2118}
2119
Han-Wen Nienhuysf9f7fd32021-12-22 18:11:54 +00002120void base_ref_store_init(struct ref_store *refs, struct repository *repo,
2121 const char *path, const struct ref_storage_be *be)
Michael Haggerty00eebe32016-09-04 18:08:11 +02002122{
Michael Haggerty620a66b2017-02-10 12:16:11 +01002123 refs->be = be;
Han-Wen Nienhuysf9f7fd32021-12-22 18:11:54 +00002124 refs->repo = repo;
2125 refs->gitdir = xstrdup(path);
Michael Haggerty00eebe32016-09-04 18:08:11 +02002126}
Ronnie Sahlberg127b42a2016-09-04 18:08:16 +02002127
2128/* backend functions */
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002129int refs_pack_refs(struct ref_store *refs, unsigned int flags)
Michael Haggerty82315272016-09-04 18:08:27 +02002130{
Michael Haggerty82315272016-09-04 18:08:27 +02002131 return refs->be->pack_refs(refs, flags);
2132}
2133
Jeff King36a31792021-01-20 14:44:43 -05002134int peel_iterated_oid(const struct object_id *base, struct object_id *peeled)
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002135{
Jeff King36a31792021-01-20 14:44:43 -05002136 if (current_ref_iter &&
2137 (current_ref_iter->oid == base ||
2138 oideq(current_ref_iter->oid, base)))
2139 return ref_iterator_peel(current_ref_iter, peeled);
Michael Haggertyba1c0522017-09-25 10:00:14 +02002140
Han-Wen Nienhuys617480d2021-05-19 15:31:28 +00002141 return peel_object(base, peeled) ? -1 : 0;
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002142}
Michael Haggertybd427cf2016-09-04 18:08:29 +02002143
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002144int refs_create_symref(struct ref_store *refs,
2145 const char *ref_target,
2146 const char *refs_heads_master,
2147 const char *logmsg)
2148{
Junio C Hamano523fa692020-07-10 17:19:53 +00002149 char *msg;
2150 int retval;
2151
2152 msg = normalize_reflog_message(logmsg);
2153 retval = refs->be->create_symref(refs, ref_target, refs_heads_master,
2154 msg);
2155 free(msg);
2156 return retval;
Michael Haggertybd427cf2016-09-04 18:08:29 +02002157}
2158
Michael Haggerty284689b2016-09-04 18:08:28 +02002159int create_symref(const char *ref_target, const char *refs_heads_master,
2160 const char *logmsg)
2161{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002162 return refs_create_symref(get_main_ref_store(the_repository), ref_target,
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002163 refs_heads_master, logmsg);
Michael Haggerty284689b2016-09-04 18:08:28 +02002164}
2165
Michael Haggerty2ced1052017-05-22 16:17:45 +02002166int ref_update_reject_duplicates(struct string_list *refnames,
2167 struct strbuf *err)
2168{
Michael Haggertya552e502017-05-22 16:17:46 +02002169 size_t i, n = refnames->nr;
Michael Haggerty2ced1052017-05-22 16:17:45 +02002170
2171 assert(err);
2172
Michael Haggerty8556f8d2017-05-22 16:17:47 +02002173 for (i = 1; i < n; i++) {
2174 int cmp = strcmp(refnames->items[i - 1].string,
2175 refnames->items[i].string);
2176
2177 if (!cmp) {
Michael Haggerty2ced1052017-05-22 16:17:45 +02002178 strbuf_addf(err,
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02002179 _("multiple updates for ref '%s' not allowed"),
Michael Haggerty2ced1052017-05-22 16:17:45 +02002180 refnames->items[i].string);
2181 return 1;
Michael Haggerty8556f8d2017-05-22 16:17:47 +02002182 } else if (cmp > 0) {
Johannes Schindelin033abf92018-05-02 11:38:39 +02002183 BUG("ref_update_reject_duplicates() received unsorted list");
Michael Haggerty2ced1052017-05-22 16:17:45 +02002184 }
Michael Haggerty8556f8d2017-05-22 16:17:47 +02002185 }
Michael Haggerty2ced1052017-05-22 16:17:45 +02002186 return 0;
2187}
2188
Patrick Steinhardt67541592020-06-19 08:56:14 +02002189static int run_transaction_hook(struct ref_transaction *transaction,
2190 const char *state)
2191{
2192 struct child_process proc = CHILD_PROCESS_INIT;
2193 struct strbuf buf = STRBUF_INIT;
Patrick Steinhardt0a0fbbe2020-08-25 12:35:24 +02002194 const char *hook;
Patrick Steinhardt67541592020-06-19 08:56:14 +02002195 int ret = 0, i;
2196
Patrick Steinhardt0a0fbbe2020-08-25 12:35:24 +02002197 hook = find_hook("reference-transaction");
Patrick Steinhardt67541592020-06-19 08:56:14 +02002198 if (!hook)
Patrick Steinhardt67541592020-06-19 08:56:14 +02002199 return ret;
Patrick Steinhardt67541592020-06-19 08:56:14 +02002200
Jeff Kingc972bf42020-07-28 16:25:12 -04002201 strvec_pushl(&proc.args, hook, state, NULL);
Patrick Steinhardt67541592020-06-19 08:56:14 +02002202 proc.in = -1;
2203 proc.stdout_to_stderr = 1;
2204 proc.trace2_hook_name = "reference-transaction";
2205
2206 ret = start_command(&proc);
2207 if (ret)
2208 return ret;
2209
2210 sigchain_push(SIGPIPE, SIG_IGN);
2211
2212 for (i = 0; i < transaction->nr; i++) {
2213 struct ref_update *update = transaction->updates[i];
2214
2215 strbuf_reset(&buf);
2216 strbuf_addf(&buf, "%s %s %s\n",
2217 oid_to_hex(&update->old_oid),
2218 oid_to_hex(&update->new_oid),
2219 update->refname);
2220
2221 if (write_in_full(proc.in, buf.buf, buf.len) < 0) {
Ævar Arnfjörð Bjarmason4755d7d2021-10-16 11:39:25 +02002222 if (errno != EPIPE) {
2223 /* Don't leak errno outside this API */
2224 errno = 0;
Patrick Steinhardt67541592020-06-19 08:56:14 +02002225 ret = -1;
Ævar Arnfjörð Bjarmason4755d7d2021-10-16 11:39:25 +02002226 }
Patrick Steinhardt67541592020-06-19 08:56:14 +02002227 break;
2228 }
2229 }
2230
2231 close(proc.in);
2232 sigchain_pop(SIGPIPE);
2233 strbuf_release(&buf);
2234
2235 ret |= finish_command(&proc);
2236 return ret;
2237}
2238
Michael Haggerty30173b82017-05-22 16:17:44 +02002239int ref_transaction_prepare(struct ref_transaction *transaction,
2240 struct strbuf *err)
Ronnie Sahlberg127b42a2016-09-04 18:08:16 +02002241{
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07002242 struct ref_store *refs = transaction->ref_store;
Patrick Steinhardt67541592020-06-19 08:56:14 +02002243 int ret;
Ronnie Sahlberg127b42a2016-09-04 18:08:16 +02002244
Michael Haggerty8d4240d2017-05-22 16:17:43 +02002245 switch (transaction->state) {
2246 case REF_TRANSACTION_OPEN:
2247 /* Good. */
2248 break;
Michael Haggerty30173b82017-05-22 16:17:44 +02002249 case REF_TRANSACTION_PREPARED:
Johannes Schindelin033abf92018-05-02 11:38:39 +02002250 BUG("prepare called twice on reference transaction");
Michael Haggerty30173b82017-05-22 16:17:44 +02002251 break;
Michael Haggerty8d4240d2017-05-22 16:17:43 +02002252 case REF_TRANSACTION_CLOSED:
Johannes Schindelin033abf92018-05-02 11:38:39 +02002253 BUG("prepare called on a closed reference transaction");
Michael Haggerty8d4240d2017-05-22 16:17:43 +02002254 break;
2255 default:
Johannes Schindelin033abf92018-05-02 11:38:39 +02002256 BUG("unexpected reference transaction state");
Michael Haggerty8d4240d2017-05-22 16:17:43 +02002257 break;
2258 }
2259
Neeraj Singhecd81df2021-12-06 22:05:05 +00002260 if (refs->repo->objects->odb->disable_ref_updates) {
Jeff Kingd8f44812017-04-10 18:14:12 -04002261 strbuf_addstr(err,
2262 _("ref updates forbidden inside quarantine environment"));
2263 return -1;
2264 }
2265
Patrick Steinhardt67541592020-06-19 08:56:14 +02002266 ret = refs->be->transaction_prepare(refs, transaction, err);
2267 if (ret)
2268 return ret;
2269
2270 ret = run_transaction_hook(transaction, "prepared");
2271 if (ret) {
2272 ref_transaction_abort(transaction, err);
2273 die(_("ref updates aborted by hook"));
2274 }
2275
2276 return 0;
Michael Haggerty30173b82017-05-22 16:17:44 +02002277}
2278
2279int ref_transaction_abort(struct ref_transaction *transaction,
2280 struct strbuf *err)
2281{
2282 struct ref_store *refs = transaction->ref_store;
2283 int ret = 0;
2284
2285 switch (transaction->state) {
2286 case REF_TRANSACTION_OPEN:
2287 /* No need to abort explicitly. */
2288 break;
2289 case REF_TRANSACTION_PREPARED:
2290 ret = refs->be->transaction_abort(refs, transaction, err);
2291 break;
2292 case REF_TRANSACTION_CLOSED:
Johannes Schindelin033abf92018-05-02 11:38:39 +02002293 BUG("abort called on a closed reference transaction");
Michael Haggerty30173b82017-05-22 16:17:44 +02002294 break;
2295 default:
Johannes Schindelin033abf92018-05-02 11:38:39 +02002296 BUG("unexpected reference transaction state");
Michael Haggerty30173b82017-05-22 16:17:44 +02002297 break;
2298 }
2299
Patrick Steinhardt67541592020-06-19 08:56:14 +02002300 run_transaction_hook(transaction, "aborted");
2301
Michael Haggerty30173b82017-05-22 16:17:44 +02002302 ref_transaction_free(transaction);
2303 return ret;
2304}
2305
2306int ref_transaction_commit(struct ref_transaction *transaction,
2307 struct strbuf *err)
2308{
2309 struct ref_store *refs = transaction->ref_store;
2310 int ret;
2311
2312 switch (transaction->state) {
2313 case REF_TRANSACTION_OPEN:
2314 /* Need to prepare first. */
2315 ret = ref_transaction_prepare(transaction, err);
2316 if (ret)
2317 return ret;
2318 break;
2319 case REF_TRANSACTION_PREPARED:
2320 /* Fall through to finish. */
2321 break;
2322 case REF_TRANSACTION_CLOSED:
Johannes Schindelin033abf92018-05-02 11:38:39 +02002323 BUG("commit called on a closed reference transaction");
Michael Haggerty30173b82017-05-22 16:17:44 +02002324 break;
2325 default:
Johannes Schindelin033abf92018-05-02 11:38:39 +02002326 BUG("unexpected reference transaction state");
Michael Haggerty30173b82017-05-22 16:17:44 +02002327 break;
2328 }
2329
Patrick Steinhardt67541592020-06-19 08:56:14 +02002330 ret = refs->be->transaction_finish(refs, transaction, err);
2331 if (!ret)
2332 run_transaction_hook(transaction, "committed");
2333 return ret;
Ronnie Sahlberg127b42a2016-09-04 18:08:16 +02002334}
Michael Haggerty62665822016-09-04 18:08:26 +02002335
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002336int refs_verify_refname_available(struct ref_store *refs,
2337 const char *refname,
Michael Haggertyb05855b2017-04-16 08:41:26 +02002338 const struct string_list *extras,
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002339 const struct string_list *skip,
2340 struct strbuf *err)
Michael Haggerty62665822016-09-04 18:08:26 +02002341{
Michael Haggertyb05855b2017-04-16 08:41:26 +02002342 const char *slash;
2343 const char *extra_refname;
2344 struct strbuf dirname = STRBUF_INIT;
2345 struct strbuf referent = STRBUF_INIT;
2346 struct object_id oid;
2347 unsigned int type;
2348 struct ref_iterator *iter;
2349 int ok;
2350 int ret = -1;
2351
2352 /*
2353 * For the sake of comments in this function, suppose that
2354 * refname is "refs/foo/bar".
2355 */
2356
2357 assert(err);
2358
2359 strbuf_grow(&dirname, strlen(refname) + 1);
2360 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
Han-Wen Nienhuys8b72fea2021-10-16 11:39:09 +02002361 /*
2362 * Just saying "Is a directory" when we e.g. can't
2363 * lock some multi-level ref isn't very informative,
2364 * the user won't be told *what* is a directory, so
2365 * let's not use strerror() below.
2366 */
2367 int ignore_errno;
Michael Haggertyb05855b2017-04-16 08:41:26 +02002368 /* Expand dirname to the new prefix, not including the trailing slash: */
2369 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2370
2371 /*
2372 * We are still at a leading dir of the refname (e.g.,
2373 * "refs/foo"; if there is a reference with that name,
2374 * it is a conflict, *unless* it is in skip.
2375 */
2376 if (skip && string_list_has_string(skip, dirname.buf))
2377 continue;
2378
Han-Wen Nienhuys8b72fea2021-10-16 11:39:09 +02002379 if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent,
2380 &type, &ignore_errno)) {
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02002381 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
Michael Haggertyb05855b2017-04-16 08:41:26 +02002382 dirname.buf, refname);
2383 goto cleanup;
2384 }
2385
2386 if (extras && string_list_has_string(extras, dirname.buf)) {
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02002387 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
Michael Haggertyb05855b2017-04-16 08:41:26 +02002388 refname, dirname.buf);
2389 goto cleanup;
2390 }
2391 }
2392
2393 /*
2394 * We are at the leaf of our refname (e.g., "refs/foo/bar").
2395 * There is no point in searching for a reference with that
2396 * name, because a refname isn't considered to conflict with
2397 * itself. But we still need to check for references whose
2398 * names are in the "refs/foo/bar/" namespace, because they
2399 * *do* conflict.
2400 */
2401 strbuf_addstr(&dirname, refname + dirname.len);
2402 strbuf_addch(&dirname, '/');
2403
2404 iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
2405 DO_FOR_EACH_INCLUDE_BROKEN);
2406 while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2407 if (skip &&
2408 string_list_has_string(skip, iter->refname))
2409 continue;
2410
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02002411 strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
Michael Haggertyb05855b2017-04-16 08:41:26 +02002412 iter->refname, refname);
2413 ref_iterator_abort(iter);
2414 goto cleanup;
2415 }
2416
2417 if (ok != ITER_DONE)
Johannes Schindelin033abf92018-05-02 11:38:39 +02002418 BUG("error while iterating over references");
Michael Haggertyb05855b2017-04-16 08:41:26 +02002419
2420 extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2421 if (extra_refname)
Nguyễn Thái Ngọc Duy661558f2018-07-21 09:49:35 +02002422 strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
Michael Haggertyb05855b2017-04-16 08:41:26 +02002423 refname, extra_refname);
2424 else
2425 ret = 0;
2426
2427cleanup:
2428 strbuf_release(&referent);
2429 strbuf_release(&dirname);
2430 return ret;
Michael Haggerty62665822016-09-04 18:08:26 +02002431}
David Turnere3688bd2016-09-04 18:08:38 +02002432
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002433int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
David Turnere3688bd2016-09-04 18:08:38 +02002434{
David Turnere3688bd2016-09-04 18:08:38 +02002435 struct ref_iterator *iter;
Stefan Beller4a6067c2018-08-20 18:24:16 +00002436 struct do_for_each_ref_help hp = { fn, cb_data };
David Turnere3688bd2016-09-04 18:08:38 +02002437
2438 iter = refs->be->reflog_iterator_begin(refs);
2439
Stefan Beller4a6067c2018-08-20 18:24:16 +00002440 return do_for_each_repo_ref_iterator(the_repository, iter,
2441 do_for_each_ref_helper, &hp);
David Turnere3688bd2016-09-04 18:08:38 +02002442}
2443
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002444int for_each_reflog(each_ref_fn fn, void *cb_data)
2445{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002446 return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002447}
2448
2449int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2450 const char *refname,
2451 each_reflog_ent_fn fn,
2452 void *cb_data)
2453{
2454 return refs->be->for_each_reflog_ent_reverse(refs, refname,
2455 fn, cb_data);
2456}
2457
David Turnere3688bd2016-09-04 18:08:38 +02002458int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2459 void *cb_data)
2460{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002461 return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002462 refname, fn, cb_data);
2463}
David Turnere3688bd2016-09-04 18:08:38 +02002464
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002465int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2466 each_reflog_ent_fn fn, void *cb_data)
2467{
2468 return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
David Turnere3688bd2016-09-04 18:08:38 +02002469}
2470
2471int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2472 void *cb_data)
2473{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002474 return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002475 fn, cb_data);
2476}
David Turnere3688bd2016-09-04 18:08:38 +02002477
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002478int refs_reflog_exists(struct ref_store *refs, const char *refname)
2479{
2480 return refs->be->reflog_exists(refs, refname);
David Turnere3688bd2016-09-04 18:08:38 +02002481}
2482
2483int reflog_exists(const char *refname)
2484{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002485 return refs_reflog_exists(get_main_ref_store(the_repository), refname);
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002486}
David Turnere3688bd2016-09-04 18:08:38 +02002487
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002488int refs_create_reflog(struct ref_store *refs, const char *refname,
David Turnere3688bd2016-09-04 18:08:38 +02002489 struct strbuf *err)
2490{
Han-Wen Nienhuys7b089122021-11-22 14:19:08 +00002491 return refs->be->create_reflog(refs, refname, err);
2492}
2493
2494int safe_create_reflog(const char *refname, struct strbuf *err)
2495{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002496 return refs_create_reflog(get_main_ref_store(the_repository), refname,
Han-Wen Nienhuys7b089122021-11-22 14:19:08 +00002497 err);
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002498}
David Turnere3688bd2016-09-04 18:08:38 +02002499
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002500int refs_delete_reflog(struct ref_store *refs, const char *refname)
2501{
2502 return refs->be->delete_reflog(refs, refname);
David Turnere3688bd2016-09-04 18:08:38 +02002503}
2504
2505int delete_reflog(const char *refname)
2506{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002507 return refs_delete_reflog(get_main_ref_store(the_repository), refname);
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002508}
David Turnere3688bd2016-09-04 18:08:38 +02002509
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002510int refs_reflog_expire(struct ref_store *refs,
Ævar Arnfjörð Bjarmasoncc40b5c2021-08-23 13:36:11 +02002511 const char *refname,
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002512 unsigned int flags,
2513 reflog_expiry_prepare_fn prepare_fn,
2514 reflog_expiry_should_prune_fn should_prune_fn,
2515 reflog_expiry_cleanup_fn cleanup_fn,
2516 void *policy_cb_data)
2517{
Ævar Arnfjörð Bjarmasoncc40b5c2021-08-23 13:36:11 +02002518 return refs->be->reflog_expire(refs, refname, flags,
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002519 prepare_fn, should_prune_fn,
2520 cleanup_fn, policy_cb_data);
David Turnere3688bd2016-09-04 18:08:38 +02002521}
2522
Ævar Arnfjörð Bjarmasoncc40b5c2021-08-23 13:36:11 +02002523int reflog_expire(const char *refname,
David Turnere3688bd2016-09-04 18:08:38 +02002524 unsigned int flags,
2525 reflog_expiry_prepare_fn prepare_fn,
2526 reflog_expiry_should_prune_fn should_prune_fn,
2527 reflog_expiry_cleanup_fn cleanup_fn,
2528 void *policy_cb_data)
2529{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002530 return refs_reflog_expire(get_main_ref_store(the_repository),
Ævar Arnfjörð Bjarmasoncc40b5c2021-08-23 13:36:11 +02002531 refname, flags,
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002532 prepare_fn, should_prune_fn,
2533 cleanup_fn, policy_cb_data);
David Turnere3688bd2016-09-04 18:08:38 +02002534}
David Turnerfc681462016-09-04 18:08:39 +02002535
2536int initial_ref_transaction_commit(struct ref_transaction *transaction,
2537 struct strbuf *err)
2538{
Nguyễn Thái Ngọc Duyc0fe4e82017-03-26 09:42:35 +07002539 struct ref_store *refs = transaction->ref_store;
David Turnerfc681462016-09-04 18:08:39 +02002540
2541 return refs->be->initial_transaction_commit(refs, transaction, err);
2542}
David Turnera27dcf82016-09-04 18:08:40 +02002543
Patrick Steinhardt4f2ba2d2022-02-17 14:04:32 +01002544void ref_transaction_for_each_queued_update(struct ref_transaction *transaction,
2545 ref_transaction_for_each_queued_update_fn cb,
2546 void *cb_data)
2547{
2548 int i;
2549
2550 for (i = 0; i < transaction->nr; i++) {
2551 struct ref_update *update = transaction->updates[i];
2552
2553 cb(update->refname,
2554 (update->flags & REF_HAVE_OLD) ? &update->old_oid : NULL,
2555 (update->flags & REF_HAVE_NEW) ? &update->new_oid : NULL,
2556 cb_data);
2557 }
2558}
2559
Junio C Hamano523fa692020-07-10 17:19:53 +00002560int refs_delete_refs(struct ref_store *refs, const char *logmsg,
Michael Haggerty64da4192017-05-22 16:17:38 +02002561 struct string_list *refnames, unsigned int flags)
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002562{
Junio C Hamano523fa692020-07-10 17:19:53 +00002563 char *msg;
2564 int retval;
2565
2566 msg = normalize_reflog_message(logmsg);
2567 retval = refs->be->delete_refs(refs, msg, refnames, flags);
2568 free(msg);
2569 return retval;
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002570}
2571
Michael Haggerty64da4192017-05-22 16:17:38 +02002572int delete_refs(const char *msg, struct string_list *refnames,
2573 unsigned int flags)
David Turnera27dcf82016-09-04 18:08:40 +02002574{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002575 return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002576}
David Turnera27dcf82016-09-04 18:08:40 +02002577
Nguyễn Thái Ngọc Duy7d2df052017-03-26 09:42:34 +07002578int refs_rename_ref(struct ref_store *refs, const char *oldref,
2579 const char *newref, const char *logmsg)
2580{
Junio C Hamano523fa692020-07-10 17:19:53 +00002581 char *msg;
2582 int retval;
2583
2584 msg = normalize_reflog_message(logmsg);
2585 retval = refs->be->rename_ref(refs, oldref, newref, msg);
2586 free(msg);
2587 return retval;
David Turnera27dcf82016-09-04 18:08:40 +02002588}
David Turner9b6b40d2016-09-04 18:08:42 +02002589
2590int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2591{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002592 return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
David Turner9b6b40d2016-09-04 18:08:42 +02002593}
Sahil Dua52d59cc2017-06-18 23:19:16 +02002594
2595int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2596 const char *newref, const char *logmsg)
2597{
Junio C Hamano523fa692020-07-10 17:19:53 +00002598 char *msg;
2599 int retval;
2600
2601 msg = normalize_reflog_message(logmsg);
2602 retval = refs->be->copy_ref(refs, oldref, newref, msg);
2603 free(msg);
2604 return retval;
Sahil Dua52d59cc2017-06-18 23:19:16 +02002605}
2606
2607int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2608{
Stefan Beller23a3f0c2018-04-11 17:21:09 -07002609 return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
Sahil Dua52d59cc2017-06-18 23:19:16 +02002610}