3dde824aab6eaba3440b851fdf1f9a4d817c763f
   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 *refs_shorten_unambiguous_ref(struct ref_store *refs,
1173                                   const char *refname, int strict)
1174{
1175        int i;
1176        static char **scanf_fmts;
1177        static int nr_rules;
1178        char *short_name;
1179        struct strbuf resolved_buf = STRBUF_INIT;
1180
1181        if (!nr_rules) {
1182                /*
1183                 * Pre-generate scanf formats from ref_rev_parse_rules[].
1184                 * Generate a format suitable for scanf from a
1185                 * ref_rev_parse_rules rule by interpolating "%s" at the
1186                 * location of the "%.*s".
1187                 */
1188                size_t total_len = 0;
1189                size_t offset = 0;
1190
1191                /* the rule list is NULL terminated, count them first */
1192                for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
1193                        /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
1194                        total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
1195
1196                scanf_fmts = xmalloc(st_add(st_mult(sizeof(char *), nr_rules), total_len));
1197
1198                offset = 0;
1199                for (i = 0; i < nr_rules; i++) {
1200                        assert(offset < total_len);
1201                        scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
1202                        offset += xsnprintf(scanf_fmts[i], total_len - offset,
1203                                            ref_rev_parse_rules[i], 2, "%s") + 1;
1204                }
1205        }
1206
1207        /* bail out if there are no rules */
1208        if (!nr_rules)
1209                return xstrdup(refname);
1210
1211        /* buffer for scanf result, at most refname must fit */
1212        short_name = xstrdup(refname);
1213
1214        /* skip first rule, it will always match */
1215        for (i = nr_rules - 1; i > 0 ; --i) {
1216                int j;
1217                int rules_to_fail = i;
1218                int short_name_len;
1219
1220                if (1 != sscanf(refname, scanf_fmts[i], short_name))
1221                        continue;
1222
1223                short_name_len = strlen(short_name);
1224
1225                /*
1226                 * in strict mode, all (except the matched one) rules
1227                 * must fail to resolve to a valid non-ambiguous ref
1228                 */
1229                if (strict)
1230                        rules_to_fail = nr_rules;
1231
1232                /*
1233                 * check if the short name resolves to a valid ref,
1234                 * but use only rules prior to the matched one
1235                 */
1236                for (j = 0; j < rules_to_fail; j++) {
1237                        const char *rule = ref_rev_parse_rules[j];
1238
1239                        /* skip matched rule */
1240                        if (i == j)
1241                                continue;
1242
1243                        /*
1244                         * the short name is ambiguous, if it resolves
1245                         * (with this previous rule) to a valid ref
1246                         * read_ref() returns 0 on success
1247                         */
1248                        strbuf_reset(&resolved_buf);
1249                        strbuf_addf(&resolved_buf, rule,
1250                                    short_name_len, short_name);
1251                        if (refs_ref_exists(refs, resolved_buf.buf))
1252                                break;
1253                }
1254
1255                /*
1256                 * short name is non-ambiguous if all previous rules
1257                 * haven't resolved to a valid ref
1258                 */
1259                if (j == rules_to_fail) {
1260                        strbuf_release(&resolved_buf);
1261                        return short_name;
1262                }
1263        }
1264
1265        strbuf_release(&resolved_buf);
1266        free(short_name);
1267        return xstrdup(refname);
1268}
1269
1270char *shorten_unambiguous_ref(const char *refname, int strict)
1271{
1272        return refs_shorten_unambiguous_ref(get_main_ref_store(the_repository),
1273                                            refname, strict);
1274}
1275
1276static struct string_list *hide_refs;
1277
1278int parse_hide_refs_config(const char *var, const char *value, const char *section)
1279{
1280        const char *key;
1281        if (!strcmp("transfer.hiderefs", var) ||
1282            (!parse_config_key(var, section, NULL, NULL, &key) &&
1283             !strcmp(key, "hiderefs"))) {
1284                char *ref;
1285                int len;
1286
1287                if (!value)
1288                        return config_error_nonbool(var);
1289                ref = xstrdup(value);
1290                len = strlen(ref);
1291                while (len && ref[len - 1] == '/')
1292                        ref[--len] = '\0';
1293                if (!hide_refs) {
1294                        hide_refs = xcalloc(1, sizeof(*hide_refs));
1295                        hide_refs->strdup_strings = 1;
1296                }
1297                string_list_append(hide_refs, ref);
1298        }
1299        return 0;
1300}
1301
1302int ref_is_hidden(const char *refname, const char *refname_full)
1303{
1304        int i;
1305
1306        if (!hide_refs)
1307                return 0;
1308        for (i = hide_refs->nr - 1; i >= 0; i--) {
1309                const char *match = hide_refs->items[i].string;
1310                const char *subject;
1311                int neg = 0;
1312                const char *p;
1313
1314                if (*match == '!') {
1315                        neg = 1;
1316                        match++;
1317                }
1318
1319                if (*match == '^') {
1320                        subject = refname_full;
1321                        match++;
1322                } else {
1323                        subject = refname;
1324                }
1325
1326                /* refname can be NULL when namespaces are used. */
1327                if (subject &&
1328                    skip_prefix(subject, match, &p) &&
1329                    (!*p || *p == '/'))
1330                        return !neg;
1331        }
1332        return 0;
1333}
1334
1335const char *find_descendant_ref(const char *dirname,
1336                                const struct string_list *extras,
1337                                const struct string_list *skip)
1338{
1339        int pos;
1340
1341        if (!extras)
1342                return NULL;
1343
1344        /*
1345         * Look at the place where dirname would be inserted into
1346         * extras. If there is an entry at that position that starts
1347         * with dirname (remember, dirname includes the trailing
1348         * slash) and is not in skip, then we have a conflict.
1349         */
1350        for (pos = string_list_find_insert_index(extras, dirname, 0);
1351             pos < extras->nr; pos++) {
1352                const char *extra_refname = extras->items[pos].string;
1353
1354                if (!starts_with(extra_refname, dirname))
1355                        break;
1356
1357                if (!skip || !string_list_has_string(skip, extra_refname))
1358                        return extra_refname;
1359        }
1360        return NULL;
1361}
1362
1363int refs_rename_ref_available(struct ref_store *refs,
1364                              const char *old_refname,
1365                              const char *new_refname)
1366{
1367        struct string_list skip = STRING_LIST_INIT_NODUP;
1368        struct strbuf err = STRBUF_INIT;
1369        int ok;
1370
1371        string_list_insert(&skip, old_refname);
1372        ok = !refs_verify_refname_available(refs, new_refname,
1373                                            NULL, &skip, &err);
1374        if (!ok)
1375                error("%s", err.buf);
1376
1377        string_list_clear(&skip, 0);
1378        strbuf_release(&err);
1379        return ok;
1380}
1381
1382int refs_head_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1383{
1384        struct object_id oid;
1385        int flag;
1386
1387        if (!refs_read_ref_full(refs, "HEAD", RESOLVE_REF_READING,
1388                                &oid, &flag))
1389                return fn("HEAD", &oid, flag, cb_data);
1390
1391        return 0;
1392}
1393
1394int head_ref(each_ref_fn fn, void *cb_data)
1395{
1396        return refs_head_ref(get_main_ref_store(the_repository), fn, cb_data);
1397}
1398
1399struct ref_iterator *refs_ref_iterator_begin(
1400                struct ref_store *refs,
1401                const char *prefix, int trim, int flags)
1402{
1403        struct ref_iterator *iter;
1404
1405        if (ref_paranoia < 0)
1406                ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);
1407        if (ref_paranoia)
1408                flags |= DO_FOR_EACH_INCLUDE_BROKEN;
1409
1410        iter = refs->be->iterator_begin(refs, prefix, flags);
1411
1412        /*
1413         * `iterator_begin()` already takes care of prefix, but we
1414         * might need to do some trimming:
1415         */
1416        if (trim)
1417                iter = prefix_ref_iterator_begin(iter, "", trim);
1418
1419        /* Sanity check for subclasses: */
1420        if (!iter->ordered)
1421                BUG("reference iterator is not ordered");
1422
1423        return iter;
1424}
1425
1426/*
1427 * Call fn for each reference in the specified submodule for which the
1428 * refname begins with prefix. If trim is non-zero, then trim that
1429 * many characters off the beginning of each refname before passing
1430 * the refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to
1431 * include broken references in the iteration. If fn ever returns a
1432 * non-zero value, stop the iteration and return that value;
1433 * otherwise, return 0.
1434 */
1435static int do_for_each_repo_ref(struct repository *r, const char *prefix,
1436                                each_repo_ref_fn fn, int trim, int flags,
1437                                void *cb_data)
1438{
1439        struct ref_iterator *iter;
1440        struct ref_store *refs = get_main_ref_store(r);
1441
1442        if (!refs)
1443                return 0;
1444
1445        iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1446
1447        return do_for_each_repo_ref_iterator(r, iter, fn, cb_data);
1448}
1449
1450struct do_for_each_ref_help {
1451        each_ref_fn *fn;
1452        void *cb_data;
1453};
1454
1455static int do_for_each_ref_helper(struct repository *r,
1456                                  const char *refname,
1457                                  const struct object_id *oid,
1458                                  int flags,
1459                                  void *cb_data)
1460{
1461        struct do_for_each_ref_help *hp = cb_data;
1462
1463        return hp->fn(refname, oid, flags, hp->cb_data);
1464}
1465
1466static int do_for_each_ref(struct ref_store *refs, const char *prefix,
1467                           each_ref_fn fn, int trim, int flags, void *cb_data)
1468{
1469        struct ref_iterator *iter;
1470        struct do_for_each_ref_help hp = { fn, cb_data };
1471
1472        if (!refs)
1473                return 0;
1474
1475        iter = refs_ref_iterator_begin(refs, prefix, trim, flags);
1476
1477        return do_for_each_repo_ref_iterator(the_repository, iter,
1478                                        do_for_each_ref_helper, &hp);
1479}
1480
1481int refs_for_each_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1482{
1483        return do_for_each_ref(refs, "", fn, 0, 0, cb_data);
1484}
1485
1486int for_each_ref(each_ref_fn fn, void *cb_data)
1487{
1488        return refs_for_each_ref(get_main_ref_store(the_repository), fn, cb_data);
1489}
1490
1491int refs_for_each_ref_in(struct ref_store *refs, const char *prefix,
1492                         each_ref_fn fn, void *cb_data)
1493{
1494        return do_for_each_ref(refs, prefix, fn, strlen(prefix), 0, cb_data);
1495}
1496
1497int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1498{
1499        return refs_for_each_ref_in(get_main_ref_store(the_repository), prefix, fn, cb_data);
1500}
1501
1502int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)
1503{
1504        unsigned int flag = 0;
1505
1506        if (broken)
1507                flag = DO_FOR_EACH_INCLUDE_BROKEN;
1508        return do_for_each_ref(get_main_ref_store(the_repository),
1509                               prefix, fn, 0, flag, cb_data);
1510}
1511
1512int refs_for_each_fullref_in(struct ref_store *refs, const char *prefix,
1513                             each_ref_fn fn, void *cb_data,
1514                             unsigned int broken)
1515{
1516        unsigned int flag = 0;
1517
1518        if (broken)
1519                flag = DO_FOR_EACH_INCLUDE_BROKEN;
1520        return do_for_each_ref(refs, prefix, fn, 0, flag, cb_data);
1521}
1522
1523int for_each_replace_ref(struct repository *r, each_repo_ref_fn fn, void *cb_data)
1524{
1525        return do_for_each_repo_ref(r, git_replace_ref_base, fn,
1526                                    strlen(git_replace_ref_base),
1527                                    DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1528}
1529
1530int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
1531{
1532        struct strbuf buf = STRBUF_INIT;
1533        int ret;
1534        strbuf_addf(&buf, "%srefs/", get_git_namespace());
1535        ret = do_for_each_ref(get_main_ref_store(the_repository),
1536                              buf.buf, fn, 0, 0, cb_data);
1537        strbuf_release(&buf);
1538        return ret;
1539}
1540
1541int refs_for_each_rawref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
1542{
1543        return do_for_each_ref(refs, "", fn, 0,
1544                               DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
1545}
1546
1547int for_each_rawref(each_ref_fn fn, void *cb_data)
1548{
1549        return refs_for_each_rawref(get_main_ref_store(the_repository), fn, cb_data);
1550}
1551
1552int refs_read_raw_ref(struct ref_store *ref_store,
1553                      const char *refname, struct object_id *oid,
1554                      struct strbuf *referent, unsigned int *type)
1555{
1556        return ref_store->be->read_raw_ref(ref_store, refname, oid, referent, type);
1557}
1558
1559/* This function needs to return a meaningful errno on failure */
1560const char *refs_resolve_ref_unsafe(struct ref_store *refs,
1561                                    const char *refname,
1562                                    int resolve_flags,
1563                                    struct object_id *oid, int *flags)
1564{
1565        static struct strbuf sb_refname = STRBUF_INIT;
1566        struct object_id unused_oid;
1567        int unused_flags;
1568        int symref_count;
1569
1570        if (!oid)
1571                oid = &unused_oid;
1572        if (!flags)
1573                flags = &unused_flags;
1574
1575        *flags = 0;
1576
1577        if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1578                if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1579                    !refname_is_safe(refname)) {
1580                        errno = EINVAL;
1581                        return NULL;
1582                }
1583
1584                /*
1585                 * dwim_ref() uses REF_ISBROKEN to distinguish between
1586                 * missing refs and refs that were present but invalid,
1587                 * to complain about the latter to stderr.
1588                 *
1589                 * We don't know whether the ref exists, so don't set
1590                 * REF_ISBROKEN yet.
1591                 */
1592                *flags |= REF_BAD_NAME;
1593        }
1594
1595        for (symref_count = 0; symref_count < SYMREF_MAXDEPTH; symref_count++) {
1596                unsigned int read_flags = 0;
1597
1598                if (refs_read_raw_ref(refs, refname,
1599                                      oid, &sb_refname, &read_flags)) {
1600                        *flags |= read_flags;
1601
1602                        /* In reading mode, refs must eventually resolve */
1603                        if (resolve_flags & RESOLVE_REF_READING)
1604                                return NULL;
1605
1606                        /*
1607                         * Otherwise a missing ref is OK. But the files backend
1608                         * may show errors besides ENOENT if there are
1609                         * similarly-named refs.
1610                         */
1611                        if (errno != ENOENT &&
1612                            errno != EISDIR &&
1613                            errno != ENOTDIR)
1614                                return NULL;
1615
1616                        oidclr(oid);
1617                        if (*flags & REF_BAD_NAME)
1618                                *flags |= REF_ISBROKEN;
1619                        return refname;
1620                }
1621
1622                *flags |= read_flags;
1623
1624                if (!(read_flags & REF_ISSYMREF)) {
1625                        if (*flags & REF_BAD_NAME) {
1626                                oidclr(oid);
1627                                *flags |= REF_ISBROKEN;
1628                        }
1629                        return refname;
1630                }
1631
1632                refname = sb_refname.buf;
1633                if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1634                        oidclr(oid);
1635                        return refname;
1636                }
1637                if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1638                        if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1639                            !refname_is_safe(refname)) {
1640                                errno = EINVAL;
1641                                return NULL;
1642                        }
1643
1644                        *flags |= REF_ISBROKEN | REF_BAD_NAME;
1645                }
1646        }
1647
1648        errno = ELOOP;
1649        return NULL;
1650}
1651
1652/* backend functions */
1653int refs_init_db(struct strbuf *err)
1654{
1655        struct ref_store *refs = get_main_ref_store(the_repository);
1656
1657        return refs->be->init_db(refs, err);
1658}
1659
1660const char *resolve_ref_unsafe(const char *refname, int resolve_flags,
1661                               struct object_id *oid, int *flags)
1662{
1663        return refs_resolve_ref_unsafe(get_main_ref_store(the_repository), refname,
1664                                       resolve_flags, oid, flags);
1665}
1666
1667int resolve_gitlink_ref(const char *submodule, const char *refname,
1668                        struct object_id *oid)
1669{
1670        struct ref_store *refs;
1671        int flags;
1672
1673        refs = get_submodule_ref_store(submodule);
1674
1675        if (!refs)
1676                return -1;
1677
1678        if (!refs_resolve_ref_unsafe(refs, refname, 0, oid, &flags) ||
1679            is_null_oid(oid))
1680                return -1;
1681        return 0;
1682}
1683
1684struct ref_store_hash_entry
1685{
1686        struct hashmap_entry ent; /* must be the first member! */
1687
1688        struct ref_store *refs;
1689
1690        /* NUL-terminated identifier of the ref store: */
1691        char name[FLEX_ARRAY];
1692};
1693
1694static int ref_store_hash_cmp(const void *unused_cmp_data,
1695                              const void *entry, const void *entry_or_key,
1696                              const void *keydata)
1697{
1698        const struct ref_store_hash_entry *e1 = entry, *e2 = entry_or_key;
1699        const char *name = keydata ? keydata : e2->name;
1700
1701        return strcmp(e1->name, name);
1702}
1703
1704static struct ref_store_hash_entry *alloc_ref_store_hash_entry(
1705                const char *name, struct ref_store *refs)
1706{
1707        struct ref_store_hash_entry *entry;
1708
1709        FLEX_ALLOC_STR(entry, name, name);
1710        hashmap_entry_init(entry, strhash(name));
1711        entry->refs = refs;
1712        return entry;
1713}
1714
1715/* A hashmap of ref_stores, stored by submodule name: */
1716static struct hashmap submodule_ref_stores;
1717
1718/* A hashmap of ref_stores, stored by worktree id: */
1719static struct hashmap worktree_ref_stores;
1720
1721/*
1722 * Look up a ref store by name. If that ref_store hasn't been
1723 * registered yet, return NULL.
1724 */
1725static struct ref_store *lookup_ref_store_map(struct hashmap *map,
1726                                              const char *name)
1727{
1728        struct ref_store_hash_entry *entry;
1729
1730        if (!map->tablesize)
1731                /* It's initialized on demand in register_ref_store(). */
1732                return NULL;
1733
1734        entry = hashmap_get_from_hash(map, strhash(name), name);
1735        return entry ? entry->refs : NULL;
1736}
1737
1738/*
1739 * Create, record, and return a ref_store instance for the specified
1740 * gitdir.
1741 */
1742static struct ref_store *ref_store_init(const char *gitdir,
1743                                        unsigned int flags)
1744{
1745        const char *be_name = "files";
1746        struct ref_storage_be *be = find_ref_storage_backend(be_name);
1747        struct ref_store *refs;
1748
1749        if (!be)
1750                BUG("reference backend %s is unknown", be_name);
1751
1752        refs = be->init(gitdir, flags);
1753        return refs;
1754}
1755
1756struct ref_store *get_main_ref_store(struct repository *r)
1757{
1758        if (r->refs)
1759                return r->refs;
1760
1761        if (!r->gitdir)
1762                BUG("attempting to get main_ref_store outside of repository");
1763
1764        r->refs = ref_store_init(r->gitdir, REF_STORE_ALL_CAPS);
1765        return r->refs;
1766}
1767
1768/*
1769 * Associate a ref store with a name. It is a fatal error to call this
1770 * function twice for the same name.
1771 */
1772static void register_ref_store_map(struct hashmap *map,
1773                                   const char *type,
1774                                   struct ref_store *refs,
1775                                   const char *name)
1776{
1777        if (!map->tablesize)
1778                hashmap_init(map, ref_store_hash_cmp, NULL, 0);
1779
1780        if (hashmap_put(map, alloc_ref_store_hash_entry(name, refs)))
1781                BUG("%s ref_store '%s' initialized twice", type, name);
1782}
1783
1784struct ref_store *get_submodule_ref_store(const char *submodule)
1785{
1786        struct strbuf submodule_sb = STRBUF_INIT;
1787        struct ref_store *refs;
1788        char *to_free = NULL;
1789        size_t len;
1790
1791        if (!submodule)
1792                return NULL;
1793
1794        len = strlen(submodule);
1795        while (len && is_dir_sep(submodule[len - 1]))
1796                len--;
1797        if (!len)
1798                return NULL;
1799
1800        if (submodule[len])
1801                /* We need to strip off one or more trailing slashes */
1802                submodule = to_free = xmemdupz(submodule, len);
1803
1804        refs = lookup_ref_store_map(&submodule_ref_stores, submodule);
1805        if (refs)
1806                goto done;
1807
1808        strbuf_addstr(&submodule_sb, submodule);
1809        if (!is_nonbare_repository_dir(&submodule_sb))
1810                goto done;
1811
1812        if (submodule_to_gitdir(&submodule_sb, submodule))
1813                goto done;
1814
1815        /* assume that add_submodule_odb() has been called */
1816        refs = ref_store_init(submodule_sb.buf,
1817                              REF_STORE_READ | REF_STORE_ODB);
1818        register_ref_store_map(&submodule_ref_stores, "submodule",
1819                               refs, submodule);
1820
1821done:
1822        strbuf_release(&submodule_sb);
1823        free(to_free);
1824
1825        return refs;
1826}
1827
1828struct ref_store *get_worktree_ref_store(const struct worktree *wt)
1829{
1830        struct ref_store *refs;
1831        const char *id;
1832
1833        if (wt->is_current)
1834                return get_main_ref_store(the_repository);
1835
1836        id = wt->id ? wt->id : "/";
1837        refs = lookup_ref_store_map(&worktree_ref_stores, id);
1838        if (refs)
1839                return refs;
1840
1841        if (wt->id)
1842                refs = ref_store_init(git_common_path("worktrees/%s", wt->id),
1843                                      REF_STORE_ALL_CAPS);
1844        else
1845                refs = ref_store_init(get_git_common_dir(),
1846                                      REF_STORE_ALL_CAPS);
1847
1848        if (refs)
1849                register_ref_store_map(&worktree_ref_stores, "worktree",
1850                                       refs, id);
1851        return refs;
1852}
1853
1854void base_ref_store_init(struct ref_store *refs,
1855                         const struct ref_storage_be *be)
1856{
1857        refs->be = be;
1858}
1859
1860/* backend functions */
1861int refs_pack_refs(struct ref_store *refs, unsigned int flags)
1862{
1863        return refs->be->pack_refs(refs, flags);
1864}
1865
1866int refs_peel_ref(struct ref_store *refs, const char *refname,
1867                  struct object_id *oid)
1868{
1869        int flag;
1870        struct object_id base;
1871
1872        if (current_ref_iter && current_ref_iter->refname == refname) {
1873                struct object_id peeled;
1874
1875                if (ref_iterator_peel(current_ref_iter, &peeled))
1876                        return -1;
1877                oidcpy(oid, &peeled);
1878                return 0;
1879        }
1880
1881        if (refs_read_ref_full(refs, refname,
1882                               RESOLVE_REF_READING, &base, &flag))
1883                return -1;
1884
1885        return peel_object(&base, oid);
1886}
1887
1888int peel_ref(const char *refname, struct object_id *oid)
1889{
1890        return refs_peel_ref(get_main_ref_store(the_repository), refname, oid);
1891}
1892
1893int refs_create_symref(struct ref_store *refs,
1894                       const char *ref_target,
1895                       const char *refs_heads_master,
1896                       const char *logmsg)
1897{
1898        return refs->be->create_symref(refs, ref_target,
1899                                       refs_heads_master,
1900                                       logmsg);
1901}
1902
1903int create_symref(const char *ref_target, const char *refs_heads_master,
1904                  const char *logmsg)
1905{
1906        return refs_create_symref(get_main_ref_store(the_repository), ref_target,
1907                                  refs_heads_master, logmsg);
1908}
1909
1910int ref_update_reject_duplicates(struct string_list *refnames,
1911                                 struct strbuf *err)
1912{
1913        size_t i, n = refnames->nr;
1914
1915        assert(err);
1916
1917        for (i = 1; i < n; i++) {
1918                int cmp = strcmp(refnames->items[i - 1].string,
1919                                 refnames->items[i].string);
1920
1921                if (!cmp) {
1922                        strbuf_addf(err,
1923                                    _("multiple updates for ref '%s' not allowed"),
1924                                    refnames->items[i].string);
1925                        return 1;
1926                } else if (cmp > 0) {
1927                        BUG("ref_update_reject_duplicates() received unsorted list");
1928                }
1929        }
1930        return 0;
1931}
1932
1933int ref_transaction_prepare(struct ref_transaction *transaction,
1934                            struct strbuf *err)
1935{
1936        struct ref_store *refs = transaction->ref_store;
1937
1938        switch (transaction->state) {
1939        case REF_TRANSACTION_OPEN:
1940                /* Good. */
1941                break;
1942        case REF_TRANSACTION_PREPARED:
1943                BUG("prepare called twice on reference transaction");
1944                break;
1945        case REF_TRANSACTION_CLOSED:
1946                BUG("prepare called on a closed reference transaction");
1947                break;
1948        default:
1949                BUG("unexpected reference transaction state");
1950                break;
1951        }
1952
1953        if (getenv(GIT_QUARANTINE_ENVIRONMENT)) {
1954                strbuf_addstr(err,
1955                              _("ref updates forbidden inside quarantine environment"));
1956                return -1;
1957        }
1958
1959        return refs->be->transaction_prepare(refs, transaction, err);
1960}
1961
1962int ref_transaction_abort(struct ref_transaction *transaction,
1963                          struct strbuf *err)
1964{
1965        struct ref_store *refs = transaction->ref_store;
1966        int ret = 0;
1967
1968        switch (transaction->state) {
1969        case REF_TRANSACTION_OPEN:
1970                /* No need to abort explicitly. */
1971                break;
1972        case REF_TRANSACTION_PREPARED:
1973                ret = refs->be->transaction_abort(refs, transaction, err);
1974                break;
1975        case REF_TRANSACTION_CLOSED:
1976                BUG("abort called on a closed reference transaction");
1977                break;
1978        default:
1979                BUG("unexpected reference transaction state");
1980                break;
1981        }
1982
1983        ref_transaction_free(transaction);
1984        return ret;
1985}
1986
1987int ref_transaction_commit(struct ref_transaction *transaction,
1988                           struct strbuf *err)
1989{
1990        struct ref_store *refs = transaction->ref_store;
1991        int ret;
1992
1993        switch (transaction->state) {
1994        case REF_TRANSACTION_OPEN:
1995                /* Need to prepare first. */
1996                ret = ref_transaction_prepare(transaction, err);
1997                if (ret)
1998                        return ret;
1999                break;
2000        case REF_TRANSACTION_PREPARED:
2001                /* Fall through to finish. */
2002                break;
2003        case REF_TRANSACTION_CLOSED:
2004                BUG("commit called on a closed reference transaction");
2005                break;
2006        default:
2007                BUG("unexpected reference transaction state");
2008                break;
2009        }
2010
2011        return refs->be->transaction_finish(refs, transaction, err);
2012}
2013
2014int refs_verify_refname_available(struct ref_store *refs,
2015                                  const char *refname,
2016                                  const struct string_list *extras,
2017                                  const struct string_list *skip,
2018                                  struct strbuf *err)
2019{
2020        const char *slash;
2021        const char *extra_refname;
2022        struct strbuf dirname = STRBUF_INIT;
2023        struct strbuf referent = STRBUF_INIT;
2024        struct object_id oid;
2025        unsigned int type;
2026        struct ref_iterator *iter;
2027        int ok;
2028        int ret = -1;
2029
2030        /*
2031         * For the sake of comments in this function, suppose that
2032         * refname is "refs/foo/bar".
2033         */
2034
2035        assert(err);
2036
2037        strbuf_grow(&dirname, strlen(refname) + 1);
2038        for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
2039                /* Expand dirname to the new prefix, not including the trailing slash: */
2040                strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len);
2041
2042                /*
2043                 * We are still at a leading dir of the refname (e.g.,
2044                 * "refs/foo"; if there is a reference with that name,
2045                 * it is a conflict, *unless* it is in skip.
2046                 */
2047                if (skip && string_list_has_string(skip, dirname.buf))
2048                        continue;
2049
2050                if (!refs_read_raw_ref(refs, dirname.buf, &oid, &referent, &type)) {
2051                        strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2052                                    dirname.buf, refname);
2053                        goto cleanup;
2054                }
2055
2056                if (extras && string_list_has_string(extras, dirname.buf)) {
2057                        strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2058                                    refname, dirname.buf);
2059                        goto cleanup;
2060                }
2061        }
2062
2063        /*
2064         * We are at the leaf of our refname (e.g., "refs/foo/bar").
2065         * There is no point in searching for a reference with that
2066         * name, because a refname isn't considered to conflict with
2067         * itself. But we still need to check for references whose
2068         * names are in the "refs/foo/bar/" namespace, because they
2069         * *do* conflict.
2070         */
2071        strbuf_addstr(&dirname, refname + dirname.len);
2072        strbuf_addch(&dirname, '/');
2073
2074        iter = refs_ref_iterator_begin(refs, dirname.buf, 0,
2075                                       DO_FOR_EACH_INCLUDE_BROKEN);
2076        while ((ok = ref_iterator_advance(iter)) == ITER_OK) {
2077                if (skip &&
2078                    string_list_has_string(skip, iter->refname))
2079                        continue;
2080
2081                strbuf_addf(err, _("'%s' exists; cannot create '%s'"),
2082                            iter->refname, refname);
2083                ref_iterator_abort(iter);
2084                goto cleanup;
2085        }
2086
2087        if (ok != ITER_DONE)
2088                BUG("error while iterating over references");
2089
2090        extra_refname = find_descendant_ref(dirname.buf, extras, skip);
2091        if (extra_refname)
2092                strbuf_addf(err, _("cannot process '%s' and '%s' at the same time"),
2093                            refname, extra_refname);
2094        else
2095                ret = 0;
2096
2097cleanup:
2098        strbuf_release(&referent);
2099        strbuf_release(&dirname);
2100        return ret;
2101}
2102
2103int refs_for_each_reflog(struct ref_store *refs, each_ref_fn fn, void *cb_data)
2104{
2105        struct ref_iterator *iter;
2106        struct do_for_each_ref_help hp = { fn, cb_data };
2107
2108        iter = refs->be->reflog_iterator_begin(refs);
2109
2110        return do_for_each_repo_ref_iterator(the_repository, iter,
2111                                             do_for_each_ref_helper, &hp);
2112}
2113
2114int for_each_reflog(each_ref_fn fn, void *cb_data)
2115{
2116        return refs_for_each_reflog(get_main_ref_store(the_repository), fn, cb_data);
2117}
2118
2119int refs_for_each_reflog_ent_reverse(struct ref_store *refs,
2120                                     const char *refname,
2121                                     each_reflog_ent_fn fn,
2122                                     void *cb_data)
2123{
2124        return refs->be->for_each_reflog_ent_reverse(refs, refname,
2125                                                     fn, cb_data);
2126}
2127
2128int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn,
2129                                void *cb_data)
2130{
2131        return refs_for_each_reflog_ent_reverse(get_main_ref_store(the_repository),
2132                                                refname, fn, cb_data);
2133}
2134
2135int refs_for_each_reflog_ent(struct ref_store *refs, const char *refname,
2136                             each_reflog_ent_fn fn, void *cb_data)
2137{
2138        return refs->be->for_each_reflog_ent(refs, refname, fn, cb_data);
2139}
2140
2141int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn,
2142                        void *cb_data)
2143{
2144        return refs_for_each_reflog_ent(get_main_ref_store(the_repository), refname,
2145                                        fn, cb_data);
2146}
2147
2148int refs_reflog_exists(struct ref_store *refs, const char *refname)
2149{
2150        return refs->be->reflog_exists(refs, refname);
2151}
2152
2153int reflog_exists(const char *refname)
2154{
2155        return refs_reflog_exists(get_main_ref_store(the_repository), refname);
2156}
2157
2158int refs_create_reflog(struct ref_store *refs, const char *refname,
2159                       int force_create, struct strbuf *err)
2160{
2161        return refs->be->create_reflog(refs, refname, force_create, err);
2162}
2163
2164int safe_create_reflog(const char *refname, int force_create,
2165                       struct strbuf *err)
2166{
2167        return refs_create_reflog(get_main_ref_store(the_repository), refname,
2168                                  force_create, err);
2169}
2170
2171int refs_delete_reflog(struct ref_store *refs, const char *refname)
2172{
2173        return refs->be->delete_reflog(refs, refname);
2174}
2175
2176int delete_reflog(const char *refname)
2177{
2178        return refs_delete_reflog(get_main_ref_store(the_repository), refname);
2179}
2180
2181int refs_reflog_expire(struct ref_store *refs,
2182                       const char *refname, const struct object_id *oid,
2183                       unsigned int flags,
2184                       reflog_expiry_prepare_fn prepare_fn,
2185                       reflog_expiry_should_prune_fn should_prune_fn,
2186                       reflog_expiry_cleanup_fn cleanup_fn,
2187                       void *policy_cb_data)
2188{
2189        return refs->be->reflog_expire(refs, refname, oid, flags,
2190                                       prepare_fn, should_prune_fn,
2191                                       cleanup_fn, policy_cb_data);
2192}
2193
2194int reflog_expire(const char *refname, const struct object_id *oid,
2195                  unsigned int flags,
2196                  reflog_expiry_prepare_fn prepare_fn,
2197                  reflog_expiry_should_prune_fn should_prune_fn,
2198                  reflog_expiry_cleanup_fn cleanup_fn,
2199                  void *policy_cb_data)
2200{
2201        return refs_reflog_expire(get_main_ref_store(the_repository),
2202                                  refname, oid, flags,
2203                                  prepare_fn, should_prune_fn,
2204                                  cleanup_fn, policy_cb_data);
2205}
2206
2207int initial_ref_transaction_commit(struct ref_transaction *transaction,
2208                                   struct strbuf *err)
2209{
2210        struct ref_store *refs = transaction->ref_store;
2211
2212        return refs->be->initial_transaction_commit(refs, transaction, err);
2213}
2214
2215int refs_delete_refs(struct ref_store *refs, const char *msg,
2216                     struct string_list *refnames, unsigned int flags)
2217{
2218        return refs->be->delete_refs(refs, msg, refnames, flags);
2219}
2220
2221int delete_refs(const char *msg, struct string_list *refnames,
2222                unsigned int flags)
2223{
2224        return refs_delete_refs(get_main_ref_store(the_repository), msg, refnames, flags);
2225}
2226
2227int refs_rename_ref(struct ref_store *refs, const char *oldref,
2228                    const char *newref, const char *logmsg)
2229{
2230        return refs->be->rename_ref(refs, oldref, newref, logmsg);
2231}
2232
2233int rename_ref(const char *oldref, const char *newref, const char *logmsg)
2234{
2235        return refs_rename_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
2236}
2237
2238int refs_copy_existing_ref(struct ref_store *refs, const char *oldref,
2239                    const char *newref, const char *logmsg)
2240{
2241        return refs->be->copy_ref(refs, oldref, newref, logmsg);
2242}
2243
2244int copy_existing_ref(const char *oldref, const char *newref, const char *logmsg)
2245{
2246        return refs_copy_existing_ref(get_main_ref_store(the_repository), oldref, newref, logmsg);
2247}