refs.con commit Merge branch 'dp/remove-duplicated-header-inclusion' into maint (be2804c)
   1#include "cache.h"
   2#include "lockfile.h"
   3#include "refs.h"
   4#include "object.h"
   5#include "tag.h"
   6#include "dir.h"
   7#include "string-list.h"
   8
   9/*
  10 * How to handle various characters in refnames:
  11 * 0: An acceptable character for refs
  12 * 1: End-of-component
  13 * 2: ., look for a preceding . to reject .. in refs
  14 * 3: {, look for a preceding @ to reject @{ in refs
  15 * 4: A bad character: ASCII control characters, "~", "^", ":" or SP
  16 */
  17static unsigned char refname_disposition[256] = {
  18        1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  19        4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  20        4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 2, 1,
  21        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4,
  22        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  23        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0,
  24        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  25        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4
  26};
  27
  28/*
  29 * Used as a flag to ref_transaction_delete when a loose ref is being
  30 * pruned.
  31 */
  32#define REF_ISPRUNING   0x0100
  33/*
  34 * Try to read one refname component from the front of refname.
  35 * Return the length of the component found, or -1 if the component is
  36 * not legal.  It is legal if it is something reasonable to have under
  37 * ".git/refs/"; We do not like it if:
  38 *
  39 * - any path component of it begins with ".", or
  40 * - it has double dots "..", or
  41 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or
  42 * - it ends with a "/".
  43 * - it ends with ".lock"
  44 * - it contains a "\" (backslash)
  45 */
  46static int check_refname_component(const char *refname, int flags)
  47{
  48        const char *cp;
  49        char last = '\0';
  50
  51        for (cp = refname; ; cp++) {
  52                int ch = *cp & 255;
  53                unsigned char disp = refname_disposition[ch];
  54                switch (disp) {
  55                case 1:
  56                        goto out;
  57                case 2:
  58                        if (last == '.')
  59                                return -1; /* Refname contains "..". */
  60                        break;
  61                case 3:
  62                        if (last == '@')
  63                                return -1; /* Refname contains "@{". */
  64                        break;
  65                case 4:
  66                        return -1;
  67                }
  68                last = ch;
  69        }
  70out:
  71        if (cp == refname)
  72                return 0; /* Component has zero length. */
  73        if (refname[0] == '.')
  74                return -1; /* Component starts with '.'. */
  75        if (cp - refname >= LOCK_SUFFIX_LEN &&
  76            !memcmp(cp - LOCK_SUFFIX_LEN, LOCK_SUFFIX, LOCK_SUFFIX_LEN))
  77                return -1; /* Refname ends with ".lock". */
  78        return cp - refname;
  79}
  80
  81int check_refname_format(const char *refname, int flags)
  82{
  83        int component_len, component_count = 0;
  84
  85        if (!strcmp(refname, "@"))
  86                /* Refname is a single character '@'. */
  87                return -1;
  88
  89        while (1) {
  90                /* We are at the start of a path component. */
  91                component_len = check_refname_component(refname, flags);
  92                if (component_len <= 0) {
  93                        if ((flags & REFNAME_REFSPEC_PATTERN) &&
  94                                        refname[0] == '*' &&
  95                                        (refname[1] == '\0' || refname[1] == '/')) {
  96                                /* Accept one wildcard as a full refname component. */
  97                                flags &= ~REFNAME_REFSPEC_PATTERN;
  98                                component_len = 1;
  99                        } else {
 100                                return -1;
 101                        }
 102                }
 103                component_count++;
 104                if (refname[component_len] == '\0')
 105                        break;
 106                /* Skip to next component. */
 107                refname += component_len + 1;
 108        }
 109
 110        if (refname[component_len - 1] == '.')
 111                return -1; /* Refname ends with '.'. */
 112        if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2)
 113                return -1; /* Refname has only one component. */
 114        return 0;
 115}
 116
 117struct ref_entry;
 118
 119/*
 120 * Information used (along with the information in ref_entry) to
 121 * describe a single cached reference.  This data structure only
 122 * occurs embedded in a union in struct ref_entry, and only when
 123 * (ref_entry->flag & REF_DIR) is zero.
 124 */
 125struct ref_value {
 126        /*
 127         * The name of the object to which this reference resolves
 128         * (which may be a tag object).  If REF_ISBROKEN, this is
 129         * null.  If REF_ISSYMREF, then this is the name of the object
 130         * referred to by the last reference in the symlink chain.
 131         */
 132        unsigned char sha1[20];
 133
 134        /*
 135         * If REF_KNOWS_PEELED, then this field holds the peeled value
 136         * of this reference, or null if the reference is known not to
 137         * be peelable.  See the documentation for peel_ref() for an
 138         * exact definition of "peelable".
 139         */
 140        unsigned char peeled[20];
 141};
 142
 143struct ref_cache;
 144
 145/*
 146 * Information used (along with the information in ref_entry) to
 147 * describe a level in the hierarchy of references.  This data
 148 * structure only occurs embedded in a union in struct ref_entry, and
 149 * only when (ref_entry.flag & REF_DIR) is set.  In that case,
 150 * (ref_entry.flag & REF_INCOMPLETE) determines whether the references
 151 * in the directory have already been read:
 152 *
 153 *     (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose
 154 *         or packed references, already read.
 155 *
 156 *     (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose
 157 *         references that hasn't been read yet (nor has any of its
 158 *         subdirectories).
 159 *
 160 * Entries within a directory are stored within a growable array of
 161 * pointers to ref_entries (entries, nr, alloc).  Entries 0 <= i <
 162 * sorted are sorted by their component name in strcmp() order and the
 163 * remaining entries are unsorted.
 164 *
 165 * Loose references are read lazily, one directory at a time.  When a
 166 * directory of loose references is read, then all of the references
 167 * in that directory are stored, and REF_INCOMPLETE stubs are created
 168 * for any subdirectories, but the subdirectories themselves are not
 169 * read.  The reading is triggered by get_ref_dir().
 170 */
 171struct ref_dir {
 172        int nr, alloc;
 173
 174        /*
 175         * Entries with index 0 <= i < sorted are sorted by name.  New
 176         * entries are appended to the list unsorted, and are sorted
 177         * only when required; thus we avoid the need to sort the list
 178         * after the addition of every reference.
 179         */
 180        int sorted;
 181
 182        /* A pointer to the ref_cache that contains this ref_dir. */
 183        struct ref_cache *ref_cache;
 184
 185        struct ref_entry **entries;
 186};
 187
 188/*
 189 * Bit values for ref_entry::flag.  REF_ISSYMREF=0x01,
 190 * REF_ISPACKED=0x02, REF_ISBROKEN=0x04 and REF_BAD_NAME=0x08 are
 191 * public values; see refs.h.
 192 */
 193
 194/*
 195 * The field ref_entry->u.value.peeled of this value entry contains
 196 * the correct peeled value for the reference, which might be
 197 * null_sha1 if the reference is not a tag or if it is broken.
 198 */
 199#define REF_KNOWS_PEELED 0x10
 200
 201/* ref_entry represents a directory of references */
 202#define REF_DIR 0x20
 203
 204/*
 205 * Entry has not yet been read from disk (used only for REF_DIR
 206 * entries representing loose references)
 207 */
 208#define REF_INCOMPLETE 0x40
 209
 210/*
 211 * A ref_entry represents either a reference or a "subdirectory" of
 212 * references.
 213 *
 214 * Each directory in the reference namespace is represented by a
 215 * ref_entry with (flags & REF_DIR) set and containing a subdir member
 216 * that holds the entries in that directory that have been read so
 217 * far.  If (flags & REF_INCOMPLETE) is set, then the directory and
 218 * its subdirectories haven't been read yet.  REF_INCOMPLETE is only
 219 * used for loose reference directories.
 220 *
 221 * References are represented by a ref_entry with (flags & REF_DIR)
 222 * unset and a value member that describes the reference's value.  The
 223 * flag member is at the ref_entry level, but it is also needed to
 224 * interpret the contents of the value field (in other words, a
 225 * ref_value object is not very much use without the enclosing
 226 * ref_entry).
 227 *
 228 * Reference names cannot end with slash and directories' names are
 229 * always stored with a trailing slash (except for the top-level
 230 * directory, which is always denoted by "").  This has two nice
 231 * consequences: (1) when the entries in each subdir are sorted
 232 * lexicographically by name (as they usually are), the references in
 233 * a whole tree can be generated in lexicographic order by traversing
 234 * the tree in left-to-right, depth-first order; (2) the names of
 235 * references and subdirectories cannot conflict, and therefore the
 236 * presence of an empty subdirectory does not block the creation of a
 237 * similarly-named reference.  (The fact that reference names with the
 238 * same leading components can conflict *with each other* is a
 239 * separate issue that is regulated by is_refname_available().)
 240 *
 241 * Please note that the name field contains the fully-qualified
 242 * reference (or subdirectory) name.  Space could be saved by only
 243 * storing the relative names.  But that would require the full names
 244 * to be generated on the fly when iterating in do_for_each_ref(), and
 245 * would break callback functions, who have always been able to assume
 246 * that the name strings that they are passed will not be freed during
 247 * the iteration.
 248 */
 249struct ref_entry {
 250        unsigned char flag; /* ISSYMREF? ISPACKED? */
 251        union {
 252                struct ref_value value; /* if not (flags&REF_DIR) */
 253                struct ref_dir subdir; /* if (flags&REF_DIR) */
 254        } u;
 255        /*
 256         * The full name of the reference (e.g., "refs/heads/master")
 257         * or the full name of the directory with a trailing slash
 258         * (e.g., "refs/heads/"):
 259         */
 260        char name[FLEX_ARRAY];
 261};
 262
 263static void read_loose_refs(const char *dirname, struct ref_dir *dir);
 264
 265static struct ref_dir *get_ref_dir(struct ref_entry *entry)
 266{
 267        struct ref_dir *dir;
 268        assert(entry->flag & REF_DIR);
 269        dir = &entry->u.subdir;
 270        if (entry->flag & REF_INCOMPLETE) {
 271                read_loose_refs(entry->name, dir);
 272                entry->flag &= ~REF_INCOMPLETE;
 273        }
 274        return dir;
 275}
 276
 277/*
 278 * Check if a refname is safe.
 279 * For refs that start with "refs/" we consider it safe as long they do
 280 * not try to resolve to outside of refs/.
 281 *
 282 * For all other refs we only consider them safe iff they only contain
 283 * upper case characters and '_' (like "HEAD" AND "MERGE_HEAD", and not like
 284 * "config").
 285 */
 286static int refname_is_safe(const char *refname)
 287{
 288        if (starts_with(refname, "refs/")) {
 289                char *buf;
 290                int result;
 291
 292                buf = xmalloc(strlen(refname) + 1);
 293                /*
 294                 * Does the refname try to escape refs/?
 295                 * For example: refs/foo/../bar is safe but refs/foo/../../bar
 296                 * is not.
 297                 */
 298                result = !normalize_path_copy(buf, refname + strlen("refs/"));
 299                free(buf);
 300                return result;
 301        }
 302        while (*refname) {
 303                if (!isupper(*refname) && *refname != '_')
 304                        return 0;
 305                refname++;
 306        }
 307        return 1;
 308}
 309
 310static struct ref_entry *create_ref_entry(const char *refname,
 311                                          const unsigned char *sha1, int flag,
 312                                          int check_name)
 313{
 314        int len;
 315        struct ref_entry *ref;
 316
 317        if (check_name &&
 318            check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))
 319                die("Reference has invalid format: '%s'", refname);
 320        if (!check_name && !refname_is_safe(refname))
 321                die("Reference has invalid name: '%s'", refname);
 322        len = strlen(refname) + 1;
 323        ref = xmalloc(sizeof(struct ref_entry) + len);
 324        hashcpy(ref->u.value.sha1, sha1);
 325        hashclr(ref->u.value.peeled);
 326        memcpy(ref->name, refname, len);
 327        ref->flag = flag;
 328        return ref;
 329}
 330
 331static void clear_ref_dir(struct ref_dir *dir);
 332
 333static void free_ref_entry(struct ref_entry *entry)
 334{
 335        if (entry->flag & REF_DIR) {
 336                /*
 337                 * Do not use get_ref_dir() here, as that might
 338                 * trigger the reading of loose refs.
 339                 */
 340                clear_ref_dir(&entry->u.subdir);
 341        }
 342        free(entry);
 343}
 344
 345/*
 346 * Add a ref_entry to the end of dir (unsorted).  Entry is always
 347 * stored directly in dir; no recursion into subdirectories is
 348 * done.
 349 */
 350static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry)
 351{
 352        ALLOC_GROW(dir->entries, dir->nr + 1, dir->alloc);
 353        dir->entries[dir->nr++] = entry;
 354        /* optimize for the case that entries are added in order */
 355        if (dir->nr == 1 ||
 356            (dir->nr == dir->sorted + 1 &&
 357             strcmp(dir->entries[dir->nr - 2]->name,
 358                    dir->entries[dir->nr - 1]->name) < 0))
 359                dir->sorted = dir->nr;
 360}
 361
 362/*
 363 * Clear and free all entries in dir, recursively.
 364 */
 365static void clear_ref_dir(struct ref_dir *dir)
 366{
 367        int i;
 368        for (i = 0; i < dir->nr; i++)
 369                free_ref_entry(dir->entries[i]);
 370        free(dir->entries);
 371        dir->sorted = dir->nr = dir->alloc = 0;
 372        dir->entries = NULL;
 373}
 374
 375/*
 376 * Create a struct ref_entry object for the specified dirname.
 377 * dirname is the name of the directory with a trailing slash (e.g.,
 378 * "refs/heads/") or "" for the top-level directory.
 379 */
 380static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache,
 381                                          const char *dirname, size_t len,
 382                                          int incomplete)
 383{
 384        struct ref_entry *direntry;
 385        direntry = xcalloc(1, sizeof(struct ref_entry) + len + 1);
 386        memcpy(direntry->name, dirname, len);
 387        direntry->name[len] = '\0';
 388        direntry->u.subdir.ref_cache = ref_cache;
 389        direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE : 0);
 390        return direntry;
 391}
 392
 393static int ref_entry_cmp(const void *a, const void *b)
 394{
 395        struct ref_entry *one = *(struct ref_entry **)a;
 396        struct ref_entry *two = *(struct ref_entry **)b;
 397        return strcmp(one->name, two->name);
 398}
 399
 400static void sort_ref_dir(struct ref_dir *dir);
 401
 402struct string_slice {
 403        size_t len;
 404        const char *str;
 405};
 406
 407static int ref_entry_cmp_sslice(const void *key_, const void *ent_)
 408{
 409        const struct string_slice *key = key_;
 410        const struct ref_entry *ent = *(const struct ref_entry * const *)ent_;
 411        int cmp = strncmp(key->str, ent->name, key->len);
 412        if (cmp)
 413                return cmp;
 414        return '\0' - (unsigned char)ent->name[key->len];
 415}
 416
 417/*
 418 * Return the index of the entry with the given refname from the
 419 * ref_dir (non-recursively), sorting dir if necessary.  Return -1 if
 420 * no such entry is found.  dir must already be complete.
 421 */
 422static int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len)
 423{
 424        struct ref_entry **r;
 425        struct string_slice key;
 426
 427        if (refname == NULL || !dir->nr)
 428                return -1;
 429
 430        sort_ref_dir(dir);
 431        key.len = len;
 432        key.str = refname;
 433        r = bsearch(&key, dir->entries, dir->nr, sizeof(*dir->entries),
 434                    ref_entry_cmp_sslice);
 435
 436        if (r == NULL)
 437                return -1;
 438
 439        return r - dir->entries;
 440}
 441
 442/*
 443 * Search for a directory entry directly within dir (without
 444 * recursing).  Sort dir if necessary.  subdirname must be a directory
 445 * name (i.e., end in '/').  If mkdir is set, then create the
 446 * directory if it is missing; otherwise, return NULL if the desired
 447 * directory cannot be found.  dir must already be complete.
 448 */
 449static struct ref_dir *search_for_subdir(struct ref_dir *dir,
 450                                         const char *subdirname, size_t len,
 451                                         int mkdir)
 452{
 453        int entry_index = search_ref_dir(dir, subdirname, len);
 454        struct ref_entry *entry;
 455        if (entry_index == -1) {
 456                if (!mkdir)
 457                        return NULL;
 458                /*
 459                 * Since dir is complete, the absence of a subdir
 460                 * means that the subdir really doesn't exist;
 461                 * therefore, create an empty record for it but mark
 462                 * the record complete.
 463                 */
 464                entry = create_dir_entry(dir->ref_cache, subdirname, len, 0);
 465                add_entry_to_dir(dir, entry);
 466        } else {
 467                entry = dir->entries[entry_index];
 468        }
 469        return get_ref_dir(entry);
 470}
 471
 472/*
 473 * If refname is a reference name, find the ref_dir within the dir
 474 * tree that should hold refname.  If refname is a directory name
 475 * (i.e., ends in '/'), then return that ref_dir itself.  dir must
 476 * represent the top-level directory and must already be complete.
 477 * Sort ref_dirs and recurse into subdirectories as necessary.  If
 478 * mkdir is set, then create any missing directories; otherwise,
 479 * return NULL if the desired directory cannot be found.
 480 */
 481static struct ref_dir *find_containing_dir(struct ref_dir *dir,
 482                                           const char *refname, int mkdir)
 483{
 484        const char *slash;
 485        for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
 486                size_t dirnamelen = slash - refname + 1;
 487                struct ref_dir *subdir;
 488                subdir = search_for_subdir(dir, refname, dirnamelen, mkdir);
 489                if (!subdir) {
 490                        dir = NULL;
 491                        break;
 492                }
 493                dir = subdir;
 494        }
 495
 496        return dir;
 497}
 498
 499/*
 500 * Find the value entry with the given name in dir, sorting ref_dirs
 501 * and recursing into subdirectories as necessary.  If the name is not
 502 * found or it corresponds to a directory entry, return NULL.
 503 */
 504static struct ref_entry *find_ref(struct ref_dir *dir, const char *refname)
 505{
 506        int entry_index;
 507        struct ref_entry *entry;
 508        dir = find_containing_dir(dir, refname, 0);
 509        if (!dir)
 510                return NULL;
 511        entry_index = search_ref_dir(dir, refname, strlen(refname));
 512        if (entry_index == -1)
 513                return NULL;
 514        entry = dir->entries[entry_index];
 515        return (entry->flag & REF_DIR) ? NULL : entry;
 516}
 517
 518/*
 519 * Remove the entry with the given name from dir, recursing into
 520 * subdirectories as necessary.  If refname is the name of a directory
 521 * (i.e., ends with '/'), then remove the directory and its contents.
 522 * If the removal was successful, return the number of entries
 523 * remaining in the directory entry that contained the deleted entry.
 524 * If the name was not found, return -1.  Please note that this
 525 * function only deletes the entry from the cache; it does not delete
 526 * it from the filesystem or ensure that other cache entries (which
 527 * might be symbolic references to the removed entry) are updated.
 528 * Nor does it remove any containing dir entries that might be made
 529 * empty by the removal.  dir must represent the top-level directory
 530 * and must already be complete.
 531 */
 532static int remove_entry(struct ref_dir *dir, const char *refname)
 533{
 534        int refname_len = strlen(refname);
 535        int entry_index;
 536        struct ref_entry *entry;
 537        int is_dir = refname[refname_len - 1] == '/';
 538        if (is_dir) {
 539                /*
 540                 * refname represents a reference directory.  Remove
 541                 * the trailing slash; otherwise we will get the
 542                 * directory *representing* refname rather than the
 543                 * one *containing* it.
 544                 */
 545                char *dirname = xmemdupz(refname, refname_len - 1);
 546                dir = find_containing_dir(dir, dirname, 0);
 547                free(dirname);
 548        } else {
 549                dir = find_containing_dir(dir, refname, 0);
 550        }
 551        if (!dir)
 552                return -1;
 553        entry_index = search_ref_dir(dir, refname, refname_len);
 554        if (entry_index == -1)
 555                return -1;
 556        entry = dir->entries[entry_index];
 557
 558        memmove(&dir->entries[entry_index],
 559                &dir->entries[entry_index + 1],
 560                (dir->nr - entry_index - 1) * sizeof(*dir->entries)
 561                );
 562        dir->nr--;
 563        if (dir->sorted > entry_index)
 564                dir->sorted--;
 565        free_ref_entry(entry);
 566        return dir->nr;
 567}
 568
 569/*
 570 * Add a ref_entry to the ref_dir (unsorted), recursing into
 571 * subdirectories as necessary.  dir must represent the top-level
 572 * directory.  Return 0 on success.
 573 */
 574static int add_ref(struct ref_dir *dir, struct ref_entry *ref)
 575{
 576        dir = find_containing_dir(dir, ref->name, 1);
 577        if (!dir)
 578                return -1;
 579        add_entry_to_dir(dir, ref);
 580        return 0;
 581}
 582
 583/*
 584 * Emit a warning and return true iff ref1 and ref2 have the same name
 585 * and the same sha1.  Die if they have the same name but different
 586 * sha1s.
 587 */
 588static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2)
 589{
 590        if (strcmp(ref1->name, ref2->name))
 591                return 0;
 592
 593        /* Duplicate name; make sure that they don't conflict: */
 594
 595        if ((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR))
 596                /* This is impossible by construction */
 597                die("Reference directory conflict: %s", ref1->name);
 598
 599        if (hashcmp(ref1->u.value.sha1, ref2->u.value.sha1))
 600                die("Duplicated ref, and SHA1s don't match: %s", ref1->name);
 601
 602        warning("Duplicated ref: %s", ref1->name);
 603        return 1;
 604}
 605
 606/*
 607 * Sort the entries in dir non-recursively (if they are not already
 608 * sorted) and remove any duplicate entries.
 609 */
 610static void sort_ref_dir(struct ref_dir *dir)
 611{
 612        int i, j;
 613        struct ref_entry *last = NULL;
 614
 615        /*
 616         * This check also prevents passing a zero-length array to qsort(),
 617         * which is a problem on some platforms.
 618         */
 619        if (dir->sorted == dir->nr)
 620                return;
 621
 622        qsort(dir->entries, dir->nr, sizeof(*dir->entries), ref_entry_cmp);
 623
 624        /* Remove any duplicates: */
 625        for (i = 0, j = 0; j < dir->nr; j++) {
 626                struct ref_entry *entry = dir->entries[j];
 627                if (last && is_dup_ref(last, entry))
 628                        free_ref_entry(entry);
 629                else
 630                        last = dir->entries[i++] = entry;
 631        }
 632        dir->sorted = dir->nr = i;
 633}
 634
 635/* Include broken references in a do_for_each_ref*() iteration: */
 636#define DO_FOR_EACH_INCLUDE_BROKEN 0x01
 637
 638/*
 639 * Return true iff the reference described by entry can be resolved to
 640 * an object in the database.  Emit a warning if the referred-to
 641 * object does not exist.
 642 */
 643static int ref_resolves_to_object(struct ref_entry *entry)
 644{
 645        if (entry->flag & REF_ISBROKEN)
 646                return 0;
 647        if (!has_sha1_file(entry->u.value.sha1)) {
 648                error("%s does not point to a valid object!", entry->name);
 649                return 0;
 650        }
 651        return 1;
 652}
 653
 654/*
 655 * current_ref is a performance hack: when iterating over references
 656 * using the for_each_ref*() functions, current_ref is set to the
 657 * current reference's entry before calling the callback function.  If
 658 * the callback function calls peel_ref(), then peel_ref() first
 659 * checks whether the reference to be peeled is the current reference
 660 * (it usually is) and if so, returns that reference's peeled version
 661 * if it is available.  This avoids a refname lookup in a common case.
 662 */
 663static struct ref_entry *current_ref;
 664
 665typedef int each_ref_entry_fn(struct ref_entry *entry, void *cb_data);
 666
 667struct ref_entry_cb {
 668        const char *base;
 669        int trim;
 670        int flags;
 671        each_ref_fn *fn;
 672        void *cb_data;
 673};
 674
 675/*
 676 * Handle one reference in a do_for_each_ref*()-style iteration,
 677 * calling an each_ref_fn for each entry.
 678 */
 679static int do_one_ref(struct ref_entry *entry, void *cb_data)
 680{
 681        struct ref_entry_cb *data = cb_data;
 682        struct ref_entry *old_current_ref;
 683        int retval;
 684
 685        if (!starts_with(entry->name, data->base))
 686                return 0;
 687
 688        if (!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) &&
 689              !ref_resolves_to_object(entry))
 690                return 0;
 691
 692        /* Store the old value, in case this is a recursive call: */
 693        old_current_ref = current_ref;
 694        current_ref = entry;
 695        retval = data->fn(entry->name + data->trim, entry->u.value.sha1,
 696                          entry->flag, data->cb_data);
 697        current_ref = old_current_ref;
 698        return retval;
 699}
 700
 701/*
 702 * Call fn for each reference in dir that has index in the range
 703 * offset <= index < dir->nr.  Recurse into subdirectories that are in
 704 * that index range, sorting them before iterating.  This function
 705 * does not sort dir itself; it should be sorted beforehand.  fn is
 706 * called for all references, including broken ones.
 707 */
 708static int do_for_each_entry_in_dir(struct ref_dir *dir, int offset,
 709                                    each_ref_entry_fn fn, void *cb_data)
 710{
 711        int i;
 712        assert(dir->sorted == dir->nr);
 713        for (i = offset; i < dir->nr; i++) {
 714                struct ref_entry *entry = dir->entries[i];
 715                int retval;
 716                if (entry->flag & REF_DIR) {
 717                        struct ref_dir *subdir = get_ref_dir(entry);
 718                        sort_ref_dir(subdir);
 719                        retval = do_for_each_entry_in_dir(subdir, 0, fn, cb_data);
 720                } else {
 721                        retval = fn(entry, cb_data);
 722                }
 723                if (retval)
 724                        return retval;
 725        }
 726        return 0;
 727}
 728
 729/*
 730 * Call fn for each reference in the union of dir1 and dir2, in order
 731 * by refname.  Recurse into subdirectories.  If a value entry appears
 732 * in both dir1 and dir2, then only process the version that is in
 733 * dir2.  The input dirs must already be sorted, but subdirs will be
 734 * sorted as needed.  fn is called for all references, including
 735 * broken ones.
 736 */
 737static int do_for_each_entry_in_dirs(struct ref_dir *dir1,
 738                                     struct ref_dir *dir2,
 739                                     each_ref_entry_fn fn, void *cb_data)
 740{
 741        int retval;
 742        int i1 = 0, i2 = 0;
 743
 744        assert(dir1->sorted == dir1->nr);
 745        assert(dir2->sorted == dir2->nr);
 746        while (1) {
 747                struct ref_entry *e1, *e2;
 748                int cmp;
 749                if (i1 == dir1->nr) {
 750                        return do_for_each_entry_in_dir(dir2, i2, fn, cb_data);
 751                }
 752                if (i2 == dir2->nr) {
 753                        return do_for_each_entry_in_dir(dir1, i1, fn, cb_data);
 754                }
 755                e1 = dir1->entries[i1];
 756                e2 = dir2->entries[i2];
 757                cmp = strcmp(e1->name, e2->name);
 758                if (cmp == 0) {
 759                        if ((e1->flag & REF_DIR) && (e2->flag & REF_DIR)) {
 760                                /* Both are directories; descend them in parallel. */
 761                                struct ref_dir *subdir1 = get_ref_dir(e1);
 762                                struct ref_dir *subdir2 = get_ref_dir(e2);
 763                                sort_ref_dir(subdir1);
 764                                sort_ref_dir(subdir2);
 765                                retval = do_for_each_entry_in_dirs(
 766                                                subdir1, subdir2, fn, cb_data);
 767                                i1++;
 768                                i2++;
 769                        } else if (!(e1->flag & REF_DIR) && !(e2->flag & REF_DIR)) {
 770                                /* Both are references; ignore the one from dir1. */
 771                                retval = fn(e2, cb_data);
 772                                i1++;
 773                                i2++;
 774                        } else {
 775                                die("conflict between reference and directory: %s",
 776                                    e1->name);
 777                        }
 778                } else {
 779                        struct ref_entry *e;
 780                        if (cmp < 0) {
 781                                e = e1;
 782                                i1++;
 783                        } else {
 784                                e = e2;
 785                                i2++;
 786                        }
 787                        if (e->flag & REF_DIR) {
 788                                struct ref_dir *subdir = get_ref_dir(e);
 789                                sort_ref_dir(subdir);
 790                                retval = do_for_each_entry_in_dir(
 791                                                subdir, 0, fn, cb_data);
 792                        } else {
 793                                retval = fn(e, cb_data);
 794                        }
 795                }
 796                if (retval)
 797                        return retval;
 798        }
 799}
 800
 801/*
 802 * Load all of the refs from the dir into our in-memory cache. The hard work
 803 * of loading loose refs is done by get_ref_dir(), so we just need to recurse
 804 * through all of the sub-directories. We do not even need to care about
 805 * sorting, as traversal order does not matter to us.
 806 */
 807static void prime_ref_dir(struct ref_dir *dir)
 808{
 809        int i;
 810        for (i = 0; i < dir->nr; i++) {
 811                struct ref_entry *entry = dir->entries[i];
 812                if (entry->flag & REF_DIR)
 813                        prime_ref_dir(get_ref_dir(entry));
 814        }
 815}
 816
 817static int entry_matches(struct ref_entry *entry, const struct string_list *list)
 818{
 819        return list && string_list_has_string(list, entry->name);
 820}
 821
 822struct nonmatching_ref_data {
 823        const struct string_list *skip;
 824        struct ref_entry *found;
 825};
 826
 827static int nonmatching_ref_fn(struct ref_entry *entry, void *vdata)
 828{
 829        struct nonmatching_ref_data *data = vdata;
 830
 831        if (entry_matches(entry, data->skip))
 832                return 0;
 833
 834        data->found = entry;
 835        return 1;
 836}
 837
 838static void report_refname_conflict(struct ref_entry *entry,
 839                                    const char *refname)
 840{
 841        error("'%s' exists; cannot create '%s'", entry->name, refname);
 842}
 843
 844/*
 845 * Return true iff a reference named refname could be created without
 846 * conflicting with the name of an existing reference in dir.  If
 847 * skip is non-NULL, ignore potential conflicts with refs in skip
 848 * (e.g., because they are scheduled for deletion in the same
 849 * operation).
 850 *
 851 * Two reference names conflict if one of them exactly matches the
 852 * leading components of the other; e.g., "foo/bar" conflicts with
 853 * both "foo" and with "foo/bar/baz" but not with "foo/bar" or
 854 * "foo/barbados".
 855 *
 856 * skip must be sorted.
 857 */
 858static int is_refname_available(const char *refname,
 859                                const struct string_list *skip,
 860                                struct ref_dir *dir)
 861{
 862        const char *slash;
 863        size_t len;
 864        int pos;
 865        char *dirname;
 866
 867        for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) {
 868                /*
 869                 * We are still at a leading dir of the refname; we are
 870                 * looking for a conflict with a leaf entry.
 871                 *
 872                 * If we find one, we still must make sure it is
 873                 * not in "skip".
 874                 */
 875                pos = search_ref_dir(dir, refname, slash - refname);
 876                if (pos >= 0) {
 877                        struct ref_entry *entry = dir->entries[pos];
 878                        if (entry_matches(entry, skip))
 879                                return 1;
 880                        report_refname_conflict(entry, refname);
 881                        return 0;
 882                }
 883
 884
 885                /*
 886                 * Otherwise, we can try to continue our search with
 887                 * the next component; if we come up empty, we know
 888                 * there is nothing under this whole prefix.
 889                 */
 890                pos = search_ref_dir(dir, refname, slash + 1 - refname);
 891                if (pos < 0)
 892                        return 1;
 893
 894                dir = get_ref_dir(dir->entries[pos]);
 895        }
 896
 897        /*
 898         * We are at the leaf of our refname; we want to
 899         * make sure there are no directories which match it.
 900         */
 901        len = strlen(refname);
 902        dirname = xmallocz(len + 1);
 903        sprintf(dirname, "%s/", refname);
 904        pos = search_ref_dir(dir, dirname, len + 1);
 905        free(dirname);
 906
 907        if (pos >= 0) {
 908                /*
 909                 * We found a directory named "refname". It is a
 910                 * problem iff it contains any ref that is not
 911                 * in "skip".
 912                 */
 913                struct ref_entry *entry = dir->entries[pos];
 914                struct ref_dir *dir = get_ref_dir(entry);
 915                struct nonmatching_ref_data data;
 916
 917                data.skip = skip;
 918                sort_ref_dir(dir);
 919                if (!do_for_each_entry_in_dir(dir, 0, nonmatching_ref_fn, &data))
 920                        return 1;
 921
 922                report_refname_conflict(data.found, refname);
 923                return 0;
 924        }
 925
 926        /*
 927         * There is no point in searching for another leaf
 928         * node which matches it; such an entry would be the
 929         * ref we are looking for, not a conflict.
 930         */
 931        return 1;
 932}
 933
 934struct packed_ref_cache {
 935        struct ref_entry *root;
 936
 937        /*
 938         * Count of references to the data structure in this instance,
 939         * including the pointer from ref_cache::packed if any.  The
 940         * data will not be freed as long as the reference count is
 941         * nonzero.
 942         */
 943        unsigned int referrers;
 944
 945        /*
 946         * Iff the packed-refs file associated with this instance is
 947         * currently locked for writing, this points at the associated
 948         * lock (which is owned by somebody else).  The referrer count
 949         * is also incremented when the file is locked and decremented
 950         * when it is unlocked.
 951         */
 952        struct lock_file *lock;
 953
 954        /* The metadata from when this packed-refs cache was read */
 955        struct stat_validity validity;
 956};
 957
 958/*
 959 * Future: need to be in "struct repository"
 960 * when doing a full libification.
 961 */
 962static struct ref_cache {
 963        struct ref_cache *next;
 964        struct ref_entry *loose;
 965        struct packed_ref_cache *packed;
 966        /*
 967         * The submodule name, or "" for the main repo.  We allocate
 968         * length 1 rather than FLEX_ARRAY so that the main ref_cache
 969         * is initialized correctly.
 970         */
 971        char name[1];
 972} ref_cache, *submodule_ref_caches;
 973
 974/* Lock used for the main packed-refs file: */
 975static struct lock_file packlock;
 976
 977/*
 978 * Increment the reference count of *packed_refs.
 979 */
 980static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs)
 981{
 982        packed_refs->referrers++;
 983}
 984
 985/*
 986 * Decrease the reference count of *packed_refs.  If it goes to zero,
 987 * free *packed_refs and return true; otherwise return false.
 988 */
 989static int release_packed_ref_cache(struct packed_ref_cache *packed_refs)
 990{
 991        if (!--packed_refs->referrers) {
 992                free_ref_entry(packed_refs->root);
 993                stat_validity_clear(&packed_refs->validity);
 994                free(packed_refs);
 995                return 1;
 996        } else {
 997                return 0;
 998        }
 999}
