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