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