git.oblomov.eu Git - git/blob - refs.c

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