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