1000
1001static void clear_packed_ref_cache(struct ref_cache *refs)
1002{
1003        if (refs->packed) {
1004                struct packed_ref_cache *packed_refs = refs->packed;
1005
1006                if (packed_refs->lock)
1007                        die("internal error: packed-ref cache cleared while locked");
1008                refs->packed = NULL;
1009                release_packed_ref_cache(packed_refs);
1010        }
1011}
1012
1013static void clear_loose_ref_cache(struct ref_cache *refs)
1014{
1015        if (refs->loose) {
1016                free_ref_entry(refs->loose);
1017                refs->loose = NULL;
1018        }
1019}
1020
1021static struct ref_cache *create_ref_cache(const char *submodule)
1022{
1023        int len;
1024        struct ref_cache *refs;
1025        if (!submodule)
1026                submodule = "";
1027        len = strlen(submodule) + 1;
1028        refs = xcalloc(1, sizeof(struct ref_cache) + len);
1029        memcpy(refs->name, submodule, len);
1030        return refs;
1031}
1032
1033/*
1034 * Return a pointer to a ref_cache for the specified submodule. For
1035 * the main repository, use submodule==NULL. The returned structure
1036 * will be allocated and initialized but not necessarily populated; it
1037 * should not be freed.
1038 */
1039static struct ref_cache *get_ref_cache(const char *submodule)
1040{
1041        struct ref_cache *refs;
1042
1043        if (!submodule || !*submodule)
1044                return &ref_cache;
1045
1046        for (refs = submodule_ref_caches; refs; refs = refs->next)
1047                if (!strcmp(submodule, refs->name))
1048                        return refs;
1049
1050        refs = create_ref_cache(submodule);
1051        refs->next = submodule_ref_caches;
1052        submodule_ref_caches = refs;
1053        return refs;
1054}
1055
1056/* The length of a peeled reference line in packed-refs, including EOL: */
1057#define PEELED_LINE_LENGTH 42
1058
1059/*
1060 * The packed-refs header line that we write out.  Perhaps other
1061 * traits will be added later.  The trailing space is required.
1062 */
1063static const char PACKED_REFS_HEADER[] =
1064        "# pack-refs with: peeled fully-peeled \n";
1065
1066/*
1067 * Parse one line from a packed-refs file.  Write the SHA1 to sha1.
1068 * Return a pointer to the refname within the line (null-terminated),
1069 * or NULL if there was a problem.
1070 */
1071static const char *parse_ref_line(struct strbuf *line, unsigned char *sha1)
1072{
1073        const char *ref;
1074
1075        /*
1076         * 42: the answer to everything.
1077         *
1078         * In this case, it happens to be the answer to
1079         *  40 (length of sha1 hex representation)
1080         *  +1 (space in between hex and name)
1081         *  +1 (newline at the end of the line)
1082         */
1083        if (line->len <= 42)
1084                return NULL;
1085
1086        if (get_sha1_hex(line->buf, sha1) < 0)
1087                return NULL;
1088        if (!isspace(line->buf[40]))
1089                return NULL;
1090
1091        ref = line->buf + 41;
1092        if (isspace(*ref))
1093                return NULL;
1094
1095        if (line->buf[line->len - 1] != '\n')
1096                return NULL;
1097        line->buf[--line->len] = 0;
1098
1099        return ref;
1100}
1101
1102/*
1103 * Read f, which is a packed-refs file, into dir.
1104 *
1105 * A comment line of the form "# pack-refs with: " may contain zero or
1106 * more traits. We interpret the traits as follows:
1107 *
1108 *   No traits:
1109 *
1110 *      Probably no references are peeled. But if the file contains a
1111 *      peeled value for a reference, we will use it.
1112 *
1113 *   peeled:
1114 *
1115 *      References under "refs/tags/", if they *can* be peeled, *are*
1116 *      peeled in this file. References outside of "refs/tags/" are
1117 *      probably not peeled even if they could have been, but if we find
1118 *      a peeled value for such a reference we will use it.
1119 *
1120 *   fully-peeled:
1121 *
1122 *      All references in the file that can be peeled are peeled.
1123 *      Inversely (and this is more important), any references in the
1124 *      file for which no peeled value is recorded is not peelable. This
1125 *      trait should typically be written alongside "peeled" for
1126 *      compatibility with older clients, but we do not require it
1127 *      (i.e., "peeled" is a no-op if "fully-peeled" is set).
1128 */
1129static void read_packed_refs(FILE *f, struct ref_dir *dir)
1130{
1131        struct ref_entry *last = NULL;
1132        struct strbuf line = STRBUF_INIT;
1133        enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;
1134
1135        while (strbuf_getwholeline(&line, f, '\n') != EOF) {
1136                unsigned char sha1[20];
1137                const char *refname;
1138                const char *traits;
1139
1140                if (skip_prefix(line.buf, "# pack-refs with:", &traits)) {
1141                        if (strstr(traits, " fully-peeled "))
1142                                peeled = PEELED_FULLY;
1143                        else if (strstr(traits, " peeled "))
1144                                peeled = PEELED_TAGS;
1145                        /* perhaps other traits later as well */
1146                        continue;
1147                }
1148
1149                refname = parse_ref_line(&line, sha1);
1150                if (refname) {
1151                        int flag = REF_ISPACKED;
1152
1153                        if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1154                                hashclr(sha1);
1155                                flag |= REF_BAD_NAME | REF_ISBROKEN;
1156                        }
1157                        last = create_ref_entry(refname, sha1, flag, 0);
1158                        if (peeled == PEELED_FULLY ||
1159                            (peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))
1160                                last->flag |= REF_KNOWS_PEELED;
1161                        add_ref(dir, last);
1162                        continue;
1163                }
1164                if (last &&
1165                    line.buf[0] == '^' &&
1166                    line.len == PEELED_LINE_LENGTH &&
1167                    line.buf[PEELED_LINE_LENGTH - 1] == '\n' &&
1168                    !get_sha1_hex(line.buf + 1, sha1)) {
1169                        hashcpy(last->u.value.peeled, sha1);
1170                        /*
1171                         * Regardless of what the file header said,
1172                         * we definitely know the value of *this*
1173                         * reference:
1174                         */
1175                        last->flag |= REF_KNOWS_PEELED;
1176                }
1177        }
1178
1179        strbuf_release(&line);
1180}
1181
1182/*
1183 * Get the packed_ref_cache for the specified ref_cache, creating it
1184 * if necessary.
1185 */
1186static struct packed_ref_cache *get_packed_ref_cache(struct ref_cache *refs)
1187{
1188        const char *packed_refs_file;
1189
1190        if (*refs->name)
1191                packed_refs_file = git_path_submodule(refs->name, "packed-refs");
1192        else
1193                packed_refs_file = git_path("packed-refs");
1194
1195        if (refs->packed &&
1196            !stat_validity_check(&refs->packed->validity, packed_refs_file))
1197                clear_packed_ref_cache(refs);
1198
1199        if (!refs->packed) {
1200                FILE *f;
1201
1202                refs->packed = xcalloc(1, sizeof(*refs->packed));
1203                acquire_packed_ref_cache(refs->packed);
1204                refs->packed->root = create_dir_entry(refs, "", 0, 0);
1205                f = fopen(packed_refs_file, "r");
1206                if (f) {
1207                        stat_validity_update(&refs->packed->validity, fileno(f));
1208                        read_packed_refs(f, get_ref_dir(refs->packed->root));
1209                        fclose(f);
1210                }
1211        }
1212        return refs->packed;
1213}
1214
1215static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)
1216{
1217        return get_ref_dir(packed_ref_cache->root);
1218}
1219
1220static struct ref_dir *get_packed_refs(struct ref_cache *refs)
1221{
1222        return get_packed_ref_dir(get_packed_ref_cache(refs));
1223}
1224
1225void add_packed_ref(const char *refname, const unsigned char *sha1)
1226{
1227        struct packed_ref_cache *packed_ref_cache =
1228                get_packed_ref_cache(&ref_cache);
1229
1230        if (!packed_ref_cache->lock)
1231                die("internal error: packed refs not locked");
1232        add_ref(get_packed_ref_dir(packed_ref_cache),
1233                create_ref_entry(refname, sha1, REF_ISPACKED, 1));
1234}
1235
1236/*
1237 * Read the loose references from the namespace dirname into dir
1238 * (without recursing).  dirname must end with '/'.  dir must be the
1239 * directory entry corresponding to dirname.
1240 */
1241static void read_loose_refs(const char *dirname, struct ref_dir *dir)
1242{
1243        struct ref_cache *refs = dir->ref_cache;
1244        DIR *d;
1245        const char *path;
1246        struct dirent *de;
1247        int dirnamelen = strlen(dirname);
1248        struct strbuf refname;
1249
1250        if (*refs->name)
1251                path = git_path_submodule(refs->name, "%s", dirname);
1252        else
1253                path = git_path("%s", dirname);
1254
1255        d = opendir(path);
1256        if (!d)
1257                return;
1258
1259        strbuf_init(&refname, dirnamelen + 257);
1260        strbuf_add(&refname, dirname, dirnamelen);
1261
1262        while ((de = readdir(d)) != NULL) {
1263                unsigned char sha1[20];
1264                struct stat st;
1265                int flag;
1266                const char *refdir;
1267
1268                if (de->d_name[0] == '.')
1269                        continue;
1270                if (ends_with(de->d_name, ".lock"))
1271                        continue;
1272                strbuf_addstr(&refname, de->d_name);
1273                refdir = *refs->name
1274                        ? git_path_submodule(refs->name, "%s", refname.buf)
1275                        : git_path("%s", refname.buf);
1276                if (stat(refdir, &st) < 0) {
1277                        ; /* silently ignore */
1278                } else if (S_ISDIR(st.st_mode)) {
1279                        strbuf_addch(&refname, '/');
1280                        add_entry_to_dir(dir,
1281                                         create_dir_entry(refs, refname.buf,
1282                                                          refname.len, 1));
1283                } else {
1284                        if (*refs->name) {
1285                                hashclr(sha1);
1286                                flag = 0;
1287                                if (resolve_gitlink_ref(refs->name, refname.buf, sha1) < 0) {
1288                                        hashclr(sha1);
1289                                        flag |= REF_ISBROKEN;
1290                                }
1291                        } else if (read_ref_full(refname.buf,
1292                                                 RESOLVE_REF_READING,
1293                                                 sha1, &flag)) {
1294                                hashclr(sha1);
1295                                flag |= REF_ISBROKEN;
1296                        }
1297                        if (check_refname_format(refname.buf,
1298                                                 REFNAME_ALLOW_ONELEVEL)) {
1299                                hashclr(sha1);
1300                                flag |= REF_BAD_NAME | REF_ISBROKEN;
1301                        }
1302                        add_entry_to_dir(dir,
1303                                         create_ref_entry(refname.buf, sha1, flag, 0));
1304                }
1305                strbuf_setlen(&refname, dirnamelen);
1306        }
1307        strbuf_release(&refname);
1308        closedir(d);
1309}
1310
1311static struct ref_dir *get_loose_refs(struct ref_cache *refs)
1312{
1313        if (!refs->loose) {
1314                /*
1315                 * Mark the top-level directory complete because we
1316                 * are about to read the only subdirectory that can
1317                 * hold references:
1318                 */
1319                refs->loose = create_dir_entry(refs, "", 0, 0);
1320                /*
1321                 * Create an incomplete entry for "refs/":
1322                 */
1323                add_entry_to_dir(get_ref_dir(refs->loose),
1324                                 create_dir_entry(refs, "refs/", 5, 1));
1325        }
1326        return get_ref_dir(refs->loose);
1327}
1328
1329/* We allow "recursive" symbolic refs. Only within reason, though */
1330#define MAXDEPTH 5
1331#define MAXREFLEN (1024)
1332
1333/*
1334 * Called by resolve_gitlink_ref_recursive() after it failed to read
1335 * from the loose refs in ref_cache refs. Find <refname> in the
1336 * packed-refs file for the submodule.
1337 */
1338static int resolve_gitlink_packed_ref(struct ref_cache *refs,
1339                                      const char *refname, unsigned char *sha1)
1340{
1341        struct ref_entry *ref;
1342        struct ref_dir *dir = get_packed_refs(refs);
1343
1344        ref = find_ref(dir, refname);
1345        if (ref == NULL)
1346                return -1;
1347
1348        hashcpy(sha1, ref->u.value.sha1);
1349        return 0;
1350}
1351
1352static int resolve_gitlink_ref_recursive(struct ref_cache *refs,
1353                                         const char *refname, unsigned char *sha1,
1354                                         int recursion)
1355{
1356        int fd, len;
1357        char buffer[128], *p;
1358        char *path;
1359
1360        if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)
1361                return -1;
1362        path = *refs->name
1363                ? git_path_submodule(refs->name, "%s", refname)
1364                : git_path("%s", refname);
1365        fd = open(path, O_RDONLY);
1366        if (fd < 0)
1367                return resolve_gitlink_packed_ref(refs, refname, sha1);
1368
1369        len = read(fd, buffer, sizeof(buffer)-1);
1370        close(fd);
1371        if (len < 0)
1372                return -1;
1373        while (len && isspace(buffer[len-1]))
1374                len--;
1375        buffer[len] = 0;
1376
1377        /* Was it a detached head or an old-fashioned symlink? */
1378        if (!get_sha1_hex(buffer, sha1))
1379                return 0;
1380
1381        /* Symref? */
1382        if (strncmp(buffer, "ref:", 4))
1383                return -1;
1384        p = buffer + 4;
1385        while (isspace(*p))
1386                p++;
1387
1388        return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);
1389}
1390
1391int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)
1392{
1393        int len = strlen(path), retval;
1394        char *submodule;
1395        struct ref_cache *refs;
1396
1397        while (len && path[len-1] == '/')
1398                len--;
1399        if (!len)
1400                return -1;
1401        submodule = xstrndup(path, len);
1402        refs = get_ref_cache(submodule);
1403        free(submodule);
1404
1405        retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);
1406        return retval;
1407}
1408
1409/*
1410 * Return the ref_entry for the given refname from the packed
1411 * references.  If it does not exist, return NULL.
1412 */
1413static struct ref_entry *get_packed_ref(const char *refname)
1414{
1415        return find_ref(get_packed_refs(&ref_cache), refname);
1416}
1417
1418/*
1419 * A loose ref file doesn't exist; check for a packed ref.  The
1420 * options are forwarded from resolve_safe_unsafe().
1421 */
1422static int resolve_missing_loose_ref(const char *refname,
1423                                     int resolve_flags,
1424                                     unsigned char *sha1,
1425                                     int *flags)
1426{
1427        struct ref_entry *entry;
1428
1429        /*
1430         * The loose reference file does not exist; check for a packed
1431         * reference.
1432         */
1433        entry = get_packed_ref(refname);
1434        if (entry) {
1435                hashcpy(sha1, entry->u.value.sha1);
1436                if (flags)
1437                        *flags |= REF_ISPACKED;
1438                return 0;
1439        }
1440        /* The reference is not a packed reference, either. */
1441        if (resolve_flags & RESOLVE_REF_READING) {
1442                errno = ENOENT;
1443                return -1;
1444        } else {
1445                hashclr(sha1);
1446                return 0;
1447        }
1448}
1449
1450/* This function needs to return a meaningful errno on failure */
1451const char *resolve_ref_unsafe(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
1452{
1453        int depth = MAXDEPTH;
1454        ssize_t len;
1455        char buffer[256];
1456        static char refname_buffer[256];
1457        int bad_name = 0;
1458
1459        if (flags)
1460                *flags = 0;
1461
1462        if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
1463                if (flags)
1464                        *flags |= REF_BAD_NAME;
1465
1466                if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1467                    !refname_is_safe(refname)) {
1468                        errno = EINVAL;
1469                        return NULL;
1470                }
1471                /*
1472                 * dwim_ref() uses REF_ISBROKEN to distinguish between
1473                 * missing refs and refs that were present but invalid,
1474                 * to complain about the latter to stderr.
1475                 *
1476                 * We don't know whether the ref exists, so don't set
1477                 * REF_ISBROKEN yet.
1478                 */
1479                bad_name = 1;
1480        }
1481        for (;;) {
1482                char path[PATH_MAX];
1483                struct stat st;
1484                char *buf;
1485                int fd;
1486
1487                if (--depth < 0) {
1488                        errno = ELOOP;
1489                        return NULL;
1490                }
1491
1492                git_snpath(path, sizeof(path), "%s", refname);
1493
1494                /*
1495                 * We might have to loop back here to avoid a race
1496                 * condition: first we lstat() the file, then we try
1497                 * to read it as a link or as a file.  But if somebody
1498                 * changes the type of the file (file <-> directory
1499                 * <-> symlink) between the lstat() and reading, then
1500                 * we don't want to report that as an error but rather
1501                 * try again starting with the lstat().
1502                 */
1503        stat_ref:
1504                if (lstat(path, &st) < 0) {
1505                        if (errno != ENOENT)
1506                                return NULL;
1507                        if (resolve_missing_loose_ref(refname, resolve_flags,
1508                                                      sha1, flags))
1509                                return NULL;
1510                        if (bad_name) {
1511                                hashclr(sha1);
1512                                if (flags)
1513                                        *flags |= REF_ISBROKEN;
1514                        }
1515                        return refname;
1516                }
1517
1518                /* Follow "normalized" - ie "refs/.." symlinks by hand */
1519                if (S_ISLNK(st.st_mode)) {
1520                        len = readlink(path, buffer, sizeof(buffer)-1);
1521                        if (len < 0) {
1522                                if (errno == ENOENT || errno == EINVAL)
1523                                        /* inconsistent with lstat; retry */
1524                                        goto stat_ref;
1525                                else
1526                                        return NULL;
1527                        }
1528                        buffer[len] = 0;
1529                        if (starts_with(buffer, "refs/") &&
1530                                        !check_refname_format(buffer, 0)) {
1531                                strcpy(refname_buffer, buffer);
1532                                refname = refname_buffer;
1533                                if (flags)
1534                                        *flags |= REF_ISSYMREF;
1535                                if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1536                                        hashclr(sha1);
1537                                        return refname;
1538                                }
1539                                continue;
1540                        }
1541                }
1542
1543                /* Is it a directory? */
1544                if (S_ISDIR(st.st_mode)) {
1545                        errno = EISDIR;
1546                        return NULL;
1547                }
1548
1549                /*
1550                 * Anything else, just open it and try to use it as
1551                 * a ref
1552                 */
1553                fd = open(path, O_RDONLY);
1554                if (fd < 0) {
1555                        if (errno == ENOENT)
1556                                /* inconsistent with lstat; retry */
1557                                goto stat_ref;
1558                        else
1559                                return NULL;
1560                }
1561                len = read_in_full(fd, buffer, sizeof(buffer)-1);
1562                if (len < 0) {
1563                        int save_errno = errno;
1564                        close(fd);
1565                        errno = save_errno;
1566                        return NULL;
1567                }
1568                close(fd);
1569                while (len && isspace(buffer[len-1]))
1570                        len--;
1571                buffer[len] = '\0';
1572
1573                /*
1574                 * Is it a symbolic ref?
1575                 */
1576                if (!starts_with(buffer, "ref:")) {
1577                        /*
1578                         * Please note that FETCH_HEAD has a second
1579                         * line containing other data.
1580                         */
1581                        if (get_sha1_hex(buffer, sha1) ||
1582                            (buffer[40] != '\0' && !isspace(buffer[40]))) {
1583                                if (flags)
1584                                        *flags |= REF_ISBROKEN;
1585                                errno = EINVAL;
1586                                return NULL;
1587                        }
1588                        if (bad_name) {
1589                                hashclr(sha1);
1590                                if (flags)
1591                                        *flags |= REF_ISBROKEN;
1592                        }
1593                        return refname;
1594                }
1595                if (flags)
1596                        *flags |= REF_ISSYMREF;
1597                buf = buffer + 4;
1598                while (isspace(*buf))
1599                        buf++;
1600                refname = strcpy(refname_buffer, buf);
1601                if (resolve_flags & RESOLVE_REF_NO_RECURSE) {
1602                        hashclr(sha1);
1603                        return refname;
1604                }
1605                if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {
1606                        if (flags)
1607                                *flags |= REF_ISBROKEN;
1608
1609                        if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||
1610                            !refname_is_safe(buf)) {
1611                                errno = EINVAL;
1612                                return NULL;
1613                        }
1614                        bad_name = 1;
1615                }
1616        }
1617}
1618
1619char *resolve_refdup(const char *ref, int resolve_flags, unsigned char *sha1, int *flags)
1620{
1621        return xstrdup_or_null(resolve_ref_unsafe(ref, resolve_flags, sha1, flags));
1622}
1623
1624/* The argument to filter_refs */
1625struct ref_filter {
1626        const char *pattern;
1627        each_ref_fn *fn;
1628        void *cb_data;
1629};
1630
1631int read_ref_full(const char *refname, int resolve_flags, unsigned char *sha1, int *flags)
1632{
1633        if (resolve_ref_unsafe(refname, resolve_flags, sha1, flags))
1634                return 0;
1635        return -1;
1636}
1637
1638int read_ref(const char *refname, unsigned char *sha1)
1639{
1640        return read_ref_full(refname, RESOLVE_REF_READING, sha1, NULL);
1641}
1642
1643int ref_exists(const char *refname)
1644{
1645        unsigned char sha1[20];
1646        return !!resolve_ref_unsafe(refname, RESOLVE_REF_READING, sha1, NULL);
1647}
1648
1649static int filter_refs(const char *refname, const unsigned char *sha1, int flags,
1650                       void *data)
1651{
1652        struct ref_filter *filter = (struct ref_filter *)data;
1653        if (wildmatch(filter->pattern, refname, 0, NULL))
1654                return 0;
1655        return filter->fn(refname, sha1, flags, filter->cb_data);
1656}
1657
1658enum peel_status {
1659        /* object was peeled successfully: */
1660        PEEL_PEELED = 0,
1661
1662        /*
1663         * object cannot be peeled because the named object (or an
1664         * object referred to by a tag in the peel chain), does not
1665         * exist.
1666         */
1667        PEEL_INVALID = -1,
1668
1669        /* object cannot be peeled because it is not a tag: */
1670        PEEL_NON_TAG = -2,
1671
1672        /* ref_entry contains no peeled value because it is a symref: */
1673        PEEL_IS_SYMREF = -3,
1674
1675        /*
1676         * ref_entry cannot be peeled because it is broken (i.e., the
1677         * symbolic reference cannot even be resolved to an object
1678         * name):
1679         */
1680        PEEL_BROKEN = -4
1681};
1682
1683/*
1684 * Peel the named object; i.e., if the object is a tag, resolve the
1685 * tag recursively until a non-tag is found.  If successful, store the
1686 * result to sha1 and return PEEL_PEELED.  If the object is not a tag
1687 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,
1688 * and leave sha1 unchanged.
1689 */
1690static enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)
1691{
1692        struct object *o = lookup_unknown_object(name);
1693
1694        if (o->type == OBJ_NONE) {
1695                int type = sha1_object_info(name, NULL);
1696                if (type < 0 || !object_as_type(o, type, 0))
1697                        return PEEL_INVALID;
1698        }
1699
1700        if (o->type != OBJ_TAG)
1701                return PEEL_NON_TAG;
1702
1703        o = deref_tag_noverify(o);
1704        if (!o)
1705                return PEEL_INVALID;
1706
1707        hashcpy(sha1, o->sha1);
1708        return PEEL_PEELED;
1709}
1710
1711/*
1712 * Peel the entry (if possible) and return its new peel_status.  If
1713 * repeel is true, re-peel the entry even if there is an old peeled
1714 * value that is already stored in it.
1715 *
1716 * It is OK to call this function with a packed reference entry that
1717 * might be stale and might even refer to an object that has since
1718 * been garbage-collected.  In such a case, if the entry has
1719 * REF_KNOWS_PEELED then leave the status unchanged and return
1720 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.
1721 */
1722static enum peel_status peel_entry(struct ref_entry *entry, int repeel)
1723{
1724        enum peel_status status;
1725
1726        if (entry->flag & REF_KNOWS_PEELED) {
1727                if (repeel) {
1728                        entry->flag &= ~REF_KNOWS_PEELED;
1729                        hashclr(entry->u.value.peeled);
1730                } else {
1731                        return is_null_sha1(entry->u.value.peeled) ?
1732                                PEEL_NON_TAG : PEEL_PEELED;
1733                }
1734        }
1735        if (entry->flag & REF_ISBROKEN)
1736                return PEEL_BROKEN;
1737        if (entry->flag & REF_ISSYMREF)
1738                return PEEL_IS_SYMREF;
1739
1740        status = peel_object(entry->u.value.sha1, entry->u.value.peeled);
1741        if (status == PEEL_PEELED || status == PEEL_NON_TAG)
1742                entry->flag |= REF_KNOWS_PEELED;
1743        return status;
1744}
1745
1746int peel_ref(const char *refname, unsigned char *sha1)
1747{
1748        int flag;
1749        unsigned char base[20];
1750
1751        if (current_ref && (current_ref->name == refname
1752                            || !strcmp(current_ref->name, refname))) {
1753                if (peel_entry(current_ref, 0))
1754                        return -1;
1755                hashcpy(sha1, current_ref->u.value.peeled);
1756                return 0;
1757        }
1758
1759        if (read_ref_full(refname, RESOLVE_REF_READING, base, &flag))
1760                return -1;
1761
1762        /*
1763         * If the reference is packed, read its ref_entry from the
1764         * cache in the hope that we already know its peeled value.
1765         * We only try this optimization on packed references because
1766         * (a) forcing the filling of the loose reference cache could
1767         * be expensive and (b) loose references anyway usually do not
1768         * have REF_KNOWS_PEELED.
1769         */
1770        if (flag & REF_ISPACKED) {
1771                struct ref_entry *r = get_packed_ref(refname);
1772                if (r) {
1773                        if (peel_entry(r, 0))
1774                                return -1;
1775                        hashcpy(sha1, r->u.value.peeled);
1776                        return 0;
1777                }
1778        }
1779
1780        return peel_object(base, sha1);
1781}
1782
1783struct warn_if_dangling_data {
1784        FILE *fp;
1785        const char *refname;
1786        const struct string_list *refnames;
1787        const char *msg_fmt;
1788};
1789
1790static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,
1791                                   int flags, void *cb_data)
1792{
1793        struct warn_if_dangling_data *d = cb_data;
1794        const char *resolves_to;
1795        unsigned char junk[20];
1796
1797        if (!(flags & REF_ISSYMREF))
1798                return 0;
1799
1800        resolves_to = resolve_ref_unsafe(refname, 0, junk, NULL);
1801        if (!resolves_to
1802            || (d->refname
1803                ? strcmp(resolves_to, d->refname)
1804                : !string_list_has_string(d->refnames, resolves_to))) {
1805                return 0;
1806        }
1807
1808        fprintf(d->fp, d->msg_fmt, refname);
1809        fputc('\n', d->fp);
1810        return 0;
1811}
1812
1813void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)
1814{
1815        struct warn_if_dangling_data data;
1816
1817        data.fp = fp;
1818        data.refname = refname;
1819        data.refnames = NULL;
1820        data.msg_fmt = msg_fmt;
1821        for_each_rawref(warn_if_dangling_symref, &data);
1822}
1823
1824void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)
1825{
1826        struct warn_if_dangling_data data;
1827
1828        data.fp = fp;
1829        data.refname = NULL;
1830        data.refnames = refnames;
1831        data.msg_fmt = msg_fmt;
1832        for_each_rawref(warn_if_dangling_symref, &data);
1833}
1834
1835/*
1836 * Call fn for each reference in the specified ref_cache, omitting
1837 * references not in the containing_dir of base.  fn is called for all
1838 * references, including broken ones.  If fn ever returns a non-zero
1839 * value, stop the iteration and return that value; otherwise, return
1840 * 0.
1841 */
1842static int do_for_each_entry(struct ref_cache *refs, const char *base,
1843                             each_ref_entry_fn fn, void *cb_data)
1844{
1845        struct packed_ref_cache *packed_ref_cache;
1846        struct ref_dir *loose_dir;
1847        struct ref_dir *packed_dir;
1848        int retval = 0;
1849
1850        /*
1851         * We must make sure that all loose refs are read before accessing the
1852         * packed-refs file; this avoids a race condition in which loose refs
1853         * are migrated to the packed-refs file by a simultaneous process, but
1854         * our in-memory view is from before the migration. get_packed_ref_cache()
1855         * takes care of making sure our view is up to date with what is on
1856         * disk.
1857         */
1858        loose_dir = get_loose_refs(refs);
1859        if (base && *base) {
1860                loose_dir = find_containing_dir(loose_dir, base, 0);
1861        }
1862        if (loose_dir)
1863                prime_ref_dir(loose_dir);
1864
1865        packed_ref_cache = get_packed_ref_cache(refs);
1866        acquire_packed_ref_cache(packed_ref_cache);
1867        packed_dir = get_packed_ref_dir(packed_ref_cache);
1868        if (base && *base) {
1869                packed_dir = find_containing_dir(packed_dir, base, 0);
1870        }
1871
1872        if (packed_dir && loose_dir) {
1873                sort_ref_dir(packed_dir);
1874                sort_ref_dir(loose_dir);
1875                retval = do_for_each_entry_in_dirs(
1876                                packed_dir, loose_dir, fn, cb_data);
1877        } else if (packed_dir) {
1878                sort_ref_dir(packed_dir);
1879                retval = do_for_each_entry_in_dir(
1880                                packed_dir, 0, fn, cb_data);
1881        } else if (loose_dir) {
1882                sort_ref_dir(loose_dir);
1883                retval = do_for_each_entry_in_dir(
1884                                loose_dir, 0, fn, cb_data);
1885        }
1886
1887        release_packed_ref_cache(packed_ref_cache);
1888        return retval;
1889}
1890
1891/*
1892 * Call fn for each reference in the specified ref_cache for which the
1893 * refname begins with base.  If trim is non-zero, then trim that many
1894 * characters off the beginning of each refname before passing the
1895 * refname to fn.  flags can be DO_FOR_EACH_INCLUDE_BROKEN to include
1896 * broken references in the iteration.  If fn ever returns a non-zero
1897 * value, stop the iteration and return that value; otherwise, return
1898 * 0.
1899 */
1900static int do_for_each_ref(struct ref_cache *refs, const char *base,
1901                           each_ref_fn fn, int trim, int flags, void *cb_data)
1902{
1903        struct ref_entry_cb data;
1904        data.base = base;
1905        data.trim = trim;
1906        data.flags = flags;
1907        data.fn = fn;
1908        data.cb_data = cb_data;
1909
1910        return do_for_each_entry(refs, base, do_one_ref, &data);
1911}
1912
1913static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)
1914{
1915        unsigned char sha1[20];
1916        int flag;
1917
1918        if (submodule) {
1919                if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)
1920                        return fn("HEAD", sha1, 0, cb_data);
1921
1922                return 0;
1923        }
1924
1925        if (!read_ref_full("HEAD", RESOLVE_REF_READING, sha1, &flag))
1926                return fn("HEAD", sha1, flag, cb_data);
1927
1928        return 0;
1929}
1930
1931int head_ref(each_ref_fn fn, void *cb_data)
1932{
1933        return do_head_ref(NULL, fn, cb_data);
1934}
1935
1936int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1937{
1938        return do_head_ref(submodule, fn, cb_data);
1939}
1940
1941int for_each_ref(each_ref_fn fn, void *cb_data)
1942{
1943        return do_for_each_ref(&ref_cache, "", fn, 0, 0, cb_data);
1944}
1945
1946int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1947{
1948        return do_for_each_ref(get_ref_cache(submodule), "", fn, 0, 0, cb_data);
1949}
1950
1951int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)
1952{
1953        return do_for_each_ref(&ref_cache, prefix, fn, strlen(prefix), 0, cb_data);
1954}
1955
1956int for_each_ref_in_submodule(const char *submodule, const char *prefix,
1957                each_ref_fn fn, void *cb_data)
1958{
1959        return do_for_each_ref(get_ref_cache(submodule), prefix, fn, strlen(prefix), 0, cb_data);
1960}
1961
1962int for_each_tag_ref(each_ref_fn fn, void *cb_data)
1963{
1964        return for_each_ref_in("refs/tags/", fn, cb_data);
1965}
1966
1967int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1968{
1969        return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);
1970}
1971
1972int for_each_branch_ref(each_ref_fn fn, void *cb_data)
1973{
1974        return for_each_ref_in("refs/heads/", fn, cb_data);
1975}
1976
1977int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1978{
1979        return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);
1980}
1981
1982int for_each_remote_ref(each_ref_fn fn, void *cb_data)
1983{
1984        return for_each_ref_in("refs/remotes/", fn, cb_data);
1985}
1986
1987int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)
1988{
1989        return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);
1990}
1991
1992int for_each_replace_ref(each_ref_fn fn, void *cb_data)
1993{
1994        return do_for_each_ref(&ref_cache, "refs/replace/", fn, 13, 0, cb_data);
1995}
1996
1997int head_ref_namespaced(each_ref_fn fn, void *cb_data)
1998{
1999        struct strbuf buf = STRBUF_INIT;
2000        int ret = 0;
2001        unsigned char sha1[20];
2002        int flag;
2003
2004        strbuf_addf(&buf, "%sHEAD", get_git_namespace());
2005        if (!read_ref_full(buf.buf, RESOLVE_REF_READING, sha1, &flag))
2006                ret = fn(buf.buf, sha1, flag, cb_data);
2007        strbuf_release(&buf);
2008
2009        return ret;
2010}
2011
2012int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)
2013{
2014        struct strbuf buf = STRBUF_INIT;
2015        int ret;
2016        strbuf_addf(&buf, "%srefs/", get_git_namespace());
2017        ret = do_for_each_ref(&ref_cache, buf.buf, fn, 0, 0, cb_data);
2018        strbuf_release(&buf);
2019        return ret;
2020}
2021
2022int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,
2023        const char *prefix, void *cb_data)
2024{
2025        struct strbuf real_pattern = STRBUF_INIT;
2026        struct ref_filter filter;
2027        int ret;
2028
2029        if (!prefix && !starts_with(pattern, "refs/"))
2030                strbuf_addstr(&real_pattern, "refs/");
2031        else if (prefix)
2032                strbuf_addstr(&real_pattern, prefix);
2033        strbuf_addstr(&real_pattern, pattern);
2034
2035        if (!has_glob_specials(pattern)) {
2036                /* Append implied '/' '*' if not present. */
2037                if (real_pattern.buf[real_pattern.len - 1] != '/')
2038                        strbuf_addch(&real_pattern, '/');
2039                /* No need to check for '*', there is none. */
2040                strbuf_addch(&real_pattern, '*');
2041        }
2042
2043        filter.pattern = real_pattern.buf;
2044        filter.fn = fn;
2045        filter.cb_data = cb_data;
2046        ret = for_each_ref(filter_refs, &filter);
2047
2048        strbuf_release(&real_pattern);
2049        return ret;
2050}
2051
2052int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)
2053{
2054        return for_each_glob_ref_in(fn, pattern, NULL, cb_data);
2055}
2056
2057int for_each_rawref(each_ref_fn fn, void *cb_data)
2058{
2059        return do_for_each_ref(&ref_cache, "", fn, 0,
2060                               DO_FOR_EACH_INCLUDE_BROKEN, cb_data);
2061}
2062
2063const char *prettify_refname(const char *name)
2064{
2065        return name + (
2066                starts_with(name, "refs/heads/") ? 11 :
2067                starts_with(name, "refs/tags/") ? 10 :
2068                starts_with(name, "refs/remotes/") ? 13 :
2069                0);
2070}
2071
2072static const char *ref_rev_parse_rules[] = {
2073        "%.*s",
2074        "refs/%.*s",
2075        "refs/tags/%.*s",
2076        "refs/heads/%.*s",
2077        "refs/remotes/%.*s",
2078        "refs/remotes/%.*s/HEAD",
2079        NULL
2080};
2081
2082int refname_match(const char *abbrev_name, const char *full_name)
2083{
2084        const char **p;
2085        const int abbrev_name_len = strlen(abbrev_name);
2086
2087        for (p = ref_rev_parse_rules; *p; p++) {
2088                if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {
2089                        return 1;
2090                }
2091        }
2092
2093        return 0;
2094}
2095
2096/* This function should make sure errno is meaningful on error */
2097static struct ref_lock *verify_lock(struct ref_lock *lock,
2098        const unsigned char *old_sha1, int mustexist)
2099{
2100        if (read_ref_full(lock->ref_name,
2101                          mustexist ? RESOLVE_REF_READING : 0,
2102                          lock->old_sha1, NULL)) {
2103                int save_errno = errno;
2104                error("Can't verify ref %s", lock->ref_name);
2105                unlock_ref(lock);
2106                errno = save_errno;
2107                return NULL;
2108        }
2109        if (hashcmp(lock->old_sha1, old_sha1)) {
2110                error("Ref %s is at %s but expected %s", lock->ref_name,
2111                        sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));
2112                unlock_ref(lock);
2113                errno = EBUSY;
2114                return NULL;
2115        }
2116        return lock;
2117}
2118
2119static int remove_empty_directories(const char *file)
2120{
2121        /* we want to create a file but there is a directory there;
2122         * if that is an empty directory (or a directory that contains
2123         * only empty directories), remove them.
2124         */
2125        struct strbuf path;
2126        int result, save_errno;
2127
2128        strbuf_init(&path, 20);
2129        strbuf_addstr(&path, file);
2130
2131        result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);
2132        save_errno = errno;
2133
2134        strbuf_release(&path);
2135        errno = save_errno;
2136
2137        return result;
2138}
2139
2140/*
2141 * *string and *len will only be substituted, and *string returned (for
2142 * later free()ing) if the string passed in is a magic short-hand form
2143 * to name a branch.
2144 */
2145static char *substitute_branch_name(const char **string, int *len)
2146{
2147        struct strbuf buf = STRBUF_INIT;
2148        int ret = interpret_branch_name(*string, *len, &buf);
2149
2150        if (ret == *len) {
2151                size_t size;
2152                *string = strbuf_detach(&buf, &size);
2153                *len = size;
2154                return (char *)*string;
2155        }
2156
2157        return NULL;
2158}
2159
2160int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)
2161{
2162        char *last_branch = substitute_branch_name(&str, &len);
2163        const char **p, *r;
2164        int refs_found = 0;
2165
2166        *ref = NULL;
2167        for (p = ref_rev_parse_rules; *p; p++) {
2168                char fullref[PATH_MAX];
2169                unsigned char sha1_from_ref[20];
2170                unsigned char *this_result;
2171                int flag;
2172
2173                this_result = refs_found ? sha1_from_ref : sha1;
2174                mksnpath(fullref, sizeof(fullref), *p, len, str);
2175                r = resolve_ref_unsafe(fullref, RESOLVE_REF_READING,
2176                                       this_result, &flag);
2177                if (r) {
2178                        if (!refs_found++)
2179                                *ref = xstrdup(r);
2180                        if (!warn_ambiguous_refs)
2181                                break;
2182                } else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {
2183                        warning("ignoring dangling symref %s.", fullref);
2184                } else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {
2185                        warning("ignoring broken ref %s.", fullref);
2186                }
2187        }
2188        free(last_branch);
2189        return refs_found;
2190}
2191
2192int dwim_log(const char *str, int len, unsigned char *sha1, char **log)
2193{
2194        char *last_branch = substitute_branch_name(&str, &len);
2195        const char **p;
2196        int logs_found = 0;
2197
2198        *log = NULL;
2199        for (p = ref_rev_parse_rules; *p; p++) {
2200                unsigned char hash[20];
2201                char path[PATH_MAX];
2202                const char *ref, *it;
2203
2204                mksnpath(path, sizeof(path), *p, len, str);
2205                ref = resolve_ref_unsafe(path, RESOLVE_REF_READING,
2206                                         hash, NULL);
2207                if (!ref)
2208                        continue;
2209                if (reflog_exists(path))
2210                        it = path;
2211                else if (strcmp(ref, path) && reflog_exists(ref))
2212                        it = ref;
2213                else
2214                        continue;
2215                if (!logs_found++) {
2216                        *log = xstrdup(it);
2217                        hashcpy(sha1, hash);
2218                }
2219                if (!warn_ambiguous_refs)
2220                        break;
2221        }
2222        free(last_branch);
2223        return logs_found;
2224}
2225
2226/*
2227 * Locks a ref returning the lock on success and NULL on failure.
2228 * On failure errno is set to something meaningful.
2229 */
2230static struct ref_lock *lock_ref_sha1_basic(const char *refname,
2231                                            const unsigned char *old_sha1,
2232                                            const struct string_list *skip,
2233                                            int flags, int *type_p)
2234{
2235        char *ref_file;
2236        const char *orig_refname = refname;
2237        struct ref_lock *lock;
2238        int last_errno = 0;
2239        int type, lflags;
2240        int mustexist = (old_sha1 && !is_null_sha1(old_sha1));
2241        int resolve_flags = 0;
2242        int missing = 0;
2243        int attempts_remaining = 3;
2244
2245        lock = xcalloc(1, sizeof(struct ref_lock));
2246        lock->lock_fd = -1;
2247
2248        if (mustexist)
2249                resolve_flags |= RESOLVE_REF_READING;
2250        if (flags & REF_DELETING) {
2251                resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME;
2252                if (flags & REF_NODEREF)
2253                        resolve_flags |= RESOLVE_REF_NO_RECURSE;
2254        }
2255
2256        refname = resolve_ref_unsafe(refname, resolve_flags,
2257                                     lock->old_sha1, &type);
2258        if (!refname && errno == EISDIR) {
2259                /* we are trying to lock foo but we used to
2260                 * have foo/bar which now does not exist;
2261                 * it is normal for the empty directory 'foo'
2262                 * to remain.
2263                 */
2264                ref_file = git_path("%s", orig_refname);
2265                if (remove_empty_directories(ref_file)) {
2266                        last_errno = errno;
2267                        error("there are still refs under '%s'", orig_refname);
2268                        goto error_return;
2269                }
2270                refname = resolve_ref_unsafe(orig_refname, resolve_flags,
2271                                             lock->old_sha1, &type);
2272        }
2273        if (type_p)
2274            *type_p = type;
2275        if (!refname) {
2276                last_errno = errno;
2277                error("unable to resolve reference %s: %s",
2278                        orig_refname, strerror(errno));
2279                goto error_return;
2280        }
2281        missing = is_null_sha1(lock->old_sha1);
2282        /* When the ref did not exist and we are creating it,
2283         * make sure there is no existing ref that is packed
2284         * whose name begins with our refname, nor a ref whose
2285         * name is a proper prefix of our refname.
2286         */
2287        if (missing &&
2288             !is_refname_available(refname, skip, get_packed_refs(&ref_cache))) {
2289                last_errno = ENOTDIR;
2290                goto error_return;
2291        }
2292
2293        lock->lk = xcalloc(1, sizeof(struct lock_file));
2294
2295        lflags = 0;
2296        if (flags & REF_NODEREF) {
2297                refname = orig_refname;
2298                lflags |= LOCK_NO_DEREF;
2299        }
2300        lock->ref_name = xstrdup(refname);
2301        lock->orig_ref_name = xstrdup(orig_refname);
2302        ref_file = git_path("%s", refname);
2303        if (missing)
2304                lock->force_write = 1;
2305        if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))
2306                lock->force_write = 1;
2307
2308 retry:
2309        switch (safe_create_leading_directories(ref_file)) {
2310        case SCLD_OK:
2311                break; /* success */
2312        case SCLD_VANISHED:
2313                if (--attempts_remaining > 0)
2314                        goto retry;
2315                /* fall through */
2316        default:
2317                last_errno = errno;
2318                error("unable to create directory for %s", ref_file);
2319                goto error_return;
2320        }
2321
2322        lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);
2323        if (lock->lock_fd < 0) {
2324                last_errno = errno;
2325                if (errno == ENOENT && --attempts_remaining > 0)
2326                        /*
2327                         * Maybe somebody just deleted one of the
2328                         * directories leading to ref_file.  Try
2329                         * again:
2330                         */
2331                        goto retry;
2332                else {
2333                        struct strbuf err = STRBUF_INIT;
2334                        unable_to_lock_message(ref_file, errno, &err);
2335                        error("%s", err.buf);
2336                        strbuf_release(&err);
2337                        goto error_return;
2338                }
2339        }
2340        return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;
2341
2342 error_return:
2343        unlock_ref(lock);
2344        errno = last_errno;
2345        return NULL;
2346}
2347
2348struct ref_lock *lock_any_ref_for_update(const char *refname,
2349                                         const unsigned char *old_sha1,
2350                                         int flags, int *type_p)
2351{
2352        return lock_ref_sha1_basic(refname, old_sha1, NULL, flags, type_p);
2353}
2354
2355/*
2356 * Write an entry to the packed-refs file for the specified refname.
2357 * If peeled is non-NULL, write it as the entry's peeled value.
2358 */
2359static void write_packed_entry(FILE *fh, char *refname, unsigned char *sha1,
2360                               unsigned char *peeled)
2361{
2362        fprintf_or_die(fh, "%s %s\n", sha1_to_hex(sha1), refname);
2363        if (peeled)
2364                fprintf_or_die(fh, "^%s\n", sha1_to_hex(peeled));
2365}
2366
2367/*
2368 * An each_ref_entry_fn that writes the entry to a packed-refs file.
2369 */
2370static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)
2371{
2372        enum peel_status peel_status = peel_entry(entry, 0);
2373
2374        if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
2375                error("internal error: %s is not a valid packed reference!",
2376                      entry->name);
2377        write_packed_entry(cb_data, entry->name, entry->u.value.sha1,
2378                           peel_status == PEEL_PEELED ?
2379                           entry->u.value.peeled : NULL);
2380        return 0;
2381}
2382
2383/* This should return a meaningful errno on failure */
2384int lock_packed_refs(int flags)
2385{
2386        struct packed_ref_cache *packed_ref_cache;
2387
2388        if (hold_lock_file_for_update(&packlock, git_path("packed-refs"), flags) < 0)
2389                return -1;
2390        /*
2391         * Get the current packed-refs while holding the lock.  If the
2392         * packed-refs file has been modified since we last read it,
2393         * this will automatically invalidate the cache and re-read
2394         * the packed-refs file.
2395         */
2396        packed_ref_cache = get_packed_ref_cache(&ref_cache);
2397        packed_ref_cache->lock = &packlock;
2398        /* Increment the reference count to prevent it from being freed: */
2399        acquire_packed_ref_cache(packed_ref_cache);
2400        return 0;
2401}
2402
2403/*
2404 * Commit the packed refs changes.
2405 * On error we must make sure that errno contains a meaningful value.
2406 */
2407int commit_packed_refs(void)
2408{
2409        struct packed_ref_cache *packed_ref_cache =
2410                get_packed_ref_cache(&ref_cache);
2411        int error = 0;
2412        int save_errno = 0;
2413        FILE *out;
2414
2415        if (!packed_ref_cache->lock)
2416                die("internal error: packed-refs not locked");
2417
2418        out = fdopen_lock_file(packed_ref_cache->lock, "w");
2419        if (!out)
2420                die_errno("unable to fdopen packed-refs descriptor");
2421
2422        fprintf_or_die(out, "%s", PACKED_REFS_HEADER);
2423        do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),
2424                                 0, write_packed_entry_fn, out);
2425
2426        if (commit_lock_file(packed_ref_cache->lock)) {
2427                save_errno = errno;
2428                error = -1;
2429        }
2430        packed_ref_cache->lock = NULL;
2431        release_packed_ref_cache(packed_ref_cache);
2432        errno = save_errno;
2433        return error;
2434}
2435
2436void rollback_packed_refs(void)
2437{
2438        struct packed_ref_cache *packed_ref_cache =
2439                get_packed_ref_cache(&ref_cache);
2440
2441        if (!packed_ref_cache->lock)
2442                die("internal error: packed-refs not locked");
2443        rollback_lock_file(packed_ref_cache->lock);
2444        packed_ref_cache->lock = NULL;
2445        release_packed_ref_cache(packed_ref_cache);
2446        clear_packed_ref_cache(&ref_cache);
2447}
2448
2449struct ref_to_prune {
2450        struct ref_to_prune *next;
2451        unsigned char sha1[20];
2452        char name[FLEX_ARRAY];
2453};
2454
2455struct pack_refs_cb_data {
2456        unsigned int flags;
2457        struct ref_dir *packed_refs;
2458        struct ref_to_prune *ref_to_prune;
2459};
2460
2461/*
2462 * An each_ref_entry_fn that is run over loose references only.  If
2463 * the loose reference can be packed, add an entry in the packed ref
2464 * cache.  If the reference should be pruned, also add it to
2465 * ref_to_prune in the pack_refs_cb_data.
2466 */
2467static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)
2468{
2469        struct pack_refs_cb_data *cb = cb_data;
2470        enum peel_status peel_status;
2471        struct ref_entry *packed_entry;
2472        int is_tag_ref = starts_with(entry->name, "refs/tags/");
2473
2474        /* ALWAYS pack tags */
2475        if (!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)
2476                return 0;
2477
2478        /* Do not pack symbolic or broken refs: */
2479        if ((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))
2480                return 0;
2481
2482        /* Add a packed ref cache entry equivalent to the loose entry. */
2483        peel_status = peel_entry(entry, 1);
2484        if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)
2485                die("internal error peeling reference %s (%s)",
2486                    entry->name, sha1_to_hex(entry->u.value.sha1));
2487        packed_entry = find_ref(cb->packed_refs, entry->name);
2488        if (packed_entry) {
2489                /* Overwrite existing packed entry with info from loose entry */
2490                packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;
2491                hashcpy(packed_entry->u.value.sha1, entry->u.value.sha1);
2492        } else {
2493                packed_entry = create_ref_entry(entry->name, entry->u.value.sha1,
2494                                                REF_ISPACKED | REF_KNOWS_PEELED, 0);
2495                add_ref(cb->packed_refs, packed_entry);
2496        }
2497        hashcpy(packed_entry->u.value.peeled, entry->u.value.peeled);
2498
2499        /* Schedule the loose reference for pruning if requested. */
2500        if ((cb->flags & PACK_REFS_PRUNE)) {
2501                int namelen = strlen(entry->name) + 1;
2502                struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);
2503                hashcpy(n->sha1, entry->u.value.sha1);
2504                strcpy(n->name, entry->name);
2505                n->next = cb->ref_to_prune;
2506                cb->ref_to_prune = n;
2507        }
2508        return 0;
2509}
2510
2511/*
2512 * Remove empty parents, but spare refs/ and immediate subdirs.
2513 * Note: munges *name.
2514 */
2515static void try_remove_empty_parents(char *name)
2516{
2517        char *p, *q;
2518        int i;
2519        p = name;
2520        for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */
2521                while (*p && *p != '/')
2522                        p++;
2523                /* tolerate duplicate slashes; see check_refname_format() */
2524                while (*p == '/')
2525                        p++;
2526        }
2527        for (q = p; *q; q++)
2528                ;
2529        while (1) {
2530                while (q > p && *q != '/')
2531                        q--;
2532                while (q > p && *(q-1) == '/')
2533                        q--;
2534                if (q == p)
2535                        break;
2536                *q = '\0';
2537                if (rmdir(git_path("%s", name)))
2538                        break;
2539        }
2540}
2541
2542/* make sure nobody touched the ref, and unlink */
2543static void prune_ref(struct ref_to_prune *r)
2544{
2545        struct ref_transaction *transaction;
2546        struct strbuf err = STRBUF_INIT;
2547
2548        if (check_refname_format(r->name, 0))
2549                return;
2550
2551        transaction = ref_transaction_begin(&err);
2552        if (!transaction ||
2553            ref_transaction_delete(transaction, r->name, r->sha1,
2554                                   REF_ISPRUNING, 1, NULL, &err) ||
2555            ref_transaction_commit(transaction, &err)) {
2556                ref_transaction_free(transaction);
2557                error("%s", err.buf);
2558                strbuf_release(&err);
2559                return;
2560        }
2561        ref_transaction_free(transaction);
2562        strbuf_release(&err);
2563        try_remove_empty_parents(r->name);
2564}
2565
2566static void prune_refs(struct ref_to_prune *r)
2567{
2568        while (r) {
2569                prune_ref(r);
2570                r = r->next;
2571        }
2572}
2573
2574int pack_refs(unsigned int flags)
2575{
2576        struct pack_refs_cb_data cbdata;
2577
2578        memset(&cbdata, 0, sizeof(cbdata));
2579        cbdata.flags = flags;
2580
2581        lock_packed_refs(LOCK_DIE_ON_ERROR);
2582        cbdata.packed_refs = get_packed_refs(&ref_cache);
2583
2584        do_for_each_entry_in_dir(get_loose_refs(&ref_cache), 0,
2585                                 pack_if_possible_fn, &cbdata);
2586
2587        if (commit_packed_refs())
2588                die_errno("unable to overwrite old ref-pack file");
2589
2590        prune_refs(cbdata.ref_to_prune);
2591        return 0;
2592}
2593
2594/*
2595 * If entry is no longer needed in packed-refs, add it to the string
2596 * list pointed to by cb_data.  Reasons for deleting entries:
2597 *
2598 * - Entry is broken.
2599 * - Entry is overridden by a loose ref.
2600 * - Entry does not point at a valid object.
2601 *
2602 * In the first and third cases, also emit an error message because these
2603 * are indications of repository corruption.
2604 */
2605static int curate_packed_ref_fn(struct ref_entry *entry, void *cb_data)
2606{
2607        struct string_list *refs_to_delete = cb_data;
2608
2609        if (entry->flag & REF_ISBROKEN) {
2610                /* This shouldn't happen to packed refs. */
2611                error("%s is broken!", entry->name);
2612                string_list_append(refs_to_delete, entry->name);
2613                return 0;
2614        }
2615        if (!has_sha1_file(entry->u.value.sha1)) {
2616                unsigned char sha1[20];
2617                int flags;
2618
2619                if (read_ref_full(entry->name, 0, sha1, &flags))
2620                        /* We should at least have found the packed ref. */
2621                        die("Internal error");
2622                if ((flags & REF_ISSYMREF) || !(flags & REF_ISPACKED)) {
2623                        /*
2624                         * This packed reference is overridden by a
2625                         * loose reference, so it is OK that its value
2626                         * is no longer valid; for example, it might
2627                         * refer to an object that has been garbage
2628                         * collected.  For this purpose we don't even
2629                         * care whether the loose reference itself is
2630                         * invalid, broken, symbolic, etc.  Silently
2631                         * remove the packed reference.
2632                         */
2633                        string_list_append(refs_to_delete, entry->name);
2634                        return 0;
2635                }
2636                /*
2637                 * There is no overriding loose reference, so the fact
2638                 * that this reference doesn't refer to a valid object
2639                 * indicates some kind of repository corruption.
2640                 * Report the problem, then omit the reference from
2641                 * the output.
2642                 */
2643                error("%s does not point to a valid object!", entry->name);
2644                string_list_append(refs_to_delete, entry->name);
2645                return 0;
2646        }
2647
2648        return 0;
2649}
2650
2651int repack_without_refs(struct string_list *refnames, struct strbuf *err)
2652{
2653        struct ref_dir *packed;
2654        struct string_list refs_to_delete = STRING_LIST_INIT_DUP;
2655        struct string_list_item *refname, *ref_to_delete;
2656        int ret, needs_repacking = 0, removed = 0;
2657
2658        assert(err);
2659
2660        /* Look for a packed ref */
2661        for_each_string_list_item(refname, refnames) {
2662                if (get_packed_ref(refname->string)) {
2663                        needs_repacking = 1;
2664                        break;
2665                }
2666        }
2667
2668        /* Avoid locking if we have nothing to do */
2669        if (!needs_repacking)
2670                return 0; /* no refname exists in packed refs */
2671
2672        if (lock_packed_refs(0)) {
2673                unable_to_lock_message(git_path("packed-refs"), errno, err);
2674                return -1;
2675        }
2676        packed = get_packed_refs(&ref_cache);
2677
2678        /* Remove refnames from the cache */
2679        for_each_string_list_item(refname, refnames)
2680                if (remove_entry(packed, refname->string) != -1)
2681                        removed = 1;
2682        if (!removed) {
2683                /*
2684                 * All packed entries disappeared while we were
2685                 * acquiring the lock.
2686                 */
2687                rollback_packed_refs();
2688                return 0;
2689        }
2690
2691        /* Remove any other accumulated cruft */
2692        do_for_each_entry_in_dir(packed, 0, curate_packed_ref_fn, &refs_to_delete);
2693        for_each_string_list_item(ref_to_delete, &refs_to_delete) {
2694                if (remove_entry(packed, ref_to_delete->string) == -1)
2695                        die("internal error");
2696        }
2697
2698        /* Write what remains */
2699        ret = commit_packed_refs();
2700        if (ret)
2701                strbuf_addf(err, "unable to overwrite old ref-pack file: %s",
2702                            strerror(errno));
2703        return ret;
2704}
2705
2706static int delete_ref_loose(struct ref_lock *lock, int flag, struct strbuf *err)
2707{
2708        assert(err);
2709
2710        if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {
2711                /*
2712                 * loose.  The loose file name is the same as the
2713                 * lockfile name, minus ".lock":
2714                 */
2715                char *loose_filename = get_locked_file_path(lock->lk);
2716                int res = unlink_or_msg(loose_filename, err);
2717                free(loose_filename);
2718                if (res)
2719                        return 1;
2720        }
2721        return 0;
2722}
2723
2724int delete_ref(const char *refname, const unsigned char *sha1, int delopt)
2725{
2726        struct ref_transaction *transaction;
2727        struct strbuf err = STRBUF_INIT;
2728
2729        transaction = ref_transaction_begin(&err);
2730        if (!transaction ||
2731            ref_transaction_delete(transaction, refname, sha1, delopt,
2732                                   sha1 && !is_null_sha1(sha1), NULL, &err) ||
2733            ref_transaction_commit(transaction, &err)) {
2734                error("%s", err.buf);
2735                ref_transaction_free(transaction);
2736                strbuf_release(&err);
2737                return 1;
2738        }
2739        ref_transaction_free(transaction);
2740        strbuf_release(&err);
2741        return 0;
2742}
2743
2744/*
2745 * People using contrib's git-new-workdir have .git/logs/refs ->
2746 * /some/other/path/.git/logs/refs, and that may live on another device.
2747 *
2748 * IOW, to avoid cross device rename errors, the temporary renamed log must
2749 * live into logs/refs.
2750 */
2751#define TMP_RENAMED_LOG  "logs/refs/.tmp-renamed-log"
2752
2753static int rename_tmp_log(const char *newrefname)
2754{
2755        int attempts_remaining = 4;
2756
2757 retry:
2758        switch (safe_create_leading_directories(git_path("logs/%s", newrefname))) {
2759        case SCLD_OK:
2760                break; /* success */
2761        case SCLD_VANISHED:
2762                if (--attempts_remaining > 0)
2763                        goto retry;
2764                /* fall through */
2765        default:
2766                error("unable to create directory for %s", newrefname);
2767                return -1;
2768        }
2769
2770        if (rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newrefname))) {
2771                if ((errno==EISDIR || errno==ENOTDIR) && --attempts_remaining > 0) {
2772                        /*
2773                         * rename(a, b) when b is an existing
2774                         * directory ought to result in ISDIR, but
2775                         * Solaris 5.8 gives ENOTDIR.  Sheesh.
2776                         */
2777                        if (remove_empty_directories(git_path("logs/%s", newrefname))) {
2778                                error("Directory not empty: logs/%s", newrefname);
2779                                return -1;
2780                        }
2781                        goto retry;
2782                } else if (errno == ENOENT && --attempts_remaining > 0) {
2783                        /*
2784                         * Maybe another process just deleted one of
2785                         * the directories in the path to newrefname.
2786                         * Try again from the beginning.
2787                         */
2788                        goto retry;
2789                } else {
2790                        error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",
2791                                newrefname, strerror(errno));
2792                        return -1;
2793                }
2794        }
2795        return 0;
2796}
2797
2798static int rename_ref_available(const char *oldname, const char *newname)
2799{
2800        struct string_list skip = STRING_LIST_INIT_NODUP;
2801        int ret;
2802
2803        string_list_insert(&skip, oldname);
2804        ret = is_refname_available(newname, &skip, get_packed_refs(&ref_cache))
2805            && is_refname_available(newname, &skip, get_loose_refs(&ref_cache));
2806        string_list_clear(&skip, 0);
2807        return ret;
2808}
2809
2810static int write_ref_sha1(struct ref_lock *lock, const unsigned char *sha1,
2811                          const char *logmsg);
2812
2813int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)
2814{
2815        unsigned char sha1[20], orig_sha1[20];
2816        int flag = 0, logmoved = 0;
2817        struct ref_lock *lock;
2818        struct stat loginfo;
2819        int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);
2820        const char *symref = NULL;
2821
2822        if (log && S_ISLNK(loginfo.st_mode))
2823                return error("reflog for %s is a symlink", oldrefname);
2824
2825        symref = resolve_ref_unsafe(oldrefname, RESOLVE_REF_READING,
2826                                    orig_sha1, &flag);
2827        if (flag & REF_ISSYMREF)
2828                return error("refname %s is a symbolic ref, renaming it is not supported",
2829                        oldrefname);
2830        if (!symref)
2831                return error("refname %s not found", oldrefname);
2832
2833        if (!rename_ref_available(oldrefname, newrefname))
2834                return 1;
2835
2836        if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))
2837                return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",
2838                        oldrefname, strerror(errno));
2839
2840        if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {
2841                error("unable to delete old %s", oldrefname);
2842                goto rollback;
2843        }
2844
2845        if (!read_ref_full(newrefname, RESOLVE_REF_READING, sha1, NULL) &&
2846            delete_ref(newrefname, sha1, REF_NODEREF)) {
2847                if (errno==EISDIR) {
2848                        if (remove_empty_directories(git_path("%s", newrefname))) {
2849                                error("Directory not empty: %s", newrefname);
2850                                goto rollback;
2851                        }
2852                } else {
2853                        error("unable to delete existing %s", newrefname);
2854                        goto rollback;
2855                }
2856        }
2857
2858        if (log && rename_tmp_log(newrefname))
2859                goto rollback;
2860
2861        logmoved = log;
2862
2863        lock = lock_ref_sha1_basic(newrefname, NULL, NULL, 0, NULL);
2864        if (!lock) {
2865                error("unable to lock %s for update", newrefname);
2866                goto rollback;
2867        }
2868        lock->force_write = 1;
2869        hashcpy(lock->old_sha1, orig_sha1);
2870        if (write_ref_sha1(lock, orig_sha1, logmsg)) {
2871                error("unable to write current sha1 into %s", newrefname);
2872                goto rollback;
2873        }
2874
2875        return 0;
2876
2877 rollback:
2878        lock = lock_ref_sha1_basic(oldrefname, NULL, NULL, 0, NULL);
2879        if (!lock) {
2880                error("unable to lock %s for rollback", oldrefname);
2881                goto rollbacklog;
2882        }
2883
2884        lock->force_write = 1;
2885        flag = log_all_ref_updates;
2886        log_all_ref_updates = 0;
2887        if (write_ref_sha1(lock, orig_sha1, NULL))
2888                error("unable to write current sha1 into %s", oldrefname);
2889        log_all_ref_updates = flag;
2890
2891 rollbacklog:
2892        if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))
2893                error("unable to restore logfile %s from %s: %s",
2894                        oldrefname, newrefname, strerror(errno));
2895        if (!logmoved && log &&
2896            rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))
2897                error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",
2898                        oldrefname, strerror(errno));
2899
2900        return 1;
2901}
2902
2903int close_ref(struct ref_lock *lock)
2904{
2905        if (close_lock_file(lock->lk))
2906                return -1;
2907        lock->lock_fd = -1;
2908        return 0;
2909}
2910
2911int commit_ref(struct ref_lock *lock)
2912{
2913        if (commit_lock_file(lock->lk))
2914                return -1;
2915        lock->lock_fd = -1;
2916        return 0;
2917}
2918
2919void unlock_ref(struct ref_lock *lock)
2920{
2921        /* Do not free lock->lk -- atexit() still looks at them */
2922        if (lock->lk)
2923                rollback_lock_file(lock->lk);
2924        free(lock->ref_name);
2925        free(lock->orig_ref_name);
2926        free(lock);
2927}
2928
2929/*
2930 * copy the reflog message msg to buf, which has been allocated sufficiently
2931 * large, while cleaning up the whitespaces.  Especially, convert LF to space,
2932 * because reflog file is one line per entry.
2933 */
2934static int copy_msg(char *buf, const char *msg)
2935{
2936        char *cp = buf;
2937        char c;
2938        int wasspace = 1;
2939
2940        *cp++ = '\t';
2941        while ((c = *msg++)) {
2942                if (wasspace && isspace(c))
2943                        continue;
2944                wasspace = isspace(c);
2945                if (wasspace)
2946                        c = ' ';
2947                *cp++ = c;
2948        }
2949        while (buf < cp && isspace(cp[-1]))
2950                cp--;
2951        *cp++ = '\n';
2952        return cp - buf;
2953}
2954
2955/* This function must set a meaningful errno on failure */
2956int log_ref_setup(const char *refname, char *logfile, int bufsize)
2957{
2958        int logfd, oflags = O_APPEND | O_WRONLY;
2959
2960        git_snpath(logfile, bufsize, "logs/%s", refname);
2961        if (log_all_ref_updates &&
2962            (starts_with(refname, "refs/heads/") ||
2963             starts_with(refname, "refs/remotes/") ||
2964             starts_with(refname, "refs/notes/") ||
2965             !strcmp(refname, "HEAD"))) {
2966                if (safe_create_leading_directories(logfile) < 0) {
2967                        int save_errno = errno;
2968                        error("unable to create directory for %s", logfile);
2969                        errno = save_errno;
2970                        return -1;
2971                }
2972                oflags |= O_CREAT;
2973        }
2974
2975        logfd = open(logfile, oflags, 0666);
2976        if (logfd < 0) {
2977                if (!(oflags & O_CREAT) && (errno == ENOENT || errno == EISDIR))
2978                        return 0;
2979
2980                if (errno == EISDIR) {
2981                        if (remove_empty_directories(logfile)) {
2982                                int save_errno = errno;
2983                                error("There are still logs under '%s'",
2984                                      logfile);
2985                                errno = save_errno;
2986                                return -1;
2987                        }
2988                        logfd = open(logfile, oflags, 0666);
2989                }
2990
2991                if (logfd < 0) {
2992                        int save_errno = errno;
2993                        error("Unable to append to %s: %s", logfile,
2994                              strerror(errno));
2995                        errno = save_errno;
2996                        return -1;
2997                }
2998        }
2999
3000        adjust_shared_perm(logfile);
3001        close(logfd);
3002        return 0;
3003}
3004
3005static int log_ref_write(const char *refname, const unsigned char *old_sha1,
3006                         const unsigned char *new_sha1, const char *msg)
3007{
3008        int logfd, result, written, oflags = O_APPEND | O_WRONLY;
3009        unsigned maxlen, len;
3010        int msglen;
3011        char log_file[PATH_MAX];
3012        char *logrec;
3013        const char *committer;
3014
3015        if (log_all_ref_updates < 0)
3016                log_all_ref_updates = !is_bare_repository();
3017
3018        result = log_ref_setup(refname, log_file, sizeof(log_file));
3019        if (result)
3020                return result;
3021
3022        logfd = open(log_file, oflags);
3023        if (logfd < 0)
3024                return 0;
3025        msglen = msg ? strlen(msg) : 0;
3026        committer = git_committer_info(0);
3027        maxlen = strlen(committer) + msglen + 100;
3028        logrec = xmalloc(maxlen);
3029        len = sprintf(logrec, "%s %s %s\n",
3030                      sha1_to_hex(old_sha1),
3031                      sha1_to_hex(new_sha1),
3032                      committer);
3033        if (msglen)
3034                len += copy_msg(logrec + len - 1, msg) - 1;
3035        written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;
3036        free(logrec);
3037        if (written != len) {
3038                int save_errno = errno;
3039                close(logfd);
3040                error("Unable to append to %s", log_file);
3041                errno = save_errno;
3042                return -1;
3043        }
3044        if (close(logfd)) {
3045                int save_errno = errno;
3046                error("Unable to append to %s", log_file);
3047                errno = save_errno;
3048                return -1;
3049        }
3050        return 0;
3051}
3052
3053int is_branch(const char *refname)
3054{
3055        return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");
3056}
3057
3058/*
3059 * Write sha1 into the ref specified by the lock. Make sure that errno
3060 * is sane on error.
3061 */
3062static int write_ref_sha1(struct ref_lock *lock,
3063        const unsigned char *sha1, const char *logmsg)
3064{
3065        static char term = '\n';
3066        struct object *o;
3067
3068        if (!lock) {
3069                errno = EINVAL;
3070                return -1;
3071        }
3072        if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {
3073                unlock_ref(lock);
3074                return 0;
3075        }
3076        o = parse_object(sha1);
3077        if (!o) {
3078                error("Trying to write ref %s with nonexistent object %s",
3079                        lock->ref_name, sha1_to_hex(sha1));
3080                unlock_ref(lock);
3081                errno = EINVAL;
3082                return -1;
3083        }
3084        if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {
3085                error("Trying to write non-commit object %s to branch %s",
3086                        sha1_to_hex(sha1), lock->ref_name);
3087                unlock_ref(lock);
3088                errno = EINVAL;
3089                return -1;
3090        }
3091        if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||
3092            write_in_full(lock->lock_fd, &term, 1) != 1 ||
3093            close_ref(lock) < 0) {
3094                int save_errno = errno;
3095                error("Couldn't write %s", lock->lk->filename.buf);
3096                unlock_ref(lock);
3097                errno = save_errno;
3098                return -1;
3099        }
3100        clear_loose_ref_cache(&ref_cache);
3101        if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||
3102            (strcmp(lock->ref_name, lock->orig_ref_name) &&
3103             log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {
3104                unlock_ref(lock);
3105                return -1;
3106        }
3107        if (strcmp(lock->orig_ref_name, "HEAD") != 0) {
3108                /*
3109                 * Special hack: If a branch is updated directly and HEAD
3110                 * points to it (may happen on the remote side of a push
3111                 * for example) then logically the HEAD reflog should be
3112                 * updated too.
3113                 * A generic solution implies reverse symref information,
3114                 * but finding all symrefs pointing to the given branch
3115                 * would be rather costly for this rare event (the direct
3116                 * update of a branch) to be worth it.  So let's cheat and
3117                 * check with HEAD only which should cover 99% of all usage
3118                 * scenarios (even 100% of the default ones).
3119                 */
3120                unsigned char head_sha1[20];
3121                int head_flag;
3122                const char *head_ref;
3123                head_ref = resolve_ref_unsafe("HEAD", RESOLVE_REF_READING,
3124                                              head_sha1, &head_flag);
3125                if (head_ref && (head_flag & REF_ISSYMREF) &&
3126                    !strcmp(head_ref, lock->ref_name))
3127                        log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);
3128        }
3129        if (commit_ref(lock)) {
3130                error("Couldn't set %s", lock->ref_name);
3131                unlock_ref(lock);
3132                return -1;
3133        }
3134        unlock_ref(lock);
3135        return 0;
3136}
3137
3138int create_symref(const char *ref_target, const char *refs_heads_master,
3139                  const char *logmsg)
3140{
3141        const char *lockpath;
3142        char ref[1000];
3143        int fd, len, written;
3144        char *git_HEAD = git_pathdup("%s", ref_target);
3145        unsigned char old_sha1[20], new_sha1[20];
3146
3147        if (logmsg && read_ref(ref_target, old_sha1))
3148                hashclr(old_sha1);
3149
3150        if (safe_create_leading_directories(git_HEAD) < 0)
3151                return error("unable to create directory for %s", git_HEAD);
3152
3153#ifndef NO_SYMLINK_HEAD
3154        if (prefer_symlink_refs) {
3155                unlink(git_HEAD);
3156                if (!symlink(refs_heads_master, git_HEAD))
3157                        goto done;
3158                fprintf(stderr, "no symlink - falling back to symbolic ref\n");
3159        }
3160#endif
3161
3162        len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);
3163        if (sizeof(ref) <= len) {
3164                error("refname too long: %s", refs_heads_master);
3165                goto error_free_return;
3166        }
3167        lockpath = mkpath("%s.lock", git_HEAD);
3168        fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);
3169        if (fd < 0) {
3170                error("Unable to open %s for writing", lockpath);
3171                goto error_free_return;
3172        }
3173        written = write_in_full(fd, ref, len);
3174        if (close(fd) != 0 || written != len) {
3175                error("Unable to write to %s", lockpath);
3176                goto error_unlink_return;
3177        }
3178        if (rename(lockpath, git_HEAD) < 0) {
3179                error("Unable to create %s", git_HEAD);
3180                goto error_unlink_return;
3181        }
3182        if (adjust_shared_perm(git_HEAD)) {
3183                error("Unable to fix permissions on %s", lockpath);
3184        error_unlink_return:
3185                unlink_or_warn(lockpath);
3186        error_free_return:
3187                free(git_HEAD);
3188                return -1;
3189        }
3190
3191#ifndef NO_SYMLINK_HEAD
3192        done:
3193#endif
3194        if (logmsg && !read_ref(refs_heads_master, new_sha1))
3195                log_ref_write(ref_target, old_sha1, new_sha1, logmsg);
3196
3197        free(git_HEAD);
3198        return 0;
3199}
3200
3201struct read_ref_at_cb {
3202        const char *refname;
3203        unsigned long at_time;
3204        int cnt;
3205        int reccnt;
3206        unsigned char *sha1;
3207        int found_it;
3208
3209        unsigned char osha1[20];
3210        unsigned char nsha1[20];
3211        int tz;
3212        unsigned long date;
3213        char **msg;
3214        unsigned long *cutoff_time;
3215        int *cutoff_tz;
3216        int *cutoff_cnt;
3217};
3218
3219static int read_ref_at_ent(unsigned char *osha1, unsigned char *nsha1,
3220                const char *email, unsigned long timestamp, int tz,
3221                const char *message, void *cb_data)
3222{
3223        struct read_ref_at_cb *cb = cb_data;
3224
3225        cb->reccnt++;
3226        cb->tz = tz;
3227        cb->date = timestamp;
3228
3229        if (timestamp <= cb->at_time || cb->cnt == 0) {
3230                if (cb->msg)
3231                        *cb->msg = xstrdup(message);
3232                if (cb->cutoff_time)
3233                        *cb->cutoff_time = timestamp;
3234                if (cb->cutoff_tz)
3235                        *cb->cutoff_tz = tz;
3236                if (cb->cutoff_cnt)
3237                        *cb->cutoff_cnt = cb->reccnt - 1;
3238                /*
3239                 * we have not yet updated cb->[n|o]sha1 so they still
3240                 * hold the values for the previous record.
3241                 */
3242                if (!is_null_sha1(cb->osha1)) {
3243                        hashcpy(cb->sha1, nsha1);
3244                        if (hashcmp(cb->osha1, nsha1))
3245                                warning("Log for ref %s has gap after %s.",
3246                                        cb->refname, show_date(cb->date, cb->tz, DATE_RFC2822));
3247                }
3248                else if (cb->date == cb->at_time)
3249                        hashcpy(cb->sha1, nsha1);
3250                else if (hashcmp(nsha1, cb->sha1))
3251                        warning("Log for ref %s unexpectedly ended on %s.",
3252                                cb->refname, show_date(cb->date, cb->tz,
3253                                                   DATE_RFC2822));
3254                hashcpy(cb->osha1, osha1);
3255                hashcpy(cb->nsha1, nsha1);
3256                cb->found_it = 1;
3257                return 1;
3258        }
3259        hashcpy(cb->osha1, osha1);
3260        hashcpy(cb->nsha1, nsha1);
3261        if (cb->cnt > 0)
3262                cb->cnt--;
3263        return 0;
3264}
3265
3266static int read_ref_at_ent_oldest(unsigned char *osha1, unsigned char *nsha1,
3267                                  const char *email, unsigned long timestamp,
3268                                  int tz, const char *message, void *cb_data)
3269{
3270        struct read_ref_at_cb *cb = cb_data;
3271
3272        if (cb->msg)
3273                *cb->msg = xstrdup(message);
3274        if (cb->cutoff_time)
3275                *cb->cutoff_time = timestamp;
3276        if (cb->cutoff_tz)
3277                *cb->cutoff_tz = tz;
3278        if (cb->cutoff_cnt)
3279                *cb->cutoff_cnt = cb->reccnt;
3280        hashcpy(cb->sha1, osha1);
3281        if (is_null_sha1(cb->sha1))
3282                hashcpy(cb->sha1, nsha1);
3283        /* We just want the first entry */
3284        return 1;
3285}
3286
3287int read_ref_at(const char *refname, unsigned int flags, unsigned long at_time, int cnt,
3288                unsigned char *sha1, char **msg,
3289                unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)
3290{
3291        struct read_ref_at_cb cb;
3292
3293        memset(&cb, 0, sizeof(cb));
3294        cb.refname = refname;
3295        cb.at_time = at_time;
3296        cb.cnt = cnt;
3297        cb.msg = msg;
3298        cb.cutoff_time = cutoff_time;
3299        cb.cutoff_tz = cutoff_tz;
3300        cb.cutoff_cnt = cutoff_cnt;
3301        cb.sha1 = sha1;
3302
3303        for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);
3304
3305        if (!cb.reccnt) {
3306                if (flags & GET_SHA1_QUIETLY)
3307                        exit(128);
3308                else
3309                        die("Log for %s is empty.", refname);
3310        }
3311        if (cb.found_it)
3312                return 0;
3313
3314        for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);
3315
3316        return 1;
3317}
3318
3319int reflog_exists(const char *refname)
3320{
3321        struct stat st;
3322
3323        return !lstat(git_path("logs/%s", refname), &st) &&
3324                S_ISREG(st.st_mode);
3325}
3326
3327int delete_reflog(const char *refname)
3328{
3329        return remove_path(git_path("logs/%s", refname));
3330}
3331
3332static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)
3333{
3334        unsigned char osha1[20], nsha1[20];
3335        char *email_end, *message;
3336        unsigned long timestamp;
3337        int tz;
3338
3339        /* old SP new SP name <email> SP time TAB msg LF */
3340        if (sb->len < 83 || sb->buf[sb->len - 1] != '\n' ||
3341            get_sha1_hex(sb->buf, osha1) || sb->buf[40] != ' ' ||
3342            get_sha1_hex(sb->buf + 41, nsha1) || sb->buf[81] != ' ' ||
3343            !(email_end = strchr(sb->buf + 82, '>')) ||
3344            email_end[1] != ' ' ||
3345            !(timestamp = strtoul(email_end + 2, &message, 10)) ||
3346            !message || message[0] != ' ' ||
3347            (message[1] != '+' && message[1] != '-') ||
3348            !isdigit(message[2]) || !isdigit(message[3]) ||
3349            !isdigit(message[4]) || !isdigit(message[5]))
3350                return 0; /* corrupt? */
3351        email_end[1] = '\0';
3352        tz = strtol(message + 1, NULL, 10);
3353        if (message[6] != '\t')
3354                message += 6;
3355        else
3356                message += 7;
3357        return fn(osha1, nsha1, sb->buf + 82, timestamp, tz, message, cb_data);
3358}
3359
3360static char *find_beginning_of_line(char *bob, char *scan)
3361{
3362        while (bob < scan && *(--scan) != '\n')
3363                ; /* keep scanning backwards */
3364        /*
3365         * Return either beginning of the buffer, or LF at the end of
3366         * the previous line.
3367         */
3368        return scan;
3369}
3370
3371int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data)
3372{
3373        struct strbuf sb = STRBUF_INIT;
3374        FILE *logfp;
3375        long pos;
3376        int ret = 0, at_tail = 1;
3377
3378        logfp = fopen(git_path("logs/%s", refname), "r");
3379        if (!logfp)
3380                return -1;
3381
3382        /* Jump to the end */
3383        if (fseek(logfp, 0, SEEK_END) < 0)
3384                return error("cannot seek back reflog for %s: %s",
3385                             refname, strerror(errno));
3386        pos = ftell(logfp);
3387        while (!ret && 0 < pos) {
3388                int cnt;
3389                size_t nread;
3390                char buf[BUFSIZ];
3391                char *endp, *scanp;
3392
3393                /* Fill next block from the end */
3394                cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;
3395                if (fseek(logfp, pos - cnt, SEEK_SET))
3396                        return error("cannot seek back reflog for %s: %s",
3397                                     refname, strerror(errno));
3398                nread = fread(buf, cnt, 1, logfp);
3399                if (nread != 1)
3400                        return error("cannot read %d bytes from reflog for %s: %s",
3401                                     cnt, refname, strerror(errno));
3402                pos -= cnt;
3403
3404                scanp = endp = buf + cnt;
3405                if (at_tail && scanp[-1] == '\n')
3406                        /* Looking at the final LF at the end of the file */
3407                        scanp--;
3408                at_tail = 0;
3409
3410                while (buf < scanp) {
3411                        /*
3412                         * terminating LF of the previous line, or the beginning
3413                         * of the buffer.
3414                         */
3415                        char *bp;
3416
3417                        bp = find_beginning_of_line(buf, scanp);
3418
3419                        if (*bp == '\n') {
3420                                /*
3421                                 * The newline is the end of the previous line,
3422                                 * so we know we have complete line starting
3423                                 * at (bp + 1). Prefix it onto any prior data
3424                                 * we collected for the line and process it.
3425                                 */
3426                                strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1));
3427                                scanp = bp;
3428                                endp = bp + 1;
3429                                ret = show_one_reflog_ent(&sb, fn, cb_data);
3430                                strbuf_reset(&sb);
3431                                if (ret)
3432                                        break;
3433                        } else if (!pos) {
3434                                /*
3435                                 * We are at the start of the buffer, and the
3436                                 * start of the file; there is no previous
3437                                 * line, and we have everything for this one.
3438                                 * Process it, and we can end the loop.
3439                                 */
3440                                strbuf_splice(&sb, 0, 0, buf, endp - buf);
3441                                ret = show_one_reflog_ent(&sb, fn, cb_data);
3442                                strbuf_reset(&sb);
3443                                break;
3444                        }
3445
3446                        if (bp == buf) {
3447                                /*
3448                                 * We are at the start of the buffer, and there
3449                                 * is more file to read backwards. Which means
3450                                 * we are in the middle of a line. Note that we
3451                                 * may get here even if *bp was a newline; that
3452                                 * just means we are at the exact end of the
3453                                 * previous line, rather than some spot in the
3454                                 * middle.
3455                                 *
3456                                 * Save away what we have to be combined with
3457                                 * the data from the next read.
3458                                 */
3459                                strbuf_splice(&sb, 0, 0, buf, endp - buf);
3460                                break;
3461                        }
3462                }
3463
3464        }
3465        if (!ret && sb.len)
3466                die("BUG: reverse reflog parser had leftover data");
3467
3468        fclose(logfp);
3469        strbuf_release(&sb);
3470        return ret;
3471}
3472
3473int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)
3474{
3475        FILE *logfp;
3476        struct strbuf sb = STRBUF_INIT;
3477        int ret = 0;
3478
3479        logfp = fopen(git_path("logs/%s", refname), "r");
3480        if (!logfp)
3481                return -1;
3482
3483        while (!ret && !strbuf_getwholeline(&sb, logfp, '\n'))
3484                ret = show_one_reflog_ent(&sb, fn, cb_data);
3485        fclose(logfp);
3486        strbuf_release(&sb);
3487        return ret;
3488}
3489/*
3490 * Call fn for each reflog in the namespace indicated by name.  name
3491 * must be empty or end with '/'.  Name will be used as a scratch
3492 * space, but its contents will be restored before return.
3493 */
3494static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data)
3495{
3496        DIR *d = opendir(git_path("logs/%s", name->buf));
3497        int retval = 0;
3498        struct dirent *de;
3499        int oldlen = name->len;
3500
3501        if (!d)
3502                return name->len ? errno : 0;
3503
3504        while ((de = readdir(d)) != NULL) {
3505                struct stat st;
3506
3507                if (de->d_name[0] == '.')
3508                        continue;
3509                if (ends_with(de->d_name, ".lock"))
3510                        continue;
3511                strbuf_addstr(name, de->d_name);
3512                if (stat(git_path("logs/%s", name->buf), &st) < 0) {
3513                        ; /* silently ignore */
3514                } else {
3515                        if (S_ISDIR(st.st_mode)) {
3516                                strbuf_addch(name, '/');
3517                                retval = do_for_each_reflog(name, fn, cb_data);
3518                        } else {
3519                                unsigned char sha1[20];
3520                                if (read_ref_full(name->buf, 0, sha1, NULL))
3521                                        retval = error("bad ref for %s", name->buf);
3522                                else
3523                                        retval = fn(name->buf, sha1, 0, cb_data);
3524                        }
3525                        if (retval)
3526                                break;
3527                }
3528                strbuf_setlen(name, oldlen);
3529        }
3530        closedir(d);
3531        return retval;
3532}
3533
3534int for_each_reflog(each_ref_fn fn, void *cb_data)
3535{
3536        int retval;
3537        struct strbuf name;
3538        strbuf_init(&name, PATH_MAX);
3539        retval = do_for_each_reflog(&name, fn, cb_data);
3540        strbuf_release(&name);
3541        return retval;
3542}
3543
3544/**
3545 * Information needed for a single ref update.  Set new_sha1 to the
3546 * new value or to zero to delete the ref.  To check the old value
3547 * while locking the ref, set have_old to 1 and set old_sha1 to the
3548 * value or to zero to ensure the ref does not exist before update.
3549 */
3550struct ref_update {
3551        unsigned char new_sha1[20];
3552        unsigned char old_sha1[20];
3553        int flags; /* REF_NODEREF? */
3554        int have_old; /* 1 if old_sha1 is valid, 0 otherwise */
3555        struct ref_lock *lock;
3556        int type;
3557        char *msg;
3558        const char refname[FLEX_ARRAY];
3559};
3560
3561/*
3562 * Transaction states.
3563 * OPEN:   The transaction is in a valid state and can accept new updates.
3564 *         An OPEN transaction can be committed.
3565 * CLOSED: A closed transaction is no longer active and no other operations
3566 *         than free can be used on it in this state.
3567 *         A transaction can either become closed by successfully committing
3568 *         an active transaction or if there is a failure while building
3569 *         the transaction thus rendering it failed/inactive.
3570 */
3571enum ref_transaction_state {
3572        REF_TRANSACTION_OPEN   = 0,
3573        REF_TRANSACTION_CLOSED = 1
3574};
3575
3576/*
3577 * Data structure for holding a reference transaction, which can
3578 * consist of checks and updates to multiple references, carried out
3579 * as atomically as possible.  This structure is opaque to callers.
3580 */
3581struct ref_transaction {
3582        struct ref_update **updates;
3583        size_t alloc;
3584        size_t nr;
3585        enum ref_transaction_state state;
3586};
3587
3588struct ref_transaction *ref_transaction_begin(struct strbuf *err)
3589{
3590        assert(err);
3591
3592        return xcalloc(1, sizeof(struct ref_transaction));
3593}
3594
3595void ref_transaction_free(struct ref_transaction *transaction)
3596{
3597        int i;
3598
3599        if (!transaction)
3600                return;
3601
3602        for (i = 0; i < transaction->nr; i++) {
3603                free(transaction->updates[i]->msg);
3604                free(transaction->updates[i]);
3605        }
3606        free(transaction->updates);
3607        free(transaction);
3608}
3609
3610static struct ref_update *add_update(struct ref_transaction *transaction,
3611                                     const char *refname)
3612{
3613        size_t len = strlen(refname);
3614        struct ref_update *update = xcalloc(1, sizeof(*update) + len + 1);
3615
3616        strcpy((char *)update->refname, refname);
3617        ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);
3618        transaction->updates[transaction->nr++] = update;
3619        return update;
3620}
3621
3622int ref_transaction_update(struct ref_transaction *transaction,
3623                           const char *refname,
3624                           const unsigned char *new_sha1,
3625                           const unsigned char *old_sha1,
3626                           int flags, int have_old, const char *msg,
3627                           struct strbuf *err)
3628{
3629        struct ref_update *update;
3630
3631        assert(err);
3632
3633        if (transaction->state != REF_TRANSACTION_OPEN)
3634                die("BUG: update called for transaction that is not open");
3635
3636        if (have_old && !old_sha1)
3637                die("BUG: have_old is true but old_sha1 is NULL");
3638
3639        if (!is_null_sha1(new_sha1) &&
3640            check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
3641                strbuf_addf(err, "refusing to update ref with bad name %s",
3642                            refname);
3643                return -1;
3644        }
3645
3646        update = add_update(transaction, refname);
3647        hashcpy(update->new_sha1, new_sha1);
3648        update->flags = flags;
3649        update->have_old = have_old;
3650        if (have_old)
3651                hashcpy(update->old_sha1, old_sha1);
3652        if (msg)
3653                update->msg = xstrdup(msg);
3654        return 0;
3655}
3656
3657int ref_transaction_create(struct ref_transaction *transaction,
3658                           const char *refname,
3659                           const unsigned char *new_sha1,
3660                           int flags, const char *msg,
3661                           struct strbuf *err)
3662{
3663        struct ref_update *update;
3664
3665        assert(err);
3666
3667        if (transaction->state != REF_TRANSACTION_OPEN)
3668                die("BUG: create called for transaction that is not open");
3669
3670        if (!new_sha1 || is_null_sha1(new_sha1))
3671                die("BUG: create ref with null new_sha1");
3672
3673        if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {
3674                strbuf_addf(err, "refusing to create ref with bad name %s",
3675                            refname);
3676                return -1;
3677        }
3678
3679        update = add_update(transaction, refname);
3680
3681        hashcpy(update->new_sha1, new_sha1);
3682        hashclr(update->old_sha1);
3683        update->flags = flags;
3684        update->have_old = 1;
3685        if (msg)
3686                update->msg = xstrdup(msg);
3687        return 0;
3688}
3689
3690int ref_transaction_delete(struct ref_transaction *transaction,
3691                           const char *refname,
3692                           const unsigned char *old_sha1,
3693                           int flags, int have_old, const char *msg,
3694                           struct strbuf *err)
3695{
3696        struct ref_update *update;
3697
3698        assert(err);
3699
3700        if (transaction->state != REF_TRANSACTION_OPEN)
3701                die("BUG: delete called for transaction that is not open");
3702
3703        if (have_old && !old_sha1)
3704                die("BUG: have_old is true but old_sha1 is NULL");
3705
3706        update = add_update(transaction, refname);
3707        update->flags = flags;
3708        update->have_old = have_old;
3709        if (have_old) {
3710                assert(!is_null_sha1(old_sha1));
3711                hashcpy(update->old_sha1, old_sha1);
3712        }
3713        if (msg)
3714                update->msg = xstrdup(msg);
3715        return 0;
3716}
3717
3718int update_ref(const char *action, const char *refname,
3719               const unsigned char *sha1, const unsigned char *oldval,
3720               int flags, enum action_on_err onerr)
3721{
3722        struct ref_transaction *t;
3723        struct strbuf err = STRBUF_INIT;
3724
3725        t = ref_transaction_begin(&err);
3726        if (!t ||
3727            ref_transaction_update(t, refname, sha1, oldval, flags,
3728                                   !!oldval, action, &err) ||
3729            ref_transaction_commit(t, &err)) {
3730                const char *str = "update_ref failed for ref '%s': %s";
3731
3732                ref_transaction_free(t);
3733                switch (onerr) {
3734                case UPDATE_REFS_MSG_ON_ERR:
3735                        error(str, refname, err.buf);
3736                        break;
3737                case UPDATE_REFS_DIE_ON_ERR:
3738                        die(str, refname, err.buf);
3739                        break;
3740                case UPDATE_REFS_QUIET_ON_ERR:
3741                        break;
3742                }
3743                strbuf_release(&err);
3744                return 1;
3745        }
3746        strbuf_release(&err);
3747        ref_transaction_free(t);
3748        return 0;
3749}
3750
3751static int ref_update_compare(const void *r1, const void *r2)
3752{
3753        const struct ref_update * const *u1 = r1;
3754        const struct ref_update * const *u2 = r2;
3755        return strcmp((*u1)->refname, (*u2)->refname);
3756}
3757
3758static int ref_update_reject_duplicates(struct ref_update **updates, int n,
3759                                        struct strbuf *err)
3760{
3761        int i;
3762
3763        assert(err);
3764
3765        for (i = 1; i < n; i++)
3766                if (!strcmp(updates[i - 1]->refname, updates[i]->refname)) {
3767                        strbuf_addf(err,
3768                                    "Multiple updates for ref '%s' not allowed.",
3769                                    updates[i]->refname);
3770                        return 1;
3771                }
3772        return 0;
3773}
3774
3775int ref_transaction_commit(struct ref_transaction *transaction,
3776                           struct strbuf *err)
3777{
3778        int ret = 0, i;
3779        int n = transaction->nr;
3780        struct ref_update **updates = transaction->updates;
3781        struct string_list refs_to_delete = STRING_LIST_INIT_NODUP;
3782        struct string_list_item *ref_to_delete;
3783
3784        assert(err);
3785
3786        if (transaction->state != REF_TRANSACTION_OPEN)
3787                die("BUG: commit called for transaction that is not open");
3788
3789        if (!n) {
3790                transaction->state = REF_TRANSACTION_CLOSED;
3791                return 0;
3792        }
3793
3794        /* Copy, sort, and reject duplicate refs */
3795        qsort(updates, n, sizeof(*updates), ref_update_compare);
3796        if (ref_update_reject_duplicates(updates, n, err)) {
3797                ret = TRANSACTION_GENERIC_ERROR;
3798                goto cleanup;
3799        }
3800
3801        /* Acquire all locks while verifying old values */
3802        for (i = 0; i < n; i++) {
3803                struct ref_update *update = updates[i];
3804                int flags = update->flags;
3805
3806                if (is_null_sha1(update->new_sha1))
3807                        flags |= REF_DELETING;
3808                update->lock = lock_ref_sha1_basic(update->refname,
3809                                                   (update->have_old ?
3810                                                    update->old_sha1 :
3811                                                    NULL),
3812                                                   NULL,
3813                                                   flags,
3814                                                   &update->type);
3815                if (!update->lock) {
3816                        ret = (errno == ENOTDIR)
3817                                ? TRANSACTION_NAME_CONFLICT
3818                                : TRANSACTION_GENERIC_ERROR;
3819                        strbuf_addf(err, "Cannot lock the ref '%s'.",
3820                                    update->refname);
3821                        goto cleanup;
3822                }
3823        }
3824
3825        /* Perform updates first so live commits remain referenced */
3826        for (i = 0; i < n; i++) {
3827                struct ref_update *update = updates[i];
3828
3829                if (!is_null_sha1(update->new_sha1)) {
3830                        if (write_ref_sha1(update->lock, update->new_sha1,
3831                                           update->msg)) {
3832                                update->lock = NULL; /* freed by write_ref_sha1 */
3833                                strbuf_addf(err, "Cannot update the ref '%s'.",
3834                                            update->refname);
3835                                ret = TRANSACTION_GENERIC_ERROR;
3836                                goto cleanup;
3837                        }
3838                        update->lock = NULL; /* freed by write_ref_sha1 */
3839                }
3840        }
3841
3842        /* Perform deletes now that updates are safely completed */
3843        for (i = 0; i < n; i++) {
3844                struct ref_update *update = updates[i];
3845
3846                if (update->lock) {
3847                        if (delete_ref_loose(update->lock, update->type, err)) {
3848                                ret = TRANSACTION_GENERIC_ERROR;
3849                                goto cleanup;
3850                        }
3851
3852                        if (!(update->flags & REF_ISPRUNING))
3853                                string_list_append(&refs_to_delete,
3854                                                   update->lock->ref_name);
3855                }
3856        }
3857
3858        if (repack_without_refs(&refs_to_delete, err)) {
3859                ret = TRANSACTION_GENERIC_ERROR;
3860                goto cleanup;
3861        }
3862        for_each_string_list_item(ref_to_delete, &refs_to_delete)
3863                unlink_or_warn(git_path("logs/%s", ref_to_delete->string));
3864        clear_loose_ref_cache(&ref_cache);
3865
3866cleanup:
3867        transaction->state = REF_TRANSACTION_CLOSED;
3868
3869        for (i = 0; i < n; i++)
3870                if (updates[i]->lock)
3871                        unlock_ref(updates[i]->lock);
3872        string_list_clear(&refs_to_delete, 0);
3873        return ret;
3874}
3875
3876char *shorten_unambiguous_ref(const char *refname, int strict)
3877{
3878        int i;
3879        static char **scanf_fmts;
3880        static int nr_rules;
3881        char *short_name;
3882
3883        if (!nr_rules) {
3884                /*
3885                 * Pre-generate scanf formats from ref_rev_parse_rules[].
3886                 * Generate a format suitable for scanf from a
3887                 * ref_rev_parse_rules rule by interpolating "%s" at the
3888                 * location of the "%.*s".
3889                 */
3890                size_t total_len = 0;
3891                size_t offset = 0;
3892
3893                /* the rule list is NULL terminated, count them first */
3894                for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)
3895                        /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */
3896                        total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;
3897
3898                scanf_fmts = xmalloc(nr_rules * sizeof(char *) + total_len);
3899
3900                offset = 0;
3901                for (i = 0; i < nr_rules; i++) {
3902                        assert(offset < total_len);
3903                        scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;
3904                        offset += snprintf(scanf_fmts[i], total_len - offset,
3905                                           ref_rev_parse_rules[i], 2, "%s") + 1;
3906                }
3907        }
3908
3909        /* bail out if there are no rules */
3910        if (!nr_rules)
3911                return xstrdup(refname);
3912
3913        /* buffer for scanf result, at most refname must fit */
3914        short_name = xstrdup(refname);
3915
3916        /* skip first rule, it will always match */
3917        for (i = nr_rules - 1; i > 0 ; --i) {
3918                int j;
3919                int rules_to_fail = i;
3920                int short_name_len;
3921
3922                if (1 != sscanf(refname, scanf_fmts[i], short_name))
3923                        continue;
3924
3925                short_name_len = strlen(short_name);
3926
3927                /*
3928                 * in strict mode, all (except the matched one) rules
3929                 * must fail to resolve to a valid non-ambiguous ref
3930                 */
3931                if (strict)
3932                        rules_to_fail = nr_rules;
3933
3934                /*
3935                 * check if the short name resolves to a valid ref,
3936                 * but use only rules prior to the matched one
3937                 */
3938                for (j = 0; j < rules_to_fail; j++) {
3939                        const char *rule = ref_rev_parse_rules[j];
3940                        char refname[PATH_MAX];
3941
3942                        /* skip matched rule */
3943                        if (i == j)
3944                                continue;
3945
3946                        /*
3947                         * the short name is ambiguous, if it resolves
3948                         * (with this previous rule) to a valid ref
3949                         * read_ref() returns 0 on success
3950                         */
3951                        mksnpath(refname, sizeof(refname),
3952                                 rule, short_name_len, short_name);
3953                        if (ref_exists(refname))
3954                                break;
3955                }
3956
3957                /*
3958                 * short name is non-ambiguous if all previous rules
3959                 * haven't resolved to a valid ref
3960                 */
3961                if (j == rules_to_fail)
3962                        return short_name;
3963        }
3964
3965        free(short_name);
3966        return xstrdup(refname);
3967}
3968
3969static struct string_list *hide_refs;
3970
3971int parse_hide_refs_config(const char *var, const char *value, const char *section)
3972{
3973        if (!strcmp("transfer.hiderefs", var) ||
3974            /* NEEDSWORK: use parse_config_key() once both are merged */
3975            (starts_with(var, section) && var[strlen(section)] == '.' &&
3976             !strcmp(var + strlen(section), ".hiderefs"))) {
3977                char *ref;
3978                int len;
3979
3980                if (!value)
3981                        return config_error_nonbool(var);
3982                ref = xstrdup(value);
3983                len = strlen(ref);
3984                while (len && ref[len - 1] == '/')
3985                        ref[--len] = '\0';
3986                if (!hide_refs) {
3987                        hide_refs = xcalloc(1, sizeof(*hide_refs));
3988                        hide_refs->strdup_strings = 1;
3989                }
3990                string_list_append(hide_refs, ref);
3991        }
3992        return 0;
3993}
3994
3995int ref_is_hidden(const char *refname)
3996{
3997        struct string_list_item *item;
3998
3999        if (!hide_refs)
4000                return 0;
4001        for_each_string_list_item(item, hide_refs) {
4002                int len;
4003                if (!starts_with(refname, item->string))
4004                        continue;
4005                len = strlen(item->string);
4006                if (!refname[len] || refname[len] == '/')
4007                        return 1;
4008        }
4009        return 0;
4010}