1#include "../cache.h" 2#include "../refs.h" 3#include "refs-internal.h" 4#include "../lockfile.h" 5#include "../object.h" 6#include "../dir.h" 7 8struct ref_lock { 9 char *ref_name; 10 char *orig_ref_name; 11 struct lock_file *lk; 12 struct object_id old_oid; 13}; 14 15struct ref_entry; 16 17/* 18 * Information used (along with the information in ref_entry) to 19 * describe a single cached reference. This data structure only 20 * occurs embedded in a union in struct ref_entry, and only when 21 * (ref_entry->flag & REF_DIR) is zero. 22 */ 23struct ref_value { 24 /* 25 * The name of the object to which this reference resolves 26 * (which may be a tag object). If REF_ISBROKEN, this is 27 * null. If REF_ISSYMREF, then this is the name of the object 28 * referred to by the last reference in the symlink chain. 29 */ 30 struct object_id oid; 31 32 /* 33 * If REF_KNOWS_PEELED, then this field holds the peeled value 34 * of this reference, or null if the reference is known not to 35 * be peelable. See the documentation for peel_ref() for an 36 * exact definition of "peelable". 37 */ 38 struct object_id peeled; 39}; 40 41struct ref_cache; 42 43/* 44 * Information used (along with the information in ref_entry) to 45 * describe a level in the hierarchy of references. This data 46 * structure only occurs embedded in a union in struct ref_entry, and 47 * only when (ref_entry.flag & REF_DIR) is set. In that case, 48 * (ref_entry.flag & REF_INCOMPLETE) determines whether the references 49 * in the directory have already been read: 50 * 51 * (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose 52 * or packed references, already read. 53 * 54 * (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose 55 * references that hasn't been read yet (nor has any of its 56 * subdirectories). 57 * 58 * Entries within a directory are stored within a growable array of 59 * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i < 60 * sorted are sorted by their component name in strcmp() order and the 61 * remaining entries are unsorted. 62 * 63 * Loose references are read lazily, one directory at a time. When a 64 * directory of loose references is read, then all of the references 65 * in that directory are stored, and REF_INCOMPLETE stubs are created 66 * for any subdirectories, but the subdirectories themselves are not 67 * read. The reading is triggered by get_ref_dir(). 68 */ 69struct ref_dir { 70 int nr, alloc; 71 72 /* 73 * Entries with index 0 <= i < sorted are sorted by name. New 74 * entries are appended to the list unsorted, and are sorted 75 * only when required; thus we avoid the need to sort the list 76 * after the addition of every reference. 77 */ 78 int sorted; 79 80 /* A pointer to the ref_cache that contains this ref_dir. */ 81 struct ref_cache *ref_cache; 82 83 struct ref_entry **entries; 84}; 85 86/* 87 * Bit values for ref_entry::flag. REF_ISSYMREF=0x01, 88 * REF_ISPACKED=0x02, REF_ISBROKEN=0x04 and REF_BAD_NAME=0x08 are 89 * public values; see refs.h. 90 */ 91 92/* 93 * The field ref_entry->u.value.peeled of this value entry contains 94 * the correct peeled value for the reference, which might be 95 * null_sha1 if the reference is not a tag or if it is broken. 96 */ 97#define REF_KNOWS_PEELED 0x10 98 99/* ref_entry represents a directory of references */ 100#define REF_DIR 0x20 101 102/* 103 * Entry has not yet been read from disk (used only for REF_DIR 104 * entries representing loose references) 105 */ 106#define REF_INCOMPLETE 0x40 107 108/* 109 * A ref_entry represents either a reference or a "subdirectory" of 110 * references. 111 * 112 * Each directory in the reference namespace is represented by a 113 * ref_entry with (flags & REF_DIR) set and containing a subdir member 114 * that holds the entries in that directory that have been read so 115 * far. If (flags & REF_INCOMPLETE) is set, then the directory and 116 * its subdirectories haven't been read yet. REF_INCOMPLETE is only 117 * used for loose reference directories. 118 * 119 * References are represented by a ref_entry with (flags & REF_DIR) 120 * unset and a value member that describes the reference's value. The 121 * flag member is at the ref_entry level, but it is also needed to 122 * interpret the contents of the value field (in other words, a 123 * ref_value object is not very much use without the enclosing 124 * ref_entry). 125 * 126 * Reference names cannot end with slash and directories' names are 127 * always stored with a trailing slash (except for the top-level 128 * directory, which is always denoted by ""). This has two nice 129 * consequences: (1) when the entries in each subdir are sorted 130 * lexicographically by name (as they usually are), the references in 131 * a whole tree can be generated in lexicographic order by traversing 132 * the tree in left-to-right, depth-first order; (2) the names of 133 * references and subdirectories cannot conflict, and therefore the 134 * presence of an empty subdirectory does not block the creation of a 135 * similarly-named reference. (The fact that reference names with the 136 * same leading components can conflict *with each other* is a 137 * separate issue that is regulated by verify_refname_available().) 138 * 139 * Please note that the name field contains the fully-qualified 140 * reference (or subdirectory) name. Space could be saved by only 141 * storing the relative names. But that would require the full names 142 * to be generated on the fly when iterating in do_for_each_ref(), and 143 * would break callback functions, who have always been able to assume 144 * that the name strings that they are passed will not be freed during 145 * the iteration. 146 */ 147struct ref_entry { 148 unsigned char flag; /* ISSYMREF? ISPACKED? */ 149 union { 150 struct ref_value value; /* if not (flags&REF_DIR) */ 151 struct ref_dir subdir; /* if (flags&REF_DIR) */ 152 } u; 153 /* 154 * The full name of the reference (e.g., "refs/heads/master") 155 * or the full name of the directory with a trailing slash 156 * (e.g., "refs/heads/"): 157 */ 158 char name[FLEX_ARRAY]; 159}; 160 161static void read_loose_refs(const char *dirname, struct ref_dir *dir); 162static int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len); 163static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache, 164 const char *dirname, size_t len, 165 int incomplete); 166static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry); 167 168static struct ref_dir *get_ref_dir(struct ref_entry *entry) 169{ 170 struct ref_dir *dir; 171 assert(entry->flag & REF_DIR); 172 dir = &entry->u.subdir; 173 if (entry->flag & REF_INCOMPLETE) { 174 read_loose_refs(entry->name, dir); 175 176 /* 177 * Manually add refs/bisect, which, being 178 * per-worktree, might not appear in the directory 179 * listing for refs/ in the main repo. 180 */ 181 if (!strcmp(entry->name, "refs/")) { 182 int pos = search_ref_dir(dir, "refs/bisect/", 12); 183 if (pos < 0) { 184 struct ref_entry *child_entry; 185 child_entry = create_dir_entry(dir->ref_cache, 186 "refs/bisect/", 187 12, 1); 188 add_entry_to_dir(dir, child_entry); 189 read_loose_refs("refs/bisect", 190 &child_entry->u.subdir); 191 } 192 } 193 entry->flag &= ~REF_INCOMPLETE; 194 } 195 return dir; 196} 197 198static struct ref_entry *create_ref_entry(const char *refname, 199 const unsigned char *sha1, int flag, 200 int check_name) 201{ 202 int len; 203 struct ref_entry *ref; 204 205 if (check_name && 206 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) 207 die("Reference has invalid format: '%s'", refname); 208 len = strlen(refname) + 1; 209 ref = xmalloc(sizeof(struct ref_entry) + len); 210 hashcpy(ref->u.value.oid.hash, sha1); 211 oidclr(&ref->u.value.peeled); 212 memcpy(ref->name, refname, len); 213 ref->flag = flag; 214 return ref; 215} 216 217static void clear_ref_dir(struct ref_dir *dir); 218 219static void free_ref_entry(struct ref_entry *entry) 220{ 221 if (entry->flag & REF_DIR) { 222 /* 223 * Do not use get_ref_dir() here, as that might 224 * trigger the reading of loose refs. 225 */ 226 clear_ref_dir(&entry->u.subdir); 227 } 228 free(entry); 229} 230 231/* 232 * Add a ref_entry to the end of dir (unsorted). Entry is always 233 * stored directly in dir; no recursion into subdirectories is 234 * done. 235 */ 236static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry) 237{ 238 ALLOC_GROW(dir->entries, dir->nr + 1, dir->alloc); 239 dir->entries[dir->nr++] = entry; 240 /* optimize for the case that entries are added in order */ 241 if (dir->nr == 1 || 242 (dir->nr == dir->sorted + 1 && 243 strcmp(dir->entries[dir->nr - 2]->name, 244 dir->entries[dir->nr - 1]->name) < 0)) 245 dir->sorted = dir->nr; 246} 247 248/* 249 * Clear and free all entries in dir, recursively. 250 */ 251static void clear_ref_dir(struct ref_dir *dir) 252{ 253 int i; 254 for (i = 0; i < dir->nr; i++) 255 free_ref_entry(dir->entries[i]); 256 free(dir->entries); 257 dir->sorted = dir->nr = dir->alloc = 0; 258 dir->entries = NULL; 259} 260 261/* 262 * Create a struct ref_entry object for the specified dirname. 263 * dirname is the name of the directory with a trailing slash (e.g., 264 * "refs/heads/") or "" for the top-level directory. 265 */ 266static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache, 267 const char *dirname, size_t len, 268 int incomplete) 269{ 270 struct ref_entry *direntry; 271 direntry = xcalloc(1, sizeof(struct ref_entry) + len + 1); 272 memcpy(direntry->name, dirname, len); 273 direntry->name[len] = '\0'; 274 direntry->u.subdir.ref_cache = ref_cache; 275 direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE : 0); 276 return direntry; 277} 278 279static int ref_entry_cmp(const void *a, const void *b) 280{ 281 struct ref_entry *one = *(struct ref_entry **)a; 282 struct ref_entry *two = *(struct ref_entry **)b; 283 return strcmp(one->name, two->name); 284} 285 286static void sort_ref_dir(struct ref_dir *dir); 287 288struct string_slice { 289 size_t len; 290 const char *str; 291}; 292 293static int ref_entry_cmp_sslice(const void *key_, const void *ent_) 294{ 295 const struct string_slice *key = key_; 296 const struct ref_entry *ent = *(const struct ref_entry * const *)ent_; 297 int cmp = strncmp(key->str, ent->name, key->len); 298 if (cmp) 299 return cmp; 300 return '\0' - (unsigned char)ent->name[key->len]; 301} 302 303/* 304 * Return the index of the entry with the given refname from the 305 * ref_dir (non-recursively), sorting dir if necessary. Return -1 if 306 * no such entry is found. dir must already be complete. 307 */ 308static int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len) 309{ 310 struct ref_entry **r; 311 struct string_slice key; 312 313 if (refname == NULL || !dir->nr) 314 return -1; 315 316 sort_ref_dir(dir); 317 key.len = len; 318 key.str = refname; 319 r = bsearch(&key, dir->entries, dir->nr, sizeof(*dir->entries), 320 ref_entry_cmp_sslice); 321 322 if (r == NULL) 323 return -1; 324 325 return r - dir->entries; 326} 327 328/* 329 * Search for a directory entry directly within dir (without 330 * recursing). Sort dir if necessary. subdirname must be a directory 331 * name (i.e., end in '/'). If mkdir is set, then create the 332 * directory if it is missing; otherwise, return NULL if the desired 333 * directory cannot be found. dir must already be complete. 334 */ 335static struct ref_dir *search_for_subdir(struct ref_dir *dir, 336 const char *subdirname, size_t len, 337 int mkdir) 338{ 339 int entry_index = search_ref_dir(dir, subdirname, len); 340 struct ref_entry *entry; 341 if (entry_index == -1) { 342 if (!mkdir) 343 return NULL; 344 /* 345 * Since dir is complete, the absence of a subdir 346 * means that the subdir really doesn't exist; 347 * therefore, create an empty record for it but mark 348 * the record complete. 349 */ 350 entry = create_dir_entry(dir->ref_cache, subdirname, len, 0); 351 add_entry_to_dir(dir, entry); 352 } else { 353 entry = dir->entries[entry_index]; 354 } 355 return get_ref_dir(entry); 356} 357 358/* 359 * If refname is a reference name, find the ref_dir within the dir 360 * tree that should hold refname. If refname is a directory name 361 * (i.e., ends in '/'), then return that ref_dir itself. dir must 362 * represent the top-level directory and must already be complete. 363 * Sort ref_dirs and recurse into subdirectories as necessary. If 364 * mkdir is set, then create any missing directories; otherwise, 365 * return NULL if the desired directory cannot be found. 366 */ 367static struct ref_dir *find_containing_dir(struct ref_dir *dir, 368 const char *refname, int mkdir) 369{ 370 const char *slash; 371 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) { 372 size_t dirnamelen = slash - refname + 1; 373 struct ref_dir *subdir; 374 subdir = search_for_subdir(dir, refname, dirnamelen, mkdir); 375 if (!subdir) { 376 dir = NULL; 377 break; 378 } 379 dir = subdir; 380 } 381 382 return dir; 383} 384 385/* 386 * Find the value entry with the given name in dir, sorting ref_dirs 387 * and recursing into subdirectories as necessary. If the name is not 388 * found or it corresponds to a directory entry, return NULL. 389 */ 390static struct ref_entry *find_ref(struct ref_dir *dir, const char *refname) 391{ 392 int entry_index; 393 struct ref_entry *entry; 394 dir = find_containing_dir(dir, refname, 0); 395 if (!dir) 396 return NULL; 397 entry_index = search_ref_dir(dir, refname, strlen(refname)); 398 if (entry_index == -1) 399 return NULL; 400 entry = dir->entries[entry_index]; 401 return (entry->flag & REF_DIR) ? NULL : entry; 402} 403 404/* 405 * Remove the entry with the given name from dir, recursing into 406 * subdirectories as necessary. If refname is the name of a directory 407 * (i.e., ends with '/'), then remove the directory and its contents. 408 * If the removal was successful, return the number of entries 409 * remaining in the directory entry that contained the deleted entry. 410 * If the name was not found, return -1. Please note that this 411 * function only deletes the entry from the cache; it does not delete 412 * it from the filesystem or ensure that other cache entries (which 413 * might be symbolic references to the removed entry) are updated. 414 * Nor does it remove any containing dir entries that might be made 415 * empty by the removal. dir must represent the top-level directory 416 * and must already be complete. 417 */ 418static int remove_entry(struct ref_dir *dir, const char *refname) 419{ 420 int refname_len = strlen(refname); 421 int entry_index; 422 struct ref_entry *entry; 423 int is_dir = refname[refname_len - 1] == '/'; 424 if (is_dir) { 425 /* 426 * refname represents a reference directory. Remove 427 * the trailing slash; otherwise we will get the 428 * directory *representing* refname rather than the 429 * one *containing* it. 430 */ 431 char *dirname = xmemdupz(refname, refname_len - 1); 432 dir = find_containing_dir(dir, dirname, 0); 433 free(dirname); 434 } else { 435 dir = find_containing_dir(dir, refname, 0); 436 } 437 if (!dir) 438 return -1; 439 entry_index = search_ref_dir(dir, refname, refname_len); 440 if (entry_index == -1) 441 return -1; 442 entry = dir->entries[entry_index]; 443 444 memmove(&dir->entries[entry_index], 445 &dir->entries[entry_index + 1], 446 (dir->nr - entry_index - 1) * sizeof(*dir->entries) 447 ); 448 dir->nr--; 449 if (dir->sorted > entry_index) 450 dir->sorted--; 451 free_ref_entry(entry); 452 return dir->nr; 453} 454 455/* 456 * Add a ref_entry to the ref_dir (unsorted), recursing into 457 * subdirectories as necessary. dir must represent the top-level 458 * directory. Return 0 on success. 459 */ 460static int add_ref(struct ref_dir *dir, struct ref_entry *ref) 461{ 462 dir = find_containing_dir(dir, ref->name, 1); 463 if (!dir) 464 return -1; 465 add_entry_to_dir(dir, ref); 466 return 0; 467} 468 469/* 470 * Emit a warning and return true iff ref1 and ref2 have the same name 471 * and the same sha1. Die if they have the same name but different 472 * sha1s. 473 */ 474static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2) 475{ 476 if (strcmp(ref1->name, ref2->name)) 477 return 0; 478 479 /* Duplicate name; make sure that they don't conflict: */ 480 481 if ((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR)) 482 /* This is impossible by construction */ 483 die("Reference directory conflict: %s", ref1->name); 484 485 if (oidcmp(&ref1->u.value.oid, &ref2->u.value.oid)) 486 die("Duplicated ref, and SHA1s don't match: %s", ref1->name); 487 488 warning("Duplicated ref: %s", ref1->name); 489 return 1; 490} 491 492/* 493 * Sort the entries in dir non-recursively (if they are not already 494 * sorted) and remove any duplicate entries. 495 */ 496static void sort_ref_dir(struct ref_dir *dir) 497{ 498 int i, j; 499 struct ref_entry *last = NULL; 500 501 /* 502 * This check also prevents passing a zero-length array to qsort(), 503 * which is a problem on some platforms. 504 */ 505 if (dir->sorted == dir->nr) 506 return; 507 508 qsort(dir->entries, dir->nr, sizeof(*dir->entries), ref_entry_cmp); 509 510 /* Remove any duplicates: */ 511 for (i = 0, j = 0; j < dir->nr; j++) { 512 struct ref_entry *entry = dir->entries[j]; 513 if (last && is_dup_ref(last, entry)) 514 free_ref_entry(entry); 515 else 516 last = dir->entries[i++] = entry; 517 } 518 dir->sorted = dir->nr = i; 519} 520 521/* Include broken references in a do_for_each_ref*() iteration: */ 522#define DO_FOR_EACH_INCLUDE_BROKEN 0x01 523 524/* 525 * Return true iff the reference described by entry can be resolved to 526 * an object in the database. Emit a warning if the referred-to 527 * object does not exist. 528 */ 529static int ref_resolves_to_object(struct ref_entry *entry) 530{ 531 if (entry->flag & REF_ISBROKEN) 532 return 0; 533 if (!has_sha1_file(entry->u.value.oid.hash)) { 534 error("%s does not point to a valid object!", entry->name); 535 return 0; 536 } 537 return 1; 538} 539 540/* 541 * current_ref is a performance hack: when iterating over references 542 * using the for_each_ref*() functions, current_ref is set to the 543 * current reference's entry before calling the callback function. If 544 * the callback function calls peel_ref(), then peel_ref() first 545 * checks whether the reference to be peeled is the current reference 546 * (it usually is) and if so, returns that reference's peeled version 547 * if it is available. This avoids a refname lookup in a common case. 548 */ 549static struct ref_entry *current_ref; 550 551typedef int each_ref_entry_fn(struct ref_entry *entry, void *cb_data); 552 553struct ref_entry_cb { 554 const char *base; 555 int trim; 556 int flags; 557 each_ref_fn *fn; 558 void *cb_data; 559}; 560 561/* 562 * Handle one reference in a do_for_each_ref*()-style iteration, 563 * calling an each_ref_fn for each entry. 564 */ 565static int do_one_ref(struct ref_entry *entry, void *cb_data) 566{ 567 struct ref_entry_cb *data = cb_data; 568 struct ref_entry *old_current_ref; 569 int retval; 570 571 if (!starts_with(entry->name, data->base)) 572 return 0; 573 574 if (!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 575 !ref_resolves_to_object(entry)) 576 return 0; 577 578 /* Store the old value, in case this is a recursive call: */ 579 old_current_ref = current_ref; 580 current_ref = entry; 581 retval = data->fn(entry->name + data->trim, &entry->u.value.oid, 582 entry->flag, data->cb_data); 583 current_ref = old_current_ref; 584 return retval; 585} 586 587/* 588 * Call fn for each reference in dir that has index in the range 589 * offset <= index < dir->nr. Recurse into subdirectories that are in 590 * that index range, sorting them before iterating. This function 591 * does not sort dir itself; it should be sorted beforehand. fn is 592 * called for all references, including broken ones. 593 */ 594static int do_for_each_entry_in_dir(struct ref_dir *dir, int offset, 595 each_ref_entry_fn fn, void *cb_data) 596{ 597 int i; 598 assert(dir->sorted == dir->nr); 599 for (i = offset; i < dir->nr; i++) { 600 struct ref_entry *entry = dir->entries[i]; 601 int retval; 602 if (entry->flag & REF_DIR) { 603 struct ref_dir *subdir = get_ref_dir(entry); 604 sort_ref_dir(subdir); 605 retval = do_for_each_entry_in_dir(subdir, 0, fn, cb_data); 606 } else { 607 retval = fn(entry, cb_data); 608 } 609 if (retval) 610 return retval; 611 } 612 return 0; 613} 614 615/* 616 * Call fn for each reference in the union of dir1 and dir2, in order 617 * by refname. Recurse into subdirectories. If a value entry appears 618 * in both dir1 and dir2, then only process the version that is in 619 * dir2. The input dirs must already be sorted, but subdirs will be 620 * sorted as needed. fn is called for all references, including 621 * broken ones. 622 */ 623static int do_for_each_entry_in_dirs(struct ref_dir *dir1, 624 struct ref_dir *dir2, 625 each_ref_entry_fn fn, void *cb_data) 626{ 627 int retval; 628 int i1 = 0, i2 = 0; 629 630 assert(dir1->sorted == dir1->nr); 631 assert(dir2->sorted == dir2->nr); 632 while (1) { 633 struct ref_entry *e1, *e2; 634 int cmp; 635 if (i1 == dir1->nr) { 636 return do_for_each_entry_in_dir(dir2, i2, fn, cb_data); 637 } 638 if (i2 == dir2->nr) { 639 return do_for_each_entry_in_dir(dir1, i1, fn, cb_data); 640 } 641 e1 = dir1->entries[i1]; 642 e2 = dir2->entries[i2]; 643 cmp = strcmp(e1->name, e2->name); 644 if (cmp == 0) { 645 if ((e1->flag & REF_DIR) && (e2->flag & REF_DIR)) { 646 /* Both are directories; descend them in parallel. */ 647 struct ref_dir *subdir1 = get_ref_dir(e1); 648 struct ref_dir *subdir2 = get_ref_dir(e2); 649 sort_ref_dir(subdir1); 650 sort_ref_dir(subdir2); 651 retval = do_for_each_entry_in_dirs( 652 subdir1, subdir2, fn, cb_data); 653 i1++; 654 i2++; 655 } else if (!(e1->flag & REF_DIR) && !(e2->flag & REF_DIR)) { 656 /* Both are references; ignore the one from dir1. */ 657 retval = fn(e2, cb_data); 658 i1++; 659 i2++; 660 } else { 661 die("conflict between reference and directory: %s", 662 e1->name); 663 } 664 } else { 665 struct ref_entry *e; 666 if (cmp < 0) { 667 e = e1; 668 i1++; 669 } else { 670 e = e2; 671 i2++; 672 } 673 if (e->flag & REF_DIR) { 674 struct ref_dir *subdir = get_ref_dir(e); 675 sort_ref_dir(subdir); 676 retval = do_for_each_entry_in_dir( 677 subdir, 0, fn, cb_data); 678 } else { 679 retval = fn(e, cb_data); 680 } 681 } 682 if (retval) 683 return retval; 684 } 685} 686 687/* 688 * Load all of the refs from the dir into our in-memory cache. The hard work 689 * of loading loose refs is done by get_ref_dir(), so we just need to recurse 690 * through all of the sub-directories. We do not even need to care about 691 * sorting, as traversal order does not matter to us. 692 */ 693static void prime_ref_dir(struct ref_dir *dir) 694{ 695 int i; 696 for (i = 0; i < dir->nr; i++) { 697 struct ref_entry *entry = dir->entries[i]; 698 if (entry->flag & REF_DIR) 699 prime_ref_dir(get_ref_dir(entry)); 700 } 701} 702 703struct nonmatching_ref_data { 704 const struct string_list *skip; 705 const char *conflicting_refname; 706}; 707 708static int nonmatching_ref_fn(struct ref_entry *entry, void *vdata) 709{ 710 struct nonmatching_ref_data *data = vdata; 711 712 if (data->skip && string_list_has_string(data->skip, entry->name)) 713 return 0; 714 715 data->conflicting_refname = entry->name; 716 return 1; 717} 718 719/* 720 * Return 0 if a reference named refname could be created without 721 * conflicting with the name of an existing reference in dir. 722 * See verify_refname_available for more information. 723 */ 724static int verify_refname_available_dir(const char *refname, 725 const struct string_list *extras, 726 const struct string_list *skip, 727 struct ref_dir *dir, 728 struct strbuf *err) 729{ 730 const char *slash; 731 int pos; 732 struct strbuf dirname = STRBUF_INIT; 733 int ret = -1; 734 735 /* 736 * For the sake of comments in this function, suppose that 737 * refname is "refs/foo/bar". 738 */ 739 740 assert(err); 741 742 strbuf_grow(&dirname, strlen(refname) + 1); 743 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) { 744 /* Expand dirname to the new prefix, not including the trailing slash: */ 745 strbuf_add(&dirname, refname + dirname.len, slash - refname - dirname.len); 746 747 /* 748 * We are still at a leading dir of the refname (e.g., 749 * "refs/foo"; if there is a reference with that name, 750 * it is a conflict, *unless* it is in skip. 751 */ 752 if (dir) { 753 pos = search_ref_dir(dir, dirname.buf, dirname.len); 754 if (pos >= 0 && 755 (!skip || !string_list_has_string(skip, dirname.buf))) { 756 /* 757 * We found a reference whose name is 758 * a proper prefix of refname; e.g., 759 * "refs/foo", and is not in skip. 760 */ 761 strbuf_addf(err, "'%s' exists; cannot create '%s'", 762 dirname.buf, refname); 763 goto cleanup; 764 } 765 } 766 767 if (extras && string_list_has_string(extras, dirname.buf) && 768 (!skip || !string_list_has_string(skip, dirname.buf))) { 769 strbuf_addf(err, "cannot process '%s' and '%s' at the same time", 770 refname, dirname.buf); 771 goto cleanup; 772 } 773 774 /* 775 * Otherwise, we can try to continue our search with 776 * the next component. So try to look up the 777 * directory, e.g., "refs/foo/". If we come up empty, 778 * we know there is nothing under this whole prefix, 779 * but even in that case we still have to continue the 780 * search for conflicts with extras. 781 */ 782 strbuf_addch(&dirname, '/'); 783 if (dir) { 784 pos = search_ref_dir(dir, dirname.buf, dirname.len); 785 if (pos < 0) { 786 /* 787 * There was no directory "refs/foo/", 788 * so there is nothing under this 789 * whole prefix. So there is no need 790 * to continue looking for conflicting 791 * references. But we need to continue 792 * looking for conflicting extras. 793 */ 794 dir = NULL; 795 } else { 796 dir = get_ref_dir(dir->entries[pos]); 797 } 798 } 799 } 800 801 /* 802 * We are at the leaf of our refname (e.g., "refs/foo/bar"). 803 * There is no point in searching for a reference with that 804 * name, because a refname isn't considered to conflict with 805 * itself. But we still need to check for references whose 806 * names are in the "refs/foo/bar/" namespace, because they 807 * *do* conflict. 808 */ 809 strbuf_addstr(&dirname, refname + dirname.len); 810 strbuf_addch(&dirname, '/'); 811 812 if (dir) { 813 pos = search_ref_dir(dir, dirname.buf, dirname.len); 814 815 if (pos >= 0) { 816 /* 817 * We found a directory named "$refname/" 818 * (e.g., "refs/foo/bar/"). It is a problem 819 * iff it contains any ref that is not in 820 * "skip". 821 */ 822 struct nonmatching_ref_data data; 823 824 data.skip = skip; 825 data.conflicting_refname = NULL; 826 dir = get_ref_dir(dir->entries[pos]); 827 sort_ref_dir(dir); 828 if (do_for_each_entry_in_dir(dir, 0, nonmatching_ref_fn, &data)) { 829 strbuf_addf(err, "'%s' exists; cannot create '%s'", 830 data.conflicting_refname, refname); 831 goto cleanup; 832 } 833 } 834 } 835 836 if (extras) { 837 /* 838 * Check for entries in extras that start with 839 * "$refname/". We do that by looking for the place 840 * where "$refname/" would be inserted in extras. If 841 * there is an entry at that position that starts with 842 * "$refname/" and is not in skip, then we have a 843 * conflict. 844 */ 845 for (pos = string_list_find_insert_index(extras, dirname.buf, 0); 846 pos < extras->nr; pos++) { 847 const char *extra_refname = extras->items[pos].string; 848 849 if (!starts_with(extra_refname, dirname.buf)) 850 break; 851 852 if (!skip || !string_list_has_string(skip, extra_refname)) { 853 strbuf_addf(err, "cannot process '%s' and '%s' at the same time", 854 refname, extra_refname); 855 goto cleanup; 856 } 857 } 858 } 859 860 /* No conflicts were found */ 861 ret = 0; 862 863cleanup: 864 strbuf_release(&dirname); 865 return ret; 866} 867 868struct packed_ref_cache { 869 struct ref_entry *root; 870 871 /* 872 * Count of references to the data structure in this instance, 873 * including the pointer from ref_cache::packed if any. The 874 * data will not be freed as long as the reference count is 875 * nonzero. 876 */ 877 unsigned int referrers; 878 879 /* 880 * Iff the packed-refs file associated with this instance is 881 * currently locked for writing, this points at the associated 882 * lock (which is owned by somebody else). The referrer count 883 * is also incremented when the file is locked and decremented 884 * when it is unlocked. 885 */ 886 struct lock_file *lock; 887 888 /* The metadata from when this packed-refs cache was read */ 889 struct stat_validity validity; 890}; 891 892/* 893 * Future: need to be in "struct repository" 894 * when doing a full libification. 895 */ 896static struct ref_cache { 897 struct ref_cache *next; 898 struct ref_entry *loose; 899 struct packed_ref_cache *packed; 900 /* 901 * The submodule name, or "" for the main repo. We allocate 902 * length 1 rather than FLEX_ARRAY so that the main ref_cache 903 * is initialized correctly. 904 */ 905 char name[1]; 906} ref_cache, *submodule_ref_caches; 907 908/* Lock used for the main packed-refs file: */ 909static struct lock_file packlock; 910 911/* 912 * Increment the reference count of *packed_refs. 913 */ 914static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs) 915{ 916 packed_refs->referrers++; 917} 918 919/* 920 * Decrease the reference count of *packed_refs. If it goes to zero, 921 * free *packed_refs and return true; otherwise return false. 922 */ 923static int release_packed_ref_cache(struct packed_ref_cache *packed_refs) 924{ 925 if (!--packed_refs->referrers) { 926 free_ref_entry(packed_refs->root); 927 stat_validity_clear(&packed_refs->validity); 928 free(packed_refs); 929 return 1; 930 } else { 931 return 0; 932 } 933} 934 935static void clear_packed_ref_cache(struct ref_cache *refs) 936{ 937 if (refs->packed) { 938 struct packed_ref_cache *packed_refs = refs->packed; 939 940 if (packed_refs->lock) 941 die("internal error: packed-ref cache cleared while locked"); 942 refs->packed = NULL; 943 release_packed_ref_cache(packed_refs); 944 } 945} 946 947static void clear_loose_ref_cache(struct ref_cache *refs) 948{ 949 if (refs->loose) { 950 free_ref_entry(refs->loose); 951 refs->loose = NULL; 952 } 953} 954 955static struct ref_cache *create_ref_cache(const char *submodule) 956{ 957 int len; 958 struct ref_cache *refs; 959 if (!submodule) 960 submodule = ""; 961 len = strlen(submodule) + 1; 962 refs = xcalloc(1, sizeof(struct ref_cache) + len); 963 memcpy(refs->name, submodule, len); 964 return refs; 965} 966 967/* 968 * Return a pointer to a ref_cache for the specified submodule. For 969 * the main repository, use submodule==NULL. The returned structure 970 * will be allocated and initialized but not necessarily populated; it 971 * should not be freed. 972 */ 973static struct ref_cache *get_ref_cache(const char *submodule) 974{ 975 struct ref_cache *refs; 976 977 if (!submodule || !*submodule) 978 return &ref_cache; 979 980 for (refs = submodule_ref_caches; refs; refs = refs->next) 981 if (!strcmp(submodule, refs->name)) 982 return refs; 983 984 refs = create_ref_cache(submodule); 985 refs->next = submodule_ref_caches; 986 submodule_ref_caches = refs; 987 return refs; 988} 989 990/* The length of a peeled reference line in packed-refs, including EOL: */ 991#define PEELED_LINE_LENGTH 42 992 993/* 994 * The packed-refs header line that we write out. Perhaps other 995 * traits will be added later. The trailing space is required. 996 */ 997static const char PACKED_REFS_HEADER[] = 998 "# pack-refs with: peeled fully-peeled \n"; 9991000/*1001 * Parse one line from a packed-refs file. Write the SHA1 to sha1.1002 * Return a pointer to the refname within the line (null-terminated),1003 * or NULL if there was a problem.1004 */1005static const char *parse_ref_line(struct strbuf *line, unsigned char *sha1)1006{1007 const char *ref;10081009 /*1010 * 42: the answer to everything.1011 *1012 * In this case, it happens to be the answer to1013 * 40 (length of sha1 hex representation)1014 * +1 (space in between hex and name)1015 * +1 (newline at the end of the line)1016 */1017 if (line->len <= 42)1018 return NULL;10191020 if (get_sha1_hex(line->buf, sha1) < 0)1021 return NULL;1022 if (!isspace(line->buf[40]))1023 return NULL;10241025 ref = line->buf + 41;1026 if (isspace(*ref))1027 return NULL;10281029 if (line->buf[line->len - 1] != '\n')1030 return NULL;1031 line->buf[--line->len] = 0;10321033 return ref;1034}10351036/*1037 * Read f, which is a packed-refs file, into dir.1038 *1039 * A comment line of the form "# pack-refs with: " may contain zero or1040 * more traits. We interpret the traits as follows:1041 *1042 * No traits:1043 *1044 * Probably no references are peeled. But if the file contains a1045 * peeled value for a reference, we will use it.1046 *1047 * peeled:1048 *1049 * References under "refs/tags/", if they *can* be peeled, *are*1050 * peeled in this file. References outside of "refs/tags/" are1051 * probably not peeled even if they could have been, but if we find1052 * a peeled value for such a reference we will use it.1053 *1054 * fully-peeled:1055 *1056 * All references in the file that can be peeled are peeled.1057 * Inversely (and this is more important), any references in the1058 * file for which no peeled value is recorded is not peelable. This1059 * trait should typically be written alongside "peeled" for1060 * compatibility with older clients, but we do not require it1061 * (i.e., "peeled" is a no-op if "fully-peeled" is set).1062 */1063static void read_packed_refs(FILE *f, struct ref_dir *dir)1064{1065 struct ref_entry *last = NULL;1066 struct strbuf line = STRBUF_INIT;1067 enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;10681069 while (strbuf_getwholeline(&line, f, '\n') != EOF) {1070 unsigned char sha1[20];1071 const char *refname;1072 const char *traits;10731074 if (skip_prefix(line.buf, "# pack-refs with:", &traits)) {1075 if (strstr(traits, " fully-peeled "))1076 peeled = PEELED_FULLY;1077 else if (strstr(traits, " peeled "))1078 peeled = PEELED_TAGS;1079 /* perhaps other traits later as well */1080 continue;1081 }10821083 refname = parse_ref_line(&line, sha1);1084 if (refname) {1085 int flag = REF_ISPACKED;10861087 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {1088 if (!refname_is_safe(refname))1089 die("packed refname is dangerous: %s", refname);1090 hashclr(sha1);1091 flag |= REF_BAD_NAME | REF_ISBROKEN;1092 }1093 last = create_ref_entry(refname, sha1, flag, 0);1094 if (peeled == PEELED_FULLY ||1095 (peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))1096 last->flag |= REF_KNOWS_PEELED;1097 add_ref(dir, last);1098 continue;1099 }1100 if (last &&1101 line.buf[0] == '^' &&1102 line.len == PEELED_LINE_LENGTH &&1103 line.buf[PEELED_LINE_LENGTH - 1] == '\n' &&1104 !get_sha1_hex(line.buf + 1, sha1)) {1105 hashcpy(last->u.value.peeled.hash, sha1);1106 /*1107 * Regardless of what the file header said,1108 * we definitely know the value of *this*1109 * reference:1110 */1111 last->flag |= REF_KNOWS_PEELED;1112 }1113 }11141115 strbuf_release(&line);1116}11171118/*1119 * Get the packed_ref_cache for the specified ref_cache, creating it1120 * if necessary.1121 */1122static struct packed_ref_cache *get_packed_ref_cache(struct ref_cache *refs)1123{1124 char *packed_refs_file;11251126 if (*refs->name)1127 packed_refs_file = git_pathdup_submodule(refs->name, "packed-refs");1128 else1129 packed_refs_file = git_pathdup("packed-refs");11301131 if (refs->packed &&1132 !stat_validity_check(&refs->packed->validity, packed_refs_file))1133 clear_packed_ref_cache(refs);11341135 if (!refs->packed) {1136 FILE *f;11371138 refs->packed = xcalloc(1, sizeof(*refs->packed));1139 acquire_packed_ref_cache(refs->packed);1140 refs->packed->root = create_dir_entry(refs, "", 0, 0);1141 f = fopen(packed_refs_file, "r");1142 if (f) {1143 stat_validity_update(&refs->packed->validity, fileno(f));1144 read_packed_refs(f, get_ref_dir(refs->packed->root));1145 fclose(f);1146 }1147 }1148 free(packed_refs_file);1149 return refs->packed;1150}11511152static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)1153{1154 return get_ref_dir(packed_ref_cache->root);1155}11561157static struct ref_dir *get_packed_refs(struct ref_cache *refs)1158{1159 return get_packed_ref_dir(get_packed_ref_cache(refs));1160}11611162/*1163 * Add a reference to the in-memory packed reference cache. This may1164 * only be called while the packed-refs file is locked (see1165 * lock_packed_refs()). To actually write the packed-refs file, call1166 * commit_packed_refs().1167 */1168static void add_packed_ref(const char *refname, const unsigned char *sha1)1169{1170 struct packed_ref_cache *packed_ref_cache =1171 get_packed_ref_cache(&ref_cache);11721173 if (!packed_ref_cache->lock)1174 die("internal error: packed refs not locked");1175 add_ref(get_packed_ref_dir(packed_ref_cache),1176 create_ref_entry(refname, sha1, REF_ISPACKED, 1));1177}11781179/*1180 * Read the loose references from the namespace dirname into dir1181 * (without recursing). dirname must end with '/'. dir must be the1182 * directory entry corresponding to dirname.1183 */1184static void read_loose_refs(const char *dirname, struct ref_dir *dir)1185{1186 struct ref_cache *refs = dir->ref_cache;1187 DIR *d;1188 struct dirent *de;1189 int dirnamelen = strlen(dirname);1190 struct strbuf refname;1191 struct strbuf path = STRBUF_INIT;1192 size_t path_baselen;11931194 if (*refs->name)1195 strbuf_git_path_submodule(&path, refs->name, "%s", dirname);1196 else1197 strbuf_git_path(&path, "%s", dirname);1198 path_baselen = path.len;11991200 d = opendir(path.buf);1201 if (!d) {1202 strbuf_release(&path);1203 return;1204 }12051206 strbuf_init(&refname, dirnamelen + 257);1207 strbuf_add(&refname, dirname, dirnamelen);12081209 while ((de = readdir(d)) != NULL) {1210 unsigned char sha1[20];1211 struct stat st;1212 int flag;12131214 if (de->d_name[0] == '.')1215 continue;1216 if (ends_with(de->d_name, ".lock"))1217 continue;1218 strbuf_addstr(&refname, de->d_name);1219 strbuf_addstr(&path, de->d_name);1220 if (stat(path.buf, &st) < 0) {1221 ; /* silently ignore */1222 } else if (S_ISDIR(st.st_mode)) {1223 strbuf_addch(&refname, '/');1224 add_entry_to_dir(dir,1225 create_dir_entry(refs, refname.buf,1226 refname.len, 1));1227 } else {1228 int read_ok;12291230 if (*refs->name) {1231 hashclr(sha1);1232 flag = 0;1233 read_ok = !resolve_gitlink_ref(refs->name,1234 refname.buf, sha1);1235 } else {1236 read_ok = !read_ref_full(refname.buf,1237 RESOLVE_REF_READING,1238 sha1, &flag);1239 }12401241 if (!read_ok) {1242 hashclr(sha1);1243 flag |= REF_ISBROKEN;1244 } else if (is_null_sha1(sha1)) {1245 /*1246 * It is so astronomically unlikely1247 * that NULL_SHA1 is the SHA-1 of an1248 * actual object that we consider its1249 * appearance in a loose reference1250 * file to be repo corruption1251 * (probably due to a software bug).1252 */1253 flag |= REF_ISBROKEN;1254 }12551256 if (check_refname_format(refname.buf,1257 REFNAME_ALLOW_ONELEVEL)) {1258 if (!refname_is_safe(refname.buf))1259 die("loose refname is dangerous: %s", refname.buf);1260 hashclr(sha1);1261 flag |= REF_BAD_NAME | REF_ISBROKEN;1262 }1263 add_entry_to_dir(dir,1264 create_ref_entry(refname.buf, sha1, flag, 0));1265 }1266 strbuf_setlen(&refname, dirnamelen);1267 strbuf_setlen(&path, path_baselen);1268 }1269 strbuf_release(&refname);1270 strbuf_release(&path);1271 closedir(d);1272}12731274static struct ref_dir *get_loose_refs(struct ref_cache *refs)1275{1276 if (!refs->loose) {1277 /*1278 * Mark the top-level directory complete because we1279 * are about to read the only subdirectory that can1280 * hold references:1281 */1282 refs->loose = create_dir_entry(refs, "", 0, 0);1283 /*1284 * Create an incomplete entry for "refs/":1285 */1286 add_entry_to_dir(get_ref_dir(refs->loose),1287 create_dir_entry(refs, "refs/", 5, 1));1288 }1289 return get_ref_dir(refs->loose);1290}12911292/* We allow "recursive" symbolic refs. Only within reason, though */1293#define MAXDEPTH 51294#define MAXREFLEN (1024)12951296/*1297 * Called by resolve_gitlink_ref_recursive() after it failed to read1298 * from the loose refs in ref_cache refs. Find <refname> in the1299 * packed-refs file for the submodule.1300 */1301static int resolve_gitlink_packed_ref(struct ref_cache *refs,1302 const char *refname, unsigned char *sha1)1303{1304 struct ref_entry *ref;1305 struct ref_dir *dir = get_packed_refs(refs);13061307 ref = find_ref(dir, refname);1308 if (ref == NULL)1309 return -1;13101311 hashcpy(sha1, ref->u.value.oid.hash);1312 return 0;1313}13141315static int resolve_gitlink_ref_recursive(struct ref_cache *refs,1316 const char *refname, unsigned char *sha1,1317 int recursion)1318{1319 int fd, len;1320 char buffer[128], *p;1321 char *path;13221323 if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)1324 return -1;1325 path = *refs->name1326 ? git_pathdup_submodule(refs->name, "%s", refname)1327 : git_pathdup("%s", refname);1328 fd = open(path, O_RDONLY);1329 free(path);1330 if (fd < 0)1331 return resolve_gitlink_packed_ref(refs, refname, sha1);13321333 len = read(fd, buffer, sizeof(buffer)-1);1334 close(fd);1335 if (len < 0)1336 return -1;1337 while (len && isspace(buffer[len-1]))1338 len--;1339 buffer[len] = 0;13401341 /* Was it a detached head or an old-fashioned symlink? */1342 if (!get_sha1_hex(buffer, sha1))1343 return 0;13441345 /* Symref? */1346 if (strncmp(buffer, "ref:", 4))1347 return -1;1348 p = buffer + 4;1349 while (isspace(*p))1350 p++;13511352 return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);1353}13541355int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)1356{1357 int len = strlen(path), retval;1358 char *submodule;1359 struct ref_cache *refs;13601361 while (len && path[len-1] == '/')1362 len--;1363 if (!len)1364 return -1;1365 submodule = xstrndup(path, len);1366 refs = get_ref_cache(submodule);1367 free(submodule);13681369 retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);1370 return retval;1371}13721373/*1374 * Return the ref_entry for the given refname from the packed1375 * references. If it does not exist, return NULL.1376 */1377static struct ref_entry *get_packed_ref(const char *refname)1378{1379 return find_ref(get_packed_refs(&ref_cache), refname);1380}13811382/*1383 * A loose ref file doesn't exist; check for a packed ref. The1384 * options are forwarded from resolve_safe_unsafe().1385 */1386static int resolve_missing_loose_ref(const char *refname,1387 int resolve_flags,1388 unsigned char *sha1,1389 int *flags)1390{1391 struct ref_entry *entry;13921393 /*1394 * The loose reference file does not exist; check for a packed1395 * reference.1396 */1397 entry = get_packed_ref(refname);1398 if (entry) {1399 hashcpy(sha1, entry->u.value.oid.hash);1400 if (flags)1401 *flags |= REF_ISPACKED;1402 return 0;1403 }1404 /* The reference is not a packed reference, either. */1405 if (resolve_flags & RESOLVE_REF_READING) {1406 errno = ENOENT;1407 return -1;1408 } else {1409 hashclr(sha1);1410 return 0;1411 }1412}14131414/* This function needs to return a meaningful errno on failure */1415static const char *resolve_ref_1(const char *refname,1416 int resolve_flags,1417 unsigned char *sha1,1418 int *flags,1419 struct strbuf *sb_refname,1420 struct strbuf *sb_path,1421 struct strbuf *sb_contents)1422{1423 int depth = MAXDEPTH;1424 int bad_name = 0;14251426 if (flags)1427 *flags = 0;14281429 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {1430 if (flags)1431 *flags |= REF_BAD_NAME;14321433 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||1434 !refname_is_safe(refname)) {1435 errno = EINVAL;1436 return NULL;1437 }1438 /*1439 * dwim_ref() uses REF_ISBROKEN to distinguish between1440 * missing refs and refs that were present but invalid,1441 * to complain about the latter to stderr.1442 *1443 * We don't know whether the ref exists, so don't set1444 * REF_ISBROKEN yet.1445 */1446 bad_name = 1;1447 }1448 for (;;) {1449 const char *path;1450 struct stat st;1451 char *buf;1452 int fd;14531454 if (--depth < 0) {1455 errno = ELOOP;1456 return NULL;1457 }14581459 strbuf_reset(sb_path);1460 strbuf_git_path(sb_path, "%s", refname);1461 path = sb_path->buf;14621463 /*1464 * We might have to loop back here to avoid a race1465 * condition: first we lstat() the file, then we try1466 * to read it as a link or as a file. But if somebody1467 * changes the type of the file (file <-> directory1468 * <-> symlink) between the lstat() and reading, then1469 * we don't want to report that as an error but rather1470 * try again starting with the lstat().1471 */1472 stat_ref:1473 if (lstat(path, &st) < 0) {1474 if (errno != ENOENT)1475 return NULL;1476 if (resolve_missing_loose_ref(refname, resolve_flags,1477 sha1, flags))1478 return NULL;1479 if (bad_name) {1480 hashclr(sha1);1481 if (flags)1482 *flags |= REF_ISBROKEN;1483 }1484 return refname;1485 }14861487 /* Follow "normalized" - ie "refs/.." symlinks by hand */1488 if (S_ISLNK(st.st_mode)) {1489 strbuf_reset(sb_contents);1490 if (strbuf_readlink(sb_contents, path, 0) < 0) {1491 if (errno == ENOENT || errno == EINVAL)1492 /* inconsistent with lstat; retry */1493 goto stat_ref;1494 else1495 return NULL;1496 }1497 if (starts_with(sb_contents->buf, "refs/") &&1498 !check_refname_format(sb_contents->buf, 0)) {1499 strbuf_swap(sb_refname, sb_contents);1500 refname = sb_refname->buf;1501 if (flags)1502 *flags |= REF_ISSYMREF;1503 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {1504 hashclr(sha1);1505 return refname;1506 }1507 continue;1508 }1509 }15101511 /* Is it a directory? */1512 if (S_ISDIR(st.st_mode)) {1513 errno = EISDIR;1514 return NULL;1515 }15161517 /*1518 * Anything else, just open it and try to use it as1519 * a ref1520 */1521 fd = open(path, O_RDONLY);1522 if (fd < 0) {1523 if (errno == ENOENT)1524 /* inconsistent with lstat; retry */1525 goto stat_ref;1526 else1527 return NULL;1528 }1529 strbuf_reset(sb_contents);1530 if (strbuf_read(sb_contents, fd, 256) < 0) {1531 int save_errno = errno;1532 close(fd);1533 errno = save_errno;1534 return NULL;1535 }1536 close(fd);1537 strbuf_rtrim(sb_contents);15381539 /*1540 * Is it a symbolic ref?1541 */1542 if (!starts_with(sb_contents->buf, "ref:")) {1543 /*1544 * Please note that FETCH_HEAD has a second1545 * line containing other data.1546 */1547 if (get_sha1_hex(sb_contents->buf, sha1) ||1548 (sb_contents->buf[40] != '\0' && !isspace(sb_contents->buf[40]))) {1549 if (flags)1550 *flags |= REF_ISBROKEN;1551 errno = EINVAL;1552 return NULL;1553 }1554 if (bad_name) {1555 hashclr(sha1);1556 if (flags)1557 *flags |= REF_ISBROKEN;1558 }1559 return refname;1560 }1561 if (flags)1562 *flags |= REF_ISSYMREF;1563 buf = sb_contents->buf + 4;1564 while (isspace(*buf))1565 buf++;1566 strbuf_reset(sb_refname);1567 strbuf_addstr(sb_refname, buf);1568 refname = sb_refname->buf;1569 if (resolve_flags & RESOLVE_REF_NO_RECURSE) {1570 hashclr(sha1);1571 return refname;1572 }1573 if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {1574 if (flags)1575 *flags |= REF_ISBROKEN;15761577 if (!(resolve_flags & RESOLVE_REF_ALLOW_BAD_NAME) ||1578 !refname_is_safe(buf)) {1579 errno = EINVAL;1580 return NULL;1581 }1582 bad_name = 1;1583 }1584 }1585}15861587const char *resolve_ref_unsafe(const char *refname, int resolve_flags,1588 unsigned char *sha1, int *flags)1589{1590 static struct strbuf sb_refname = STRBUF_INIT;1591 struct strbuf sb_contents = STRBUF_INIT;1592 struct strbuf sb_path = STRBUF_INIT;1593 const char *ret;15941595 ret = resolve_ref_1(refname, resolve_flags, sha1, flags,1596 &sb_refname, &sb_path, &sb_contents);1597 strbuf_release(&sb_path);1598 strbuf_release(&sb_contents);1599 return ret;1600}16011602/*1603 * Peel the entry (if possible) and return its new peel_status. If1604 * repeel is true, re-peel the entry even if there is an old peeled1605 * value that is already stored in it.1606 *1607 * It is OK to call this function with a packed reference entry that1608 * might be stale and might even refer to an object that has since1609 * been garbage-collected. In such a case, if the entry has1610 * REF_KNOWS_PEELED then leave the status unchanged and return1611 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.1612 */1613static enum peel_status peel_entry(struct ref_entry *entry, int repeel)1614{1615 enum peel_status status;16161617 if (entry->flag & REF_KNOWS_PEELED) {1618 if (repeel) {1619 entry->flag &= ~REF_KNOWS_PEELED;1620 oidclr(&entry->u.value.peeled);1621 } else {1622 return is_null_oid(&entry->u.value.peeled) ?1623 PEEL_NON_TAG : PEEL_PEELED;1624 }1625 }1626 if (entry->flag & REF_ISBROKEN)1627 return PEEL_BROKEN;1628 if (entry->flag & REF_ISSYMREF)1629 return PEEL_IS_SYMREF;16301631 status = peel_object(entry->u.value.oid.hash, entry->u.value.peeled.hash);1632 if (status == PEEL_PEELED || status == PEEL_NON_TAG)1633 entry->flag |= REF_KNOWS_PEELED;1634 return status;1635}16361637int peel_ref(const char *refname, unsigned char *sha1)1638{1639 int flag;1640 unsigned char base[20];16411642 if (current_ref && (current_ref->name == refname1643 || !strcmp(current_ref->name, refname))) {1644 if (peel_entry(current_ref, 0))1645 return -1;1646 hashcpy(sha1, current_ref->u.value.peeled.hash);1647 return 0;1648 }16491650 if (read_ref_full(refname, RESOLVE_REF_READING, base, &flag))1651 return -1;16521653 /*1654 * If the reference is packed, read its ref_entry from the1655 * cache in the hope that we already know its peeled value.1656 * We only try this optimization on packed references because1657 * (a) forcing the filling of the loose reference cache could1658 * be expensive and (b) loose references anyway usually do not1659 * have REF_KNOWS_PEELED.1660 */1661 if (flag & REF_ISPACKED) {1662 struct ref_entry *r = get_packed_ref(refname);1663 if (r) {1664 if (peel_entry(r, 0))1665 return -1;1666 hashcpy(sha1, r->u.value.peeled.hash);1667 return 0;1668 }1669 }16701671 return peel_object(base, sha1);1672}16731674/*1675 * Call fn for each reference in the specified ref_cache, omitting1676 * references not in the containing_dir of base. fn is called for all1677 * references, including broken ones. If fn ever returns a non-zero1678 * value, stop the iteration and return that value; otherwise, return1679 * 0.1680 */1681static int do_for_each_entry(struct ref_cache *refs, const char *base,1682 each_ref_entry_fn fn, void *cb_data)1683{1684 struct packed_ref_cache *packed_ref_cache;1685 struct ref_dir *loose_dir;1686 struct ref_dir *packed_dir;1687 int retval = 0;16881689 /*1690 * We must make sure that all loose refs are read before accessing the1691 * packed-refs file; this avoids a race condition in which loose refs1692 * are migrated to the packed-refs file by a simultaneous process, but1693 * our in-memory view is from before the migration. get_packed_ref_cache()1694 * takes care of making sure our view is up to date with what is on1695 * disk.1696 */1697 loose_dir = get_loose_refs(refs);1698 if (base && *base) {1699 loose_dir = find_containing_dir(loose_dir, base, 0);1700 }1701 if (loose_dir)1702 prime_ref_dir(loose_dir);17031704 packed_ref_cache = get_packed_ref_cache(refs);1705 acquire_packed_ref_cache(packed_ref_cache);1706 packed_dir = get_packed_ref_dir(packed_ref_cache);1707 if (base && *base) {1708 packed_dir = find_containing_dir(packed_dir, base, 0);1709 }17101711 if (packed_dir && loose_dir) {1712 sort_ref_dir(packed_dir);1713 sort_ref_dir(loose_dir);1714 retval = do_for_each_entry_in_dirs(1715 packed_dir, loose_dir, fn, cb_data);1716 } else if (packed_dir) {1717 sort_ref_dir(packed_dir);1718 retval = do_for_each_entry_in_dir(1719 packed_dir, 0, fn, cb_data);1720 } else if (loose_dir) {1721 sort_ref_dir(loose_dir);1722 retval = do_for_each_entry_in_dir(1723 loose_dir, 0, fn, cb_data);1724 }17251726 release_packed_ref_cache(packed_ref_cache);1727 return retval;1728}17291730/*1731 * Call fn for each reference in the specified ref_cache for which the1732 * refname begins with base. If trim is non-zero, then trim that many1733 * characters off the beginning of each refname before passing the1734 * refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include1735 * broken references in the iteration. If fn ever returns a non-zero1736 * value, stop the iteration and return that value; otherwise, return1737 * 0.1738 */1739static int do_for_each_ref(struct ref_cache *refs, const char *base,1740 each_ref_fn fn, int trim, int flags, void *cb_data)1741{1742 struct ref_entry_cb data;1743 data.base = base;1744 data.trim = trim;1745 data.flags = flags;1746 data.fn = fn;1747 data.cb_data = cb_data;17481749 if (ref_paranoia < 0)1750 ref_paranoia = git_env_bool("GIT_REF_PARANOIA", 0);1751 if (ref_paranoia)1752 data.flags |= DO_FOR_EACH_INCLUDE_BROKEN;17531754 return do_for_each_entry(refs, base, do_one_ref, &data);1755}17561757static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)1758{1759 struct object_id oid;1760 int flag;17611762 if (submodule) {1763 if (resolve_gitlink_ref(submodule, "HEAD", oid.hash) == 0)1764 return fn("HEAD", &oid, 0, cb_data);17651766 return 0;1767 }17681769 if (!read_ref_full("HEAD", RESOLVE_REF_READING, oid.hash, &flag))1770 return fn("HEAD", &oid, flag, cb_data);17711772 return 0;1773}17741775int head_ref(each_ref_fn fn, void *cb_data)1776{1777 return do_head_ref(NULL, fn, cb_data);1778}17791780int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1781{1782 return do_head_ref(submodule, fn, cb_data);1783}17841785int for_each_ref(each_ref_fn fn, void *cb_data)1786{1787 return do_for_each_ref(&ref_cache, "", fn, 0, 0, cb_data);1788}17891790int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1791{1792 return do_for_each_ref(get_ref_cache(submodule), "", fn, 0, 0, cb_data);1793}17941795int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)1796{1797 return do_for_each_ref(&ref_cache, prefix, fn, strlen(prefix), 0, cb_data);1798}17991800int for_each_fullref_in(const char *prefix, each_ref_fn fn, void *cb_data, unsigned int broken)1801{1802 unsigned int flag = 0;18031804 if (broken)1805 flag = DO_FOR_EACH_INCLUDE_BROKEN;1806 return do_for_each_ref(&ref_cache, prefix, fn, 0, flag, cb_data);1807}18081809int for_each_ref_in_submodule(const char *submodule, const char *prefix,1810 each_ref_fn fn, void *cb_data)1811{1812 return do_for_each_ref(get_ref_cache(submodule), prefix, fn, strlen(prefix), 0, cb_data);1813}18141815int for_each_replace_ref(each_ref_fn fn, void *cb_data)1816{1817 return do_for_each_ref(&ref_cache, git_replace_ref_base, fn,1818 strlen(git_replace_ref_base), 0, cb_data);1819}18201821int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)1822{1823 struct strbuf buf = STRBUF_INIT;1824 int ret;1825 strbuf_addf(&buf, "%srefs/", get_git_namespace());1826 ret = do_for_each_ref(&ref_cache, buf.buf, fn, 0, 0, cb_data);1827 strbuf_release(&buf);1828 return ret;1829}18301831int for_each_rawref(each_ref_fn fn, void *cb_data)1832{1833 return do_for_each_ref(&ref_cache, "", fn, 0,1834 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);1835}18361837static void unlock_ref(struct ref_lock *lock)1838{1839 /* Do not free lock->lk -- atexit() still looks at them */1840 if (lock->lk)1841 rollback_lock_file(lock->lk);1842 free(lock->ref_name);1843 free(lock->orig_ref_name);1844 free(lock);1845}18461847/*1848 * Verify that the reference locked by lock has the value old_sha1.1849 * Fail if the reference doesn't exist and mustexist is set. Return 01850 * on success. On error, write an error message to err, set errno, and1851 * return a negative value.1852 */1853static int verify_lock(struct ref_lock *lock,1854 const unsigned char *old_sha1, int mustexist,1855 struct strbuf *err)1856{1857 assert(err);18581859 if (read_ref_full(lock->ref_name,1860 mustexist ? RESOLVE_REF_READING : 0,1861 lock->old_oid.hash, NULL)) {1862 int save_errno = errno;1863 strbuf_addf(err, "can't verify ref %s", lock->ref_name);1864 errno = save_errno;1865 return -1;1866 }1867 if (hashcmp(lock->old_oid.hash, old_sha1)) {1868 strbuf_addf(err, "ref %s is at %s but expected %s",1869 lock->ref_name,1870 sha1_to_hex(lock->old_oid.hash),1871 sha1_to_hex(old_sha1));1872 errno = EBUSY;1873 return -1;1874 }1875 return 0;1876}18771878static int remove_empty_directories(struct strbuf *path)1879{1880 /*1881 * we want to create a file but there is a directory there;1882 * if that is an empty directory (or a directory that contains1883 * only empty directories), remove them.1884 */1885 return remove_dir_recursively(path, REMOVE_DIR_EMPTY_ONLY);1886}18871888/*1889 * Locks a ref returning the lock on success and NULL on failure.1890 * On failure errno is set to something meaningful.1891 */1892static struct ref_lock *lock_ref_sha1_basic(const char *refname,1893 const unsigned char *old_sha1,1894 const struct string_list *extras,1895 const struct string_list *skip,1896 unsigned int flags, int *type_p,1897 struct strbuf *err)1898{1899 struct strbuf ref_file = STRBUF_INIT;1900 struct strbuf orig_ref_file = STRBUF_INIT;1901 const char *orig_refname = refname;1902 struct ref_lock *lock;1903 int last_errno = 0;1904 int type, lflags;1905 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));1906 int resolve_flags = 0;1907 int attempts_remaining = 3;19081909 assert(err);19101911 lock = xcalloc(1, sizeof(struct ref_lock));19121913 if (mustexist)1914 resolve_flags |= RESOLVE_REF_READING;1915 if (flags & REF_DELETING) {1916 resolve_flags |= RESOLVE_REF_ALLOW_BAD_NAME;1917 if (flags & REF_NODEREF)1918 resolve_flags |= RESOLVE_REF_NO_RECURSE;1919 }19201921 refname = resolve_ref_unsafe(refname, resolve_flags,1922 lock->old_oid.hash, &type);1923 if (!refname && errno == EISDIR) {1924 /*1925 * we are trying to lock foo but we used to1926 * have foo/bar which now does not exist;1927 * it is normal for the empty directory 'foo'1928 * to remain.1929 */1930 strbuf_git_path(&orig_ref_file, "%s", orig_refname);1931 if (remove_empty_directories(&orig_ref_file)) {1932 last_errno = errno;1933 if (!verify_refname_available_dir(orig_refname, extras, skip,1934 get_loose_refs(&ref_cache), err))1935 strbuf_addf(err, "there are still refs under '%s'",1936 orig_refname);1937 goto error_return;1938 }1939 refname = resolve_ref_unsafe(orig_refname, resolve_flags,1940 lock->old_oid.hash, &type);1941 }1942 if (type_p)1943 *type_p = type;1944 if (!refname) {1945 last_errno = errno;1946 if (last_errno != ENOTDIR ||1947 !verify_refname_available_dir(orig_refname, extras, skip,1948 get_loose_refs(&ref_cache), err))1949 strbuf_addf(err, "unable to resolve reference %s: %s",1950 orig_refname, strerror(last_errno));19511952 goto error_return;1953 }1954 /*1955 * If the ref did not exist and we are creating it, make sure1956 * there is no existing packed ref whose name begins with our1957 * refname, nor a packed ref whose name is a proper prefix of1958 * our refname.1959 */1960 if (is_null_oid(&lock->old_oid) &&1961 verify_refname_available_dir(refname, extras, skip,1962 get_packed_refs(&ref_cache), err)) {1963 last_errno = ENOTDIR;1964 goto error_return;1965 }19661967 lock->lk = xcalloc(1, sizeof(struct lock_file));19681969 lflags = 0;1970 if (flags & REF_NODEREF) {1971 refname = orig_refname;1972 lflags |= LOCK_NO_DEREF;1973 }1974 lock->ref_name = xstrdup(refname);1975 lock->orig_ref_name = xstrdup(orig_refname);1976 strbuf_git_path(&ref_file, "%s", refname);19771978 retry:1979 switch (safe_create_leading_directories_const(ref_file.buf)) {1980 case SCLD_OK:1981 break; /* success */1982 case SCLD_VANISHED:1983 if (--attempts_remaining > 0)1984 goto retry;1985 /* fall through */1986 default:1987 last_errno = errno;1988 strbuf_addf(err, "unable to create directory for %s",1989 ref_file.buf);1990 goto error_return;1991 }19921993 if (hold_lock_file_for_update(lock->lk, ref_file.buf, lflags) < 0) {1994 last_errno = errno;1995 if (errno == ENOENT && --attempts_remaining > 0)1996 /*1997 * Maybe somebody just deleted one of the1998 * directories leading to ref_file. Try1999 * again:2000 */2001 goto retry;2002 else {2003 unable_to_lock_message(ref_file.buf, errno, err);2004 goto error_return;2005 }2006 }2007 if (old_sha1 && verify_lock(lock, old_sha1, mustexist, err)) {2008 last_errno = errno;2009 goto error_return;2010 }2011 goto out;20122013 error_return:2014 unlock_ref(lock);2015 lock = NULL;20162017 out:2018 strbuf_release(&ref_file);2019 strbuf_release(&orig_ref_file);2020 errno = last_errno;2021 return lock;2022}20232024/*2025 * Write an entry to the packed-refs file for the specified refname.2026 * If peeled is non-NULL, write it as the entry's peeled value.2027 */2028static void write_packed_entry(FILE *fh, char *refname, unsigned char *sha1,2029 unsigned char *peeled)2030{2031 fprintf_or_die(fh, "%s %s\n", sha1_to_hex(sha1), refname);2032 if (peeled)2033 fprintf_or_die(fh, "^%s\n", sha1_to_hex(peeled));2034}20352036/*2037 * An each_ref_entry_fn that writes the entry to a packed-refs file.2038 */2039static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)2040{2041 enum peel_status peel_status = peel_entry(entry, 0);20422043 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2044 error("internal error: %s is not a valid packed reference!",2045 entry->name);2046 write_packed_entry(cb_data, entry->name, entry->u.value.oid.hash,2047 peel_status == PEEL_PEELED ?2048 entry->u.value.peeled.hash : NULL);2049 return 0;2050}20512052/*2053 * Lock the packed-refs file for writing. Flags is passed to2054 * hold_lock_file_for_update(). Return 0 on success. On errors, set2055 * errno appropriately and return a nonzero value.2056 */2057static int lock_packed_refs(int flags)2058{2059 static int timeout_configured = 0;2060 static int timeout_value = 1000;20612062 struct packed_ref_cache *packed_ref_cache;20632064 if (!timeout_configured) {2065 git_config_get_int("core.packedrefstimeout", &timeout_value);2066 timeout_configured = 1;2067 }20682069 if (hold_lock_file_for_update_timeout(2070 &packlock, git_path("packed-refs"),2071 flags, timeout_value) < 0)2072 return -1;2073 /*2074 * Get the current packed-refs while holding the lock. If the2075 * packed-refs file has been modified since we last read it,2076 * this will automatically invalidate the cache and re-read2077 * the packed-refs file.2078 */2079 packed_ref_cache = get_packed_ref_cache(&ref_cache);2080 packed_ref_cache->lock = &packlock;2081 /* Increment the reference count to prevent it from being freed: */2082 acquire_packed_ref_cache(packed_ref_cache);2083 return 0;2084}20852086/*2087 * Write the current version of the packed refs cache from memory to2088 * disk. The packed-refs file must already be locked for writing (see2089 * lock_packed_refs()). Return zero on success. On errors, set errno2090 * and return a nonzero value2091 */2092static int commit_packed_refs(void)2093{2094 struct packed_ref_cache *packed_ref_cache =2095 get_packed_ref_cache(&ref_cache);2096 int error = 0;2097 int save_errno = 0;2098 FILE *out;20992100 if (!packed_ref_cache->lock)2101 die("internal error: packed-refs not locked");21022103 out = fdopen_lock_file(packed_ref_cache->lock, "w");2104 if (!out)2105 die_errno("unable to fdopen packed-refs descriptor");21062107 fprintf_or_die(out, "%s", PACKED_REFS_HEADER);2108 do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),2109 0, write_packed_entry_fn, out);21102111 if (commit_lock_file(packed_ref_cache->lock)) {2112 save_errno = errno;2113 error = -1;2114 }2115 packed_ref_cache->lock = NULL;2116 release_packed_ref_cache(packed_ref_cache);2117 errno = save_errno;2118 return error;2119}21202121/*2122 * Rollback the lockfile for the packed-refs file, and discard the2123 * in-memory packed reference cache. (The packed-refs file will be2124 * read anew if it is needed again after this function is called.)2125 */2126static void rollback_packed_refs(void)2127{2128 struct packed_ref_cache *packed_ref_cache =2129 get_packed_ref_cache(&ref_cache);21302131 if (!packed_ref_cache->lock)2132 die("internal error: packed-refs not locked");2133 rollback_lock_file(packed_ref_cache->lock);2134 packed_ref_cache->lock = NULL;2135 release_packed_ref_cache(packed_ref_cache);2136 clear_packed_ref_cache(&ref_cache);2137}21382139struct ref_to_prune {2140 struct ref_to_prune *next;2141 unsigned char sha1[20];2142 char name[FLEX_ARRAY];2143};21442145struct pack_refs_cb_data {2146 unsigned int flags;2147 struct ref_dir *packed_refs;2148 struct ref_to_prune *ref_to_prune;2149};21502151/*2152 * An each_ref_entry_fn that is run over loose references only. If2153 * the loose reference can be packed, add an entry in the packed ref2154 * cache. If the reference should be pruned, also add it to2155 * ref_to_prune in the pack_refs_cb_data.2156 */2157static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)2158{2159 struct pack_refs_cb_data *cb = cb_data;2160 enum peel_status peel_status;2161 struct ref_entry *packed_entry;2162 int is_tag_ref = starts_with(entry->name, "refs/tags/");21632164 /* Do not pack per-worktree refs: */2165 if (ref_type(entry->name) != REF_TYPE_NORMAL)2166 return 0;21672168 /* ALWAYS pack tags */2169 if (!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)2170 return 0;21712172 /* Do not pack symbolic or broken refs: */2173 if ((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))2174 return 0;21752176 /* Add a packed ref cache entry equivalent to the loose entry. */2177 peel_status = peel_entry(entry, 1);2178 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2179 die("internal error peeling reference %s (%s)",2180 entry->name, oid_to_hex(&entry->u.value.oid));2181 packed_entry = find_ref(cb->packed_refs, entry->name);2182 if (packed_entry) {2183 /* Overwrite existing packed entry with info from loose entry */2184 packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;2185 oidcpy(&packed_entry->u.value.oid, &entry->u.value.oid);2186 } else {2187 packed_entry = create_ref_entry(entry->name, entry->u.value.oid.hash,2188 REF_ISPACKED | REF_KNOWS_PEELED, 0);2189 add_ref(cb->packed_refs, packed_entry);2190 }2191 oidcpy(&packed_entry->u.value.peeled, &entry->u.value.peeled);21922193 /* Schedule the loose reference for pruning if requested. */2194 if ((cb->flags & PACK_REFS_PRUNE)) {2195 int namelen = strlen(entry->name) + 1;2196 struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);2197 hashcpy(n->sha1, entry->u.value.oid.hash);2198 memcpy(n->name, entry->name, namelen); /* includes NUL */2199 n->next = cb->ref_to_prune;2200 cb->ref_to_prune = n;2201 }2202 return 0;2203}22042205/*2206 * Remove empty parents, but spare refs/ and immediate subdirs.2207 * Note: munges *name.2208 */2209static void try_remove_empty_parents(char *name)2210{2211 char *p, *q;2212 int i;2213 p = name;2214 for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */2215 while (*p && *p != '/')2216 p++;2217 /* tolerate duplicate slashes; see check_refname_format() */2218 while (*p == '/')2219 p++;2220 }2221 for (q = p; *q; q++)2222 ;2223 while (1) {2224 while (q > p && *q != '/')2225 q--;2226 while (q > p && *(q-1) == '/')2227 q--;2228 if (q == p)2229 break;2230 *q = '\0';2231 if (rmdir(git_path("%s", name)))2232 break;2233 }2234}22352236/* make sure nobody touched the ref, and unlink */2237static void prune_ref(struct ref_to_prune *r)2238{2239 struct ref_transaction *transaction;2240 struct strbuf err = STRBUF_INIT;22412242 if (check_refname_format(r->name, 0))2243 return;22442245 transaction = ref_transaction_begin(&err);2246 if (!transaction ||2247 ref_transaction_delete(transaction, r->name, r->sha1,2248 REF_ISPRUNING, NULL, &err) ||2249 ref_transaction_commit(transaction, &err)) {2250 ref_transaction_free(transaction);2251 error("%s", err.buf);2252 strbuf_release(&err);2253 return;2254 }2255 ref_transaction_free(transaction);2256 strbuf_release(&err);2257 try_remove_empty_parents(r->name);2258}22592260static void prune_refs(struct ref_to_prune *r)2261{2262 while (r) {2263 prune_ref(r);2264 r = r->next;2265 }2266}22672268int pack_refs(unsigned int flags)2269{2270 struct pack_refs_cb_data cbdata;22712272 memset(&cbdata, 0, sizeof(cbdata));2273 cbdata.flags = flags;22742275 lock_packed_refs(LOCK_DIE_ON_ERROR);2276 cbdata.packed_refs = get_packed_refs(&ref_cache);22772278 do_for_each_entry_in_dir(get_loose_refs(&ref_cache), 0,2279 pack_if_possible_fn, &cbdata);22802281 if (commit_packed_refs())2282 die_errno("unable to overwrite old ref-pack file");22832284 prune_refs(cbdata.ref_to_prune);2285 return 0;2286}22872288/*2289 * Rewrite the packed-refs file, omitting any refs listed in2290 * 'refnames'. On error, leave packed-refs unchanged, write an error2291 * message to 'err', and return a nonzero value.2292 *2293 * The refs in 'refnames' needn't be sorted. `err` must not be NULL.2294 */2295static int repack_without_refs(struct string_list *refnames, struct strbuf *err)2296{2297 struct ref_dir *packed;2298 struct string_list_item *refname;2299 int ret, needs_repacking = 0, removed = 0;23002301 assert(err);23022303 /* Look for a packed ref */2304 for_each_string_list_item(refname, refnames) {2305 if (get_packed_ref(refname->string)) {2306 needs_repacking = 1;2307 break;2308 }2309 }23102311 /* Avoid locking if we have nothing to do */2312 if (!needs_repacking)2313 return 0; /* no refname exists in packed refs */23142315 if (lock_packed_refs(0)) {2316 unable_to_lock_message(git_path("packed-refs"), errno, err);2317 return -1;2318 }2319 packed = get_packed_refs(&ref_cache);23202321 /* Remove refnames from the cache */2322 for_each_string_list_item(refname, refnames)2323 if (remove_entry(packed, refname->string) != -1)2324 removed = 1;2325 if (!removed) {2326 /*2327 * All packed entries disappeared while we were2328 * acquiring the lock.2329 */2330 rollback_packed_refs();2331 return 0;2332 }23332334 /* Write what remains */2335 ret = commit_packed_refs();2336 if (ret)2337 strbuf_addf(err, "unable to overwrite old ref-pack file: %s",2338 strerror(errno));2339 return ret;2340}23412342static int delete_ref_loose(struct ref_lock *lock, int flag, struct strbuf *err)2343{2344 assert(err);23452346 if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {2347 /*2348 * loose. The loose file name is the same as the2349 * lockfile name, minus ".lock":2350 */2351 char *loose_filename = get_locked_file_path(lock->lk);2352 int res = unlink_or_msg(loose_filename, err);2353 free(loose_filename);2354 if (res)2355 return 1;2356 }2357 return 0;2358}23592360int delete_refs(struct string_list *refnames)2361{2362 struct strbuf err = STRBUF_INIT;2363 int i, result = 0;23642365 if (!refnames->nr)2366 return 0;23672368 result = repack_without_refs(refnames, &err);2369 if (result) {2370 /*2371 * If we failed to rewrite the packed-refs file, then2372 * it is unsafe to try to remove loose refs, because2373 * doing so might expose an obsolete packed value for2374 * a reference that might even point at an object that2375 * has been garbage collected.2376 */2377 if (refnames->nr == 1)2378 error(_("could not delete reference %s: %s"),2379 refnames->items[0].string, err.buf);2380 else2381 error(_("could not delete references: %s"), err.buf);23822383 goto out;2384 }23852386 for (i = 0; i < refnames->nr; i++) {2387 const char *refname = refnames->items[i].string;23882389 if (delete_ref(refname, NULL, 0))2390 result |= error(_("could not remove reference %s"), refname);2391 }23922393out:2394 strbuf_release(&err);2395 return result;2396}23972398/*2399 * People using contrib's git-new-workdir have .git/logs/refs ->2400 * /some/other/path/.git/logs/refs, and that may live on another device.2401 *2402 * IOW, to avoid cross device rename errors, the temporary renamed log must2403 * live into logs/refs.2404 */2405#define TMP_RENAMED_LOG "logs/refs/.tmp-renamed-log"24062407static int rename_tmp_log(const char *newrefname)2408{2409 int attempts_remaining = 4;2410 struct strbuf path = STRBUF_INIT;2411 int ret = -1;24122413 retry:2414 strbuf_reset(&path);2415 strbuf_git_path(&path, "logs/%s", newrefname);2416 switch (safe_create_leading_directories_const(path.buf)) {2417 case SCLD_OK:2418 break; /* success */2419 case SCLD_VANISHED:2420 if (--attempts_remaining > 0)2421 goto retry;2422 /* fall through */2423 default:2424 error("unable to create directory for %s", newrefname);2425 goto out;2426 }24272428 if (rename(git_path(TMP_RENAMED_LOG), path.buf)) {2429 if ((errno==EISDIR || errno==ENOTDIR) && --attempts_remaining > 0) {2430 /*2431 * rename(a, b) when b is an existing2432 * directory ought to result in ISDIR, but2433 * Solaris 5.8 gives ENOTDIR. Sheesh.2434 */2435 if (remove_empty_directories(&path)) {2436 error("Directory not empty: logs/%s", newrefname);2437 goto out;2438 }2439 goto retry;2440 } else if (errno == ENOENT && --attempts_remaining > 0) {2441 /*2442 * Maybe another process just deleted one of2443 * the directories in the path to newrefname.2444 * Try again from the beginning.2445 */2446 goto retry;2447 } else {2448 error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",2449 newrefname, strerror(errno));2450 goto out;2451 }2452 }2453 ret = 0;2454out:2455 strbuf_release(&path);2456 return ret;2457}24582459int verify_refname_available(const char *newname,2460 struct string_list *extras,2461 struct string_list *skip,2462 struct strbuf *err)2463{2464 struct ref_dir *packed_refs = get_packed_refs(&ref_cache);2465 struct ref_dir *loose_refs = get_loose_refs(&ref_cache);24662467 if (verify_refname_available_dir(newname, extras, skip,2468 packed_refs, err) ||2469 verify_refname_available_dir(newname, extras, skip,2470 loose_refs, err))2471 return -1;24722473 return 0;2474}24752476static int rename_ref_available(const char *oldname, const char *newname)2477{2478 struct string_list skip = STRING_LIST_INIT_NODUP;2479 struct strbuf err = STRBUF_INIT;2480 int ret;24812482 string_list_insert(&skip, oldname);2483 ret = !verify_refname_available(newname, NULL, &skip, &err);2484 if (!ret)2485 error("%s", err.buf);24862487 string_list_clear(&skip, 0);2488 strbuf_release(&err);2489 return ret;2490}24912492static int write_ref_to_lockfile(struct ref_lock *lock,2493 const unsigned char *sha1, struct strbuf *err);2494static int commit_ref_update(struct ref_lock *lock,2495 const unsigned char *sha1, const char *logmsg,2496 int flags, struct strbuf *err);24972498int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)2499{2500 unsigned char sha1[20], orig_sha1[20];2501 int flag = 0, logmoved = 0;2502 struct ref_lock *lock;2503 struct stat loginfo;2504 int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);2505 const char *symref = NULL;2506 struct strbuf err = STRBUF_INIT;25072508 if (log && S_ISLNK(loginfo.st_mode))2509 return error("reflog for %s is a symlink", oldrefname);25102511 symref = resolve_ref_unsafe(oldrefname, RESOLVE_REF_READING,2512 orig_sha1, &flag);2513 if (flag & REF_ISSYMREF)2514 return error("refname %s is a symbolic ref, renaming it is not supported",2515 oldrefname);2516 if (!symref)2517 return error("refname %s not found", oldrefname);25182519 if (!rename_ref_available(oldrefname, newrefname))2520 return 1;25212522 if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))2523 return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",2524 oldrefname, strerror(errno));25252526 if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {2527 error("unable to delete old %s", oldrefname);2528 goto rollback;2529 }25302531 if (!read_ref_full(newrefname, RESOLVE_REF_READING, sha1, NULL) &&2532 delete_ref(newrefname, sha1, REF_NODEREF)) {2533 if (errno==EISDIR) {2534 struct strbuf path = STRBUF_INIT;2535 int result;25362537 strbuf_git_path(&path, "%s", newrefname);2538 result = remove_empty_directories(&path);2539 strbuf_release(&path);25402541 if (result) {2542 error("Directory not empty: %s", newrefname);2543 goto rollback;2544 }2545 } else {2546 error("unable to delete existing %s", newrefname);2547 goto rollback;2548 }2549 }25502551 if (log && rename_tmp_log(newrefname))2552 goto rollback;25532554 logmoved = log;25552556 lock = lock_ref_sha1_basic(newrefname, NULL, NULL, NULL, 0, NULL, &err);2557 if (!lock) {2558 error("unable to rename '%s' to '%s': %s", oldrefname, newrefname, err.buf);2559 strbuf_release(&err);2560 goto rollback;2561 }2562 hashcpy(lock->old_oid.hash, orig_sha1);25632564 if (write_ref_to_lockfile(lock, orig_sha1, &err) ||2565 commit_ref_update(lock, orig_sha1, logmsg, 0, &err)) {2566 error("unable to write current sha1 into %s: %s", newrefname, err.buf);2567 strbuf_release(&err);2568 goto rollback;2569 }25702571 return 0;25722573 rollback:2574 lock = lock_ref_sha1_basic(oldrefname, NULL, NULL, NULL, 0, NULL, &err);2575 if (!lock) {2576 error("unable to lock %s for rollback: %s", oldrefname, err.buf);2577 strbuf_release(&err);2578 goto rollbacklog;2579 }25802581 flag = log_all_ref_updates;2582 log_all_ref_updates = 0;2583 if (write_ref_to_lockfile(lock, orig_sha1, &err) ||2584 commit_ref_update(lock, orig_sha1, NULL, 0, &err)) {2585 error("unable to write current sha1 into %s: %s", oldrefname, err.buf);2586 strbuf_release(&err);2587 }2588 log_all_ref_updates = flag;25892590 rollbacklog:2591 if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))2592 error("unable to restore logfile %s from %s: %s",2593 oldrefname, newrefname, strerror(errno));2594 if (!logmoved && log &&2595 rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))2596 error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",2597 oldrefname, strerror(errno));25982599 return 1;2600}26012602static int close_ref(struct ref_lock *lock)2603{2604 if (close_lock_file(lock->lk))2605 return -1;2606 return 0;2607}26082609static int commit_ref(struct ref_lock *lock)2610{2611 if (commit_lock_file(lock->lk))2612 return -1;2613 return 0;2614}26152616/*2617 * Create a reflog for a ref. If force_create = 0, the reflog will2618 * only be created for certain refs (those for which2619 * should_autocreate_reflog returns non-zero. Otherwise, create it2620 * regardless of the ref name. Fill in *err and return -1 on failure.2621 */2622static int log_ref_setup(const char *refname, struct strbuf *logfile, struct strbuf *err, int force_create)2623{2624 int logfd, oflags = O_APPEND | O_WRONLY;26252626 strbuf_git_path(logfile, "logs/%s", refname);2627 if (force_create || should_autocreate_reflog(refname)) {2628 if (safe_create_leading_directories(logfile->buf) < 0) {2629 strbuf_addf(err, "unable to create directory for %s: "2630 "%s", logfile->buf, strerror(errno));2631 return -1;2632 }2633 oflags |= O_CREAT;2634 }26352636 logfd = open(logfile->buf, oflags, 0666);2637 if (logfd < 0) {2638 if (!(oflags & O_CREAT) && (errno == ENOENT || errno == EISDIR))2639 return 0;26402641 if (errno == EISDIR) {2642 if (remove_empty_directories(logfile)) {2643 strbuf_addf(err, "There are still logs under "2644 "'%s'", logfile->buf);2645 return -1;2646 }2647 logfd = open(logfile->buf, oflags, 0666);2648 }26492650 if (logfd < 0) {2651 strbuf_addf(err, "unable to append to %s: %s",2652 logfile->buf, strerror(errno));2653 return -1;2654 }2655 }26562657 adjust_shared_perm(logfile->buf);2658 close(logfd);2659 return 0;2660}266126622663int safe_create_reflog(const char *refname, int force_create, struct strbuf *err)2664{2665 int ret;2666 struct strbuf sb = STRBUF_INIT;26672668 ret = log_ref_setup(refname, &sb, err, force_create);2669 strbuf_release(&sb);2670 return ret;2671}26722673static int log_ref_write_fd(int fd, const unsigned char *old_sha1,2674 const unsigned char *new_sha1,2675 const char *committer, const char *msg)2676{2677 int msglen, written;2678 unsigned maxlen, len;2679 char *logrec;26802681 msglen = msg ? strlen(msg) : 0;2682 maxlen = strlen(committer) + msglen + 100;2683 logrec = xmalloc(maxlen);2684 len = xsnprintf(logrec, maxlen, "%s %s %s\n",2685 sha1_to_hex(old_sha1),2686 sha1_to_hex(new_sha1),2687 committer);2688 if (msglen)2689 len += copy_reflog_msg(logrec + len - 1, msg) - 1;26902691 written = len <= maxlen ? write_in_full(fd, logrec, len) : -1;2692 free(logrec);2693 if (written != len)2694 return -1;26952696 return 0;2697}26982699static int log_ref_write_1(const char *refname, const unsigned char *old_sha1,2700 const unsigned char *new_sha1, const char *msg,2701 struct strbuf *logfile, int flags,2702 struct strbuf *err)2703{2704 int logfd, result, oflags = O_APPEND | O_WRONLY;27052706 if (log_all_ref_updates < 0)2707 log_all_ref_updates = !is_bare_repository();27082709 result = log_ref_setup(refname, logfile, err, flags & REF_FORCE_CREATE_REFLOG);27102711 if (result)2712 return result;27132714 logfd = open(logfile->buf, oflags);2715 if (logfd < 0)2716 return 0;2717 result = log_ref_write_fd(logfd, old_sha1, new_sha1,2718 git_committer_info(0), msg);2719 if (result) {2720 strbuf_addf(err, "unable to append to %s: %s", logfile->buf,2721 strerror(errno));2722 close(logfd);2723 return -1;2724 }2725 if (close(logfd)) {2726 strbuf_addf(err, "unable to append to %s: %s", logfile->buf,2727 strerror(errno));2728 return -1;2729 }2730 return 0;2731}27322733static int log_ref_write(const char *refname, const unsigned char *old_sha1,2734 const unsigned char *new_sha1, const char *msg,2735 int flags, struct strbuf *err)2736{2737 struct strbuf sb = STRBUF_INIT;2738 int ret = log_ref_write_1(refname, old_sha1, new_sha1, msg, &sb, flags,2739 err);2740 strbuf_release(&sb);2741 return ret;2742}27432744/*2745 * Write sha1 into the open lockfile, then close the lockfile. On2746 * errors, rollback the lockfile, fill in *err and2747 * return -1.2748 */2749static int write_ref_to_lockfile(struct ref_lock *lock,2750 const unsigned char *sha1, struct strbuf *err)2751{2752 static char term = '\n';2753 struct object *o;2754 int fd;27552756 o = parse_object(sha1);2757 if (!o) {2758 strbuf_addf(err,2759 "Trying to write ref %s with nonexistent object %s",2760 lock->ref_name, sha1_to_hex(sha1));2761 unlock_ref(lock);2762 return -1;2763 }2764 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {2765 strbuf_addf(err,2766 "Trying to write non-commit object %s to branch %s",2767 sha1_to_hex(sha1), lock->ref_name);2768 unlock_ref(lock);2769 return -1;2770 }2771 fd = get_lock_file_fd(lock->lk);2772 if (write_in_full(fd, sha1_to_hex(sha1), 40) != 40 ||2773 write_in_full(fd, &term, 1) != 1 ||2774 close_ref(lock) < 0) {2775 strbuf_addf(err,2776 "Couldn't write %s", get_lock_file_path(lock->lk));2777 unlock_ref(lock);2778 return -1;2779 }2780 return 0;2781}27822783/*2784 * Commit a change to a loose reference that has already been written2785 * to the loose reference lockfile. Also update the reflogs if2786 * necessary, using the specified lockmsg (which can be NULL).2787 */2788static int commit_ref_update(struct ref_lock *lock,2789 const unsigned char *sha1, const char *logmsg,2790 int flags, struct strbuf *err)2791{2792 clear_loose_ref_cache(&ref_cache);2793 if (log_ref_write(lock->ref_name, lock->old_oid.hash, sha1, logmsg, flags, err) < 0 ||2794 (strcmp(lock->ref_name, lock->orig_ref_name) &&2795 log_ref_write(lock->orig_ref_name, lock->old_oid.hash, sha1, logmsg, flags, err) < 0)) {2796 char *old_msg = strbuf_detach(err, NULL);2797 strbuf_addf(err, "Cannot update the ref '%s': %s",2798 lock->ref_name, old_msg);2799 free(old_msg);2800 unlock_ref(lock);2801 return -1;2802 }2803 if (strcmp(lock->orig_ref_name, "HEAD") != 0) {2804 /*2805 * Special hack: If a branch is updated directly and HEAD2806 * points to it (may happen on the remote side of a push2807 * for example) then logically the HEAD reflog should be2808 * updated too.2809 * A generic solution implies reverse symref information,2810 * but finding all symrefs pointing to the given branch2811 * would be rather costly for this rare event (the direct2812 * update of a branch) to be worth it. So let's cheat and2813 * check with HEAD only which should cover 99% of all usage2814 * scenarios (even 100% of the default ones).2815 */2816 unsigned char head_sha1[20];2817 int head_flag;2818 const char *head_ref;2819 head_ref = resolve_ref_unsafe("HEAD", RESOLVE_REF_READING,2820 head_sha1, &head_flag);2821 if (head_ref && (head_flag & REF_ISSYMREF) &&2822 !strcmp(head_ref, lock->ref_name)) {2823 struct strbuf log_err = STRBUF_INIT;2824 if (log_ref_write("HEAD", lock->old_oid.hash, sha1,2825 logmsg, 0, &log_err)) {2826 error("%s", log_err.buf);2827 strbuf_release(&log_err);2828 }2829 }2830 }2831 if (commit_ref(lock)) {2832 error("Couldn't set %s", lock->ref_name);2833 unlock_ref(lock);2834 return -1;2835 }28362837 unlock_ref(lock);2838 return 0;2839}28402841int create_symref(const char *ref_target, const char *refs_heads_master,2842 const char *logmsg)2843{2844 char *lockpath = NULL;2845 char ref[1000];2846 int fd, len, written;2847 char *git_HEAD = git_pathdup("%s", ref_target);2848 unsigned char old_sha1[20], new_sha1[20];2849 struct strbuf err = STRBUF_INIT;28502851 if (logmsg && read_ref(ref_target, old_sha1))2852 hashclr(old_sha1);28532854 if (safe_create_leading_directories(git_HEAD) < 0)2855 return error("unable to create directory for %s", git_HEAD);28562857#ifndef NO_SYMLINK_HEAD2858 if (prefer_symlink_refs) {2859 unlink(git_HEAD);2860 if (!symlink(refs_heads_master, git_HEAD))2861 goto done;2862 fprintf(stderr, "no symlink - falling back to symbolic ref\n");2863 }2864#endif28652866 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);2867 if (sizeof(ref) <= len) {2868 error("refname too long: %s", refs_heads_master);2869 goto error_free_return;2870 }2871 lockpath = mkpathdup("%s.lock", git_HEAD);2872 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);2873 if (fd < 0) {2874 error("Unable to open %s for writing", lockpath);2875 goto error_free_return;2876 }2877 written = write_in_full(fd, ref, len);2878 if (close(fd) != 0 || written != len) {2879 error("Unable to write to %s", lockpath);2880 goto error_unlink_return;2881 }2882 if (rename(lockpath, git_HEAD) < 0) {2883 error("Unable to create %s", git_HEAD);2884 goto error_unlink_return;2885 }2886 if (adjust_shared_perm(git_HEAD)) {2887 error("Unable to fix permissions on %s", lockpath);2888 error_unlink_return:2889 unlink_or_warn(lockpath);2890 error_free_return:2891 free(lockpath);2892 free(git_HEAD);2893 return -1;2894 }2895 free(lockpath);28962897#ifndef NO_SYMLINK_HEAD2898 done:2899#endif2900 if (logmsg && !read_ref(refs_heads_master, new_sha1) &&2901 log_ref_write(ref_target, old_sha1, new_sha1, logmsg, 0, &err)) {2902 error("%s", err.buf);2903 strbuf_release(&err);2904 }29052906 free(git_HEAD);2907 return 0;2908}29092910int reflog_exists(const char *refname)2911{2912 struct stat st;29132914 return !lstat(git_path("logs/%s", refname), &st) &&2915 S_ISREG(st.st_mode);2916}29172918int delete_reflog(const char *refname)2919{2920 return remove_path(git_path("logs/%s", refname));2921}29222923static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)2924{2925 unsigned char osha1[20], nsha1[20];2926 char *email_end, *message;2927 unsigned long timestamp;2928 int tz;29292930 /* old SP new SP name <email> SP time TAB msg LF */2931 if (sb->len < 83 || sb->buf[sb->len - 1] != '\n' ||2932 get_sha1_hex(sb->buf, osha1) || sb->buf[40] != ' ' ||2933 get_sha1_hex(sb->buf + 41, nsha1) || sb->buf[81] != ' ' ||2934 !(email_end = strchr(sb->buf + 82, '>')) ||2935 email_end[1] != ' ' ||2936 !(timestamp = strtoul(email_end + 2, &message, 10)) ||2937 !message || message[0] != ' ' ||2938 (message[1] != '+' && message[1] != '-') ||2939 !isdigit(message[2]) || !isdigit(message[3]) ||2940 !isdigit(message[4]) || !isdigit(message[5]))2941 return 0; /* corrupt? */2942 email_end[1] = '\0';2943 tz = strtol(message + 1, NULL, 10);2944 if (message[6] != '\t')2945 message += 6;2946 else2947 message += 7;2948 return fn(osha1, nsha1, sb->buf + 82, timestamp, tz, message, cb_data);2949}29502951static char *find_beginning_of_line(char *bob, char *scan)2952{2953 while (bob < scan && *(--scan) != '\n')2954 ; /* keep scanning backwards */2955 /*2956 * Return either beginning of the buffer, or LF at the end of2957 * the previous line.2958 */2959 return scan;2960}29612962int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data)2963{2964 struct strbuf sb = STRBUF_INIT;2965 FILE *logfp;2966 long pos;2967 int ret = 0, at_tail = 1;29682969 logfp = fopen(git_path("logs/%s", refname), "r");2970 if (!logfp)2971 return -1;29722973 /* Jump to the end */2974 if (fseek(logfp, 0, SEEK_END) < 0)2975 return error("cannot seek back reflog for %s: %s",2976 refname, strerror(errno));2977 pos = ftell(logfp);2978 while (!ret && 0 < pos) {2979 int cnt;2980 size_t nread;2981 char buf[BUFSIZ];2982 char *endp, *scanp;29832984 /* Fill next block from the end */2985 cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;2986 if (fseek(logfp, pos - cnt, SEEK_SET))2987 return error("cannot seek back reflog for %s: %s",2988 refname, strerror(errno));2989 nread = fread(buf, cnt, 1, logfp);2990 if (nread != 1)2991 return error("cannot read %d bytes from reflog for %s: %s",2992 cnt, refname, strerror(errno));2993 pos -= cnt;29942995 scanp = endp = buf + cnt;2996 if (at_tail && scanp[-1] == '\n')2997 /* Looking at the final LF at the end of the file */2998 scanp--;2999 at_tail = 0;30003001 while (buf < scanp) {3002 /*3003 * terminating LF of the previous line, or the beginning3004 * of the buffer.3005 */3006 char *bp;30073008 bp = find_beginning_of_line(buf, scanp);30093010 if (*bp == '\n') {3011 /*3012 * The newline is the end of the previous line,3013 * so we know we have complete line starting3014 * at (bp + 1). Prefix it onto any prior data3015 * we collected for the line and process it.3016 */3017 strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1));3018 scanp = bp;3019 endp = bp + 1;3020 ret = show_one_reflog_ent(&sb, fn, cb_data);3021 strbuf_reset(&sb);3022 if (ret)3023 break;3024 } else if (!pos) {3025 /*3026 * We are at the start of the buffer, and the3027 * start of the file; there is no previous3028 * line, and we have everything for this one.3029 * Process it, and we can end the loop.3030 */3031 strbuf_splice(&sb, 0, 0, buf, endp - buf);3032 ret = show_one_reflog_ent(&sb, fn, cb_data);3033 strbuf_reset(&sb);3034 break;3035 }30363037 if (bp == buf) {3038 /*3039 * We are at the start of the buffer, and there3040 * is more file to read backwards. Which means3041 * we are in the middle of a line. Note that we3042 * may get here even if *bp was a newline; that3043 * just means we are at the exact end of the3044 * previous line, rather than some spot in the3045 * middle.3046 *3047 * Save away what we have to be combined with3048 * the data from the next read.3049 */3050 strbuf_splice(&sb, 0, 0, buf, endp - buf);3051 break;3052 }3053 }30543055 }3056 if (!ret && sb.len)3057 die("BUG: reverse reflog parser had leftover data");30583059 fclose(logfp);3060 strbuf_release(&sb);3061 return ret;3062}30633064int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)3065{3066 FILE *logfp;3067 struct strbuf sb = STRBUF_INIT;3068 int ret = 0;30693070 logfp = fopen(git_path("logs/%s", refname), "r");3071 if (!logfp)3072 return -1;30733074 while (!ret && !strbuf_getwholeline(&sb, logfp, '\n'))3075 ret = show_one_reflog_ent(&sb, fn, cb_data);3076 fclose(logfp);3077 strbuf_release(&sb);3078 return ret;3079}3080/*3081 * Call fn for each reflog in the namespace indicated by name. name3082 * must be empty or end with '/'. Name will be used as a scratch3083 * space, but its contents will be restored before return.3084 */3085static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data)3086{3087 DIR *d = opendir(git_path("logs/%s", name->buf));3088 int retval = 0;3089 struct dirent *de;3090 int oldlen = name->len;30913092 if (!d)3093 return name->len ? errno : 0;30943095 while ((de = readdir(d)) != NULL) {3096 struct stat st;30973098 if (de->d_name[0] == '.')3099 continue;3100 if (ends_with(de->d_name, ".lock"))3101 continue;3102 strbuf_addstr(name, de->d_name);3103 if (stat(git_path("logs/%s", name->buf), &st) < 0) {3104 ; /* silently ignore */3105 } else {3106 if (S_ISDIR(st.st_mode)) {3107 strbuf_addch(name, '/');3108 retval = do_for_each_reflog(name, fn, cb_data);3109 } else {3110 struct object_id oid;31113112 if (read_ref_full(name->buf, 0, oid.hash, NULL))3113 retval = error("bad ref for %s", name->buf);3114 else3115 retval = fn(name->buf, &oid, 0, cb_data);3116 }3117 if (retval)3118 break;3119 }3120 strbuf_setlen(name, oldlen);3121 }3122 closedir(d);3123 return retval;3124}31253126int for_each_reflog(each_ref_fn fn, void *cb_data)3127{3128 int retval;3129 struct strbuf name;3130 strbuf_init(&name, PATH_MAX);3131 retval = do_for_each_reflog(&name, fn, cb_data);3132 strbuf_release(&name);3133 return retval;3134}31353136static int ref_update_reject_duplicates(struct string_list *refnames,3137 struct strbuf *err)3138{3139 int i, n = refnames->nr;31403141 assert(err);31423143 for (i = 1; i < n; i++)3144 if (!strcmp(refnames->items[i - 1].string, refnames->items[i].string)) {3145 strbuf_addf(err,3146 "Multiple updates for ref '%s' not allowed.",3147 refnames->items[i].string);3148 return 1;3149 }3150 return 0;3151}31523153int ref_transaction_commit(struct ref_transaction *transaction,3154 struct strbuf *err)3155{3156 int ret = 0, i;3157 int n = transaction->nr;3158 struct ref_update **updates = transaction->updates;3159 struct string_list refs_to_delete = STRING_LIST_INIT_NODUP;3160 struct string_list_item *ref_to_delete;3161 struct string_list affected_refnames = STRING_LIST_INIT_NODUP;31623163 assert(err);31643165 if (transaction->state != REF_TRANSACTION_OPEN)3166 die("BUG: commit called for transaction that is not open");31673168 if (!n) {3169 transaction->state = REF_TRANSACTION_CLOSED;3170 return 0;3171 }31723173 /* Fail if a refname appears more than once in the transaction: */3174 for (i = 0; i < n; i++)3175 string_list_append(&affected_refnames, updates[i]->refname);3176 string_list_sort(&affected_refnames);3177 if (ref_update_reject_duplicates(&affected_refnames, err)) {3178 ret = TRANSACTION_GENERIC_ERROR;3179 goto cleanup;3180 }31813182 /*3183 * Acquire all locks, verify old values if provided, check3184 * that new values are valid, and write new values to the3185 * lockfiles, ready to be activated. Only keep one lockfile3186 * open at a time to avoid running out of file descriptors.3187 */3188 for (i = 0; i < n; i++) {3189 struct ref_update *update = updates[i];31903191 if ((update->flags & REF_HAVE_NEW) &&3192 is_null_sha1(update->new_sha1))3193 update->flags |= REF_DELETING;3194 update->lock = lock_ref_sha1_basic(3195 update->refname,3196 ((update->flags & REF_HAVE_OLD) ?3197 update->old_sha1 : NULL),3198 &affected_refnames, NULL,3199 update->flags,3200 &update->type,3201 err);3202 if (!update->lock) {3203 char *reason;32043205 ret = (errno == ENOTDIR)3206 ? TRANSACTION_NAME_CONFLICT3207 : TRANSACTION_GENERIC_ERROR;3208 reason = strbuf_detach(err, NULL);3209 strbuf_addf(err, "cannot lock ref '%s': %s",3210 update->refname, reason);3211 free(reason);3212 goto cleanup;3213 }3214 if ((update->flags & REF_HAVE_NEW) &&3215 !(update->flags & REF_DELETING)) {3216 int overwriting_symref = ((update->type & REF_ISSYMREF) &&3217 (update->flags & REF_NODEREF));32183219 if (!overwriting_symref &&3220 !hashcmp(update->lock->old_oid.hash, update->new_sha1)) {3221 /*3222 * The reference already has the desired3223 * value, so we don't need to write it.3224 */3225 } else if (write_ref_to_lockfile(update->lock,3226 update->new_sha1,3227 err)) {3228 char *write_err = strbuf_detach(err, NULL);32293230 /*3231 * The lock was freed upon failure of3232 * write_ref_to_lockfile():3233 */3234 update->lock = NULL;3235 strbuf_addf(err,3236 "cannot update the ref '%s': %s",3237 update->refname, write_err);3238 free(write_err);3239 ret = TRANSACTION_GENERIC_ERROR;3240 goto cleanup;3241 } else {3242 update->flags |= REF_NEEDS_COMMIT;3243 }3244 }3245 if (!(update->flags & REF_NEEDS_COMMIT)) {3246 /*3247 * We didn't have to write anything to the lockfile.3248 * Close it to free up the file descriptor:3249 */3250 if (close_ref(update->lock)) {3251 strbuf_addf(err, "Couldn't close %s.lock",3252 update->refname);3253 goto cleanup;3254 }3255 }3256 }32573258 /* Perform updates first so live commits remain referenced */3259 for (i = 0; i < n; i++) {3260 struct ref_update *update = updates[i];32613262 if (update->flags & REF_NEEDS_COMMIT) {3263 if (commit_ref_update(update->lock,3264 update->new_sha1, update->msg,3265 update->flags, err)) {3266 /* freed by commit_ref_update(): */3267 update->lock = NULL;3268 ret = TRANSACTION_GENERIC_ERROR;3269 goto cleanup;3270 } else {3271 /* freed by commit_ref_update(): */3272 update->lock = NULL;3273 }3274 }3275 }32763277 /* Perform deletes now that updates are safely completed */3278 for (i = 0; i < n; i++) {3279 struct ref_update *update = updates[i];32803281 if (update->flags & REF_DELETING) {3282 if (delete_ref_loose(update->lock, update->type, err)) {3283 ret = TRANSACTION_GENERIC_ERROR;3284 goto cleanup;3285 }32863287 if (!(update->flags & REF_ISPRUNING))3288 string_list_append(&refs_to_delete,3289 update->lock->ref_name);3290 }3291 }32923293 if (repack_without_refs(&refs_to_delete, err)) {3294 ret = TRANSACTION_GENERIC_ERROR;3295 goto cleanup;3296 }3297 for_each_string_list_item(ref_to_delete, &refs_to_delete)3298 unlink_or_warn(git_path("logs/%s", ref_to_delete->string));3299 clear_loose_ref_cache(&ref_cache);33003301cleanup:3302 transaction->state = REF_TRANSACTION_CLOSED;33033304 for (i = 0; i < n; i++)3305 if (updates[i]->lock)3306 unlock_ref(updates[i]->lock);3307 string_list_clear(&refs_to_delete, 0);3308 string_list_clear(&affected_refnames, 0);3309 return ret;3310}33113312static int ref_present(const char *refname,3313 const struct object_id *oid, int flags, void *cb_data)3314{3315 struct string_list *affected_refnames = cb_data;33163317 return string_list_has_string(affected_refnames, refname);3318}33193320int initial_ref_transaction_commit(struct ref_transaction *transaction,3321 struct strbuf *err)3322{3323 int ret = 0, i;3324 int n = transaction->nr;3325 struct ref_update **updates = transaction->updates;3326 struct string_list affected_refnames = STRING_LIST_INIT_NODUP;33273328 assert(err);33293330 if (transaction->state != REF_TRANSACTION_OPEN)3331 die("BUG: commit called for transaction that is not open");33323333 /* Fail if a refname appears more than once in the transaction: */3334 for (i = 0; i < n; i++)3335 string_list_append(&affected_refnames, updates[i]->refname);3336 string_list_sort(&affected_refnames);3337 if (ref_update_reject_duplicates(&affected_refnames, err)) {3338 ret = TRANSACTION_GENERIC_ERROR;3339 goto cleanup;3340 }33413342 /*3343 * It's really undefined to call this function in an active3344 * repository or when there are existing references: we are3345 * only locking and changing packed-refs, so (1) any3346 * simultaneous processes might try to change a reference at3347 * the same time we do, and (2) any existing loose versions of3348 * the references that we are setting would have precedence3349 * over our values. But some remote helpers create the remote3350 * "HEAD" and "master" branches before calling this function,3351 * so here we really only check that none of the references3352 * that we are creating already exists.3353 */3354 if (for_each_rawref(ref_present, &affected_refnames))3355 die("BUG: initial ref transaction called with existing refs");33563357 for (i = 0; i < n; i++) {3358 struct ref_update *update = updates[i];33593360 if ((update->flags & REF_HAVE_OLD) &&3361 !is_null_sha1(update->old_sha1))3362 die("BUG: initial ref transaction with old_sha1 set");3363 if (verify_refname_available(update->refname,3364 &affected_refnames, NULL,3365 err)) {3366 ret = TRANSACTION_NAME_CONFLICT;3367 goto cleanup;3368 }3369 }33703371 if (lock_packed_refs(0)) {3372 strbuf_addf(err, "unable to lock packed-refs file: %s",3373 strerror(errno));3374 ret = TRANSACTION_GENERIC_ERROR;3375 goto cleanup;3376 }33773378 for (i = 0; i < n; i++) {3379 struct ref_update *update = updates[i];33803381 if ((update->flags & REF_HAVE_NEW) &&3382 !is_null_sha1(update->new_sha1))3383 add_packed_ref(update->refname, update->new_sha1);3384 }33853386 if (commit_packed_refs()) {3387 strbuf_addf(err, "unable to commit packed-refs file: %s",3388 strerror(errno));3389 ret = TRANSACTION_GENERIC_ERROR;3390 goto cleanup;3391 }33923393cleanup:3394 transaction->state = REF_TRANSACTION_CLOSED;3395 string_list_clear(&affected_refnames, 0);3396 return ret;3397}33983399struct expire_reflog_cb {3400 unsigned int flags;3401 reflog_expiry_should_prune_fn *should_prune_fn;3402 void *policy_cb;3403 FILE *newlog;3404 unsigned char last_kept_sha1[20];3405};34063407static int expire_reflog_ent(unsigned char *osha1, unsigned char *nsha1,3408 const char *email, unsigned long timestamp, int tz,3409 const char *message, void *cb_data)3410{3411 struct expire_reflog_cb *cb = cb_data;3412 struct expire_reflog_policy_cb *policy_cb = cb->policy_cb;34133414 if (cb->flags & EXPIRE_REFLOGS_REWRITE)3415 osha1 = cb->last_kept_sha1;34163417 if ((*cb->should_prune_fn)(osha1, nsha1, email, timestamp, tz,3418 message, policy_cb)) {3419 if (!cb->newlog)3420 printf("would prune %s", message);3421 else if (cb->flags & EXPIRE_REFLOGS_VERBOSE)3422 printf("prune %s", message);3423 } else {3424 if (cb->newlog) {3425 fprintf(cb->newlog, "%s %s %s %lu %+05d\t%s",3426 sha1_to_hex(osha1), sha1_to_hex(nsha1),3427 email, timestamp, tz, message);3428 hashcpy(cb->last_kept_sha1, nsha1);3429 }3430 if (cb->flags & EXPIRE_REFLOGS_VERBOSE)3431 printf("keep %s", message);3432 }3433 return 0;3434}34353436int reflog_expire(const char *refname, const unsigned char *sha1,3437 unsigned int flags,3438 reflog_expiry_prepare_fn prepare_fn,3439 reflog_expiry_should_prune_fn should_prune_fn,3440 reflog_expiry_cleanup_fn cleanup_fn,3441 void *policy_cb_data)3442{3443 static struct lock_file reflog_lock;3444 struct expire_reflog_cb cb;3445 struct ref_lock *lock;3446 char *log_file;3447 int status = 0;3448 int type;3449 struct strbuf err = STRBUF_INIT;34503451 memset(&cb, 0, sizeof(cb));3452 cb.flags = flags;3453 cb.policy_cb = policy_cb_data;3454 cb.should_prune_fn = should_prune_fn;34553456 /*3457 * The reflog file is locked by holding the lock on the3458 * reference itself, plus we might need to update the3459 * reference if --updateref was specified:3460 */3461 lock = lock_ref_sha1_basic(refname, sha1, NULL, NULL, 0, &type, &err);3462 if (!lock) {3463 error("cannot lock ref '%s': %s", refname, err.buf);3464 strbuf_release(&err);3465 return -1;3466 }3467 if (!reflog_exists(refname)) {3468 unlock_ref(lock);3469 return 0;3470 }34713472 log_file = git_pathdup("logs/%s", refname);3473 if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) {3474 /*3475 * Even though holding $GIT_DIR/logs/$reflog.lock has3476 * no locking implications, we use the lock_file3477 * machinery here anyway because it does a lot of the3478 * work we need, including cleaning up if the program3479 * exits unexpectedly.3480 */3481 if (hold_lock_file_for_update(&reflog_lock, log_file, 0) < 0) {3482 struct strbuf err = STRBUF_INIT;3483 unable_to_lock_message(log_file, errno, &err);3484 error("%s", err.buf);3485 strbuf_release(&err);3486 goto failure;3487 }3488 cb.newlog = fdopen_lock_file(&reflog_lock, "w");3489 if (!cb.newlog) {3490 error("cannot fdopen %s (%s)",3491 get_lock_file_path(&reflog_lock), strerror(errno));3492 goto failure;3493 }3494 }34953496 (*prepare_fn)(refname, sha1, cb.policy_cb);3497 for_each_reflog_ent(refname, expire_reflog_ent, &cb);3498 (*cleanup_fn)(cb.policy_cb);34993500 if (!(flags & EXPIRE_REFLOGS_DRY_RUN)) {3501 /*3502 * It doesn't make sense to adjust a reference pointed3503 * to by a symbolic ref based on expiring entries in3504 * the symbolic reference's reflog. Nor can we update3505 * a reference if there are no remaining reflog3506 * entries.3507 */3508 int update = (flags & EXPIRE_REFLOGS_UPDATE_REF) &&3509 !(type & REF_ISSYMREF) &&3510 !is_null_sha1(cb.last_kept_sha1);35113512 if (close_lock_file(&reflog_lock)) {3513 status |= error("couldn't write %s: %s", log_file,3514 strerror(errno));3515 } else if (update &&3516 (write_in_full(get_lock_file_fd(lock->lk),3517 sha1_to_hex(cb.last_kept_sha1), 40) != 40 ||3518 write_str_in_full(get_lock_file_fd(lock->lk), "\n") != 1 ||3519 close_ref(lock) < 0)) {3520 status |= error("couldn't write %s",3521 get_lock_file_path(lock->lk));3522 rollback_lock_file(&reflog_lock);3523 } else if (commit_lock_file(&reflog_lock)) {3524 status |= error("unable to commit reflog '%s' (%s)",3525 log_file, strerror(errno));3526 } else if (update && commit_ref(lock)) {3527 status |= error("couldn't set %s", lock->ref_name);3528 }3529 }3530 free(log_file);3531 unlock_ref(lock);3532 return status;35333534 failure:3535 rollback_lock_file(&reflog_lock);3536 free(log_file);3537 unlock_ref(lock);3538 return -1;3539}