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