1#include "cache.h" 2#include "refs.h" 3#include "object.h" 4#include "tag.h" 5#include "dir.h" 6#include "string-list.h" 7 8/* 9 * How to handle various characters in refnames: 10 * 0: An acceptable character for refs 11 * 1: End-of-component 12 * 2: ., look for a preceding . to reject .. in refs 13 * 3: {, look for a preceding @ to reject @{ in refs 14 * 4: A bad character: ASCII control characters, "~", "^", ":" or SP 15 */ 16static unsigned char refname_disposition[256] = { 17 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 18 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 19 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 2, 1, 20 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4, 21 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0, 23 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4 25}; 26 27/* 28 * Used as a flag to ref_transaction_delete when a loose ref is being 29 * pruned. 30 */ 31#define REF_ISPRUNING 0x0100 32/* 33 * Try to read one refname component from the front of refname. 34 * Return the length of the component found, or -1 if the component is 35 * not legal. It is legal if it is something reasonable to have under 36 * ".git/refs/"; We do not like it if: 37 * 38 * - any path component of it begins with ".", or 39 * - it has double dots "..", or 40 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or 41 * - it ends with a "/". 42 * - it ends with ".lock" 43 * - it contains a "\" (backslash) 44 */ 45static int check_refname_component(const char *refname, int flags) 46{ 47 const char *cp; 48 char last = '\0'; 49 50 for (cp = refname; ; cp++) { 51 int ch = *cp & 255; 52 unsigned char disp = refname_disposition[ch]; 53 switch (disp) { 54 case 1: 55 goto out; 56 case 2: 57 if (last == '.') 58 return -1; /* Refname contains "..". */ 59 break; 60 case 3: 61 if (last == '@') 62 return -1; /* Refname contains "@{". */ 63 break; 64 case 4: 65 return -1; 66 } 67 last = ch; 68 } 69out: 70 if (cp == refname) 71 return 0; /* Component has zero length. */ 72 if (refname[0] == '.') { 73 if (!(flags & REFNAME_DOT_COMPONENT)) 74 return -1; /* Component starts with '.'. */ 75 /* 76 * Even if leading dots are allowed, don't allow "." 77 * as a component (".." is prevented by a rule above). 78 */ 79 if (refname[1] == '\0') 80 return -1; /* Component equals ".". */ 81 } 82 if (cp - refname >= 5 && !memcmp(cp - 5, ".lock", 5)) 83 return -1; /* Refname ends with ".lock". */ 84 return cp - refname; 85} 86 87int check_refname_format(const char *refname, int flags) 88{ 89 int component_len, component_count = 0; 90 91 if (!strcmp(refname, "@")) 92 /* Refname is a single character '@'. */ 93 return -1; 94 95 while (1) { 96 /* We are at the start of a path component. */ 97 component_len = check_refname_component(refname, flags); 98 if (component_len <= 0) { 99 if ((flags & REFNAME_REFSPEC_PATTERN) && 100 refname[0] == '*' && 101 (refname[1] == '\0' || refname[1] == '/')) { 102 /* Accept one wildcard as a full refname component. */ 103 flags &= ~REFNAME_REFSPEC_PATTERN; 104 component_len = 1; 105 } else { 106 return -1; 107 } 108 } 109 component_count++; 110 if (refname[component_len] == '\0') 111 break; 112 /* Skip to next component. */ 113 refname += component_len + 1; 114 } 115 116 if (refname[component_len - 1] == '.') 117 return -1; /* Refname ends with '.'. */ 118 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2) 119 return -1; /* Refname has only one component. */ 120 return 0; 121} 122 123struct ref_entry; 124 125/* 126 * Information used (along with the information in ref_entry) to 127 * describe a single cached reference. This data structure only 128 * occurs embedded in a union in struct ref_entry, and only when 129 * (ref_entry->flag & REF_DIR) is zero. 130 */ 131struct ref_value { 132 /* 133 * The name of the object to which this reference resolves 134 * (which may be a tag object). If REF_ISBROKEN, this is 135 * null. If REF_ISSYMREF, then this is the name of the object 136 * referred to by the last reference in the symlink chain. 137 */ 138 unsigned char sha1[20]; 139 140 /* 141 * If REF_KNOWS_PEELED, then this field holds the peeled value 142 * of this reference, or null if the reference is known not to 143 * be peelable. See the documentation for peel_ref() for an 144 * exact definition of "peelable". 145 */ 146 unsigned char peeled[20]; 147}; 148 149struct ref_cache; 150 151/* 152 * Information used (along with the information in ref_entry) to 153 * describe a level in the hierarchy of references. This data 154 * structure only occurs embedded in a union in struct ref_entry, and 155 * only when (ref_entry.flag & REF_DIR) is set. In that case, 156 * (ref_entry.flag & REF_INCOMPLETE) determines whether the references 157 * in the directory have already been read: 158 * 159 * (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose 160 * or packed references, already read. 161 * 162 * (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose 163 * references that hasn't been read yet (nor has any of its 164 * subdirectories). 165 * 166 * Entries within a directory are stored within a growable array of 167 * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i < 168 * sorted are sorted by their component name in strcmp() order and the 169 * remaining entries are unsorted. 170 * 171 * Loose references are read lazily, one directory at a time. When a 172 * directory of loose references is read, then all of the references 173 * in that directory are stored, and REF_INCOMPLETE stubs are created 174 * for any subdirectories, but the subdirectories themselves are not 175 * read. The reading is triggered by get_ref_dir(). 176 */ 177struct ref_dir { 178 int nr, alloc; 179 180 /* 181 * Entries with index 0 <= i < sorted are sorted by name. New 182 * entries are appended to the list unsorted, and are sorted 183 * only when required; thus we avoid the need to sort the list 184 * after the addition of every reference. 185 */ 186 int sorted; 187 188 /* A pointer to the ref_cache that contains this ref_dir. */ 189 struct ref_cache *ref_cache; 190 191 struct ref_entry **entries; 192}; 193 194/* 195 * Bit values for ref_entry::flag. REF_ISSYMREF=0x01, 196 * REF_ISPACKED=0x02, and REF_ISBROKEN=0x04 are public values; see 197 * refs.h. 198 */ 199 200/* 201 * The field ref_entry->u.value.peeled of this value entry contains 202 * the correct peeled value for the reference, which might be 203 * null_sha1 if the reference is not a tag or if it is broken. 204 */ 205#define REF_KNOWS_PEELED 0x08 206 207/* ref_entry represents a directory of references */ 208#define REF_DIR 0x10 209 210/* 211 * Entry has not yet been read from disk (used only for REF_DIR 212 * entries representing loose references) 213 */ 214#define REF_INCOMPLETE 0x20 215 216/* 217 * A ref_entry represents either a reference or a "subdirectory" of 218 * references. 219 * 220 * Each directory in the reference namespace is represented by a 221 * ref_entry with (flags & REF_DIR) set and containing a subdir member 222 * that holds the entries in that directory that have been read so 223 * far. If (flags & REF_INCOMPLETE) is set, then the directory and 224 * its subdirectories haven't been read yet. REF_INCOMPLETE is only 225 * used for loose reference directories. 226 * 227 * References are represented by a ref_entry with (flags & REF_DIR) 228 * unset and a value member that describes the reference's value. The 229 * flag member is at the ref_entry level, but it is also needed to 230 * interpret the contents of the value field (in other words, a 231 * ref_value object is not very much use without the enclosing 232 * ref_entry). 233 * 234 * Reference names cannot end with slash and directories' names are 235 * always stored with a trailing slash (except for the top-level 236 * directory, which is always denoted by ""). This has two nice 237 * consequences: (1) when the entries in each subdir are sorted 238 * lexicographically by name (as they usually are), the references in 239 * a whole tree can be generated in lexicographic order by traversing 240 * the tree in left-to-right, depth-first order; (2) the names of 241 * references and subdirectories cannot conflict, and therefore the 242 * presence of an empty subdirectory does not block the creation of a 243 * similarly-named reference. (The fact that reference names with the 244 * same leading components can conflict *with each other* is a 245 * separate issue that is regulated by is_refname_available().) 246 * 247 * Please note that the name field contains the fully-qualified 248 * reference (or subdirectory) name. Space could be saved by only 249 * storing the relative names. But that would require the full names 250 * to be generated on the fly when iterating in do_for_each_ref(), and 251 * would break callback functions, who have always been able to assume 252 * that the name strings that they are passed will not be freed during 253 * the iteration. 254 */ 255struct ref_entry { 256 unsigned char flag; /* ISSYMREF? ISPACKED? */ 257 union { 258 struct ref_value value; /* if not (flags&REF_DIR) */ 259 struct ref_dir subdir; /* if (flags&REF_DIR) */ 260 } u; 261 /* 262 * The full name of the reference (e.g., "refs/heads/master") 263 * or the full name of the directory with a trailing slash 264 * (e.g., "refs/heads/"): 265 */ 266 char name[FLEX_ARRAY]; 267}; 268 269static void read_loose_refs(const char *dirname, struct ref_dir *dir); 270 271static struct ref_dir *get_ref_dir(struct ref_entry *entry) 272{ 273 struct ref_dir *dir; 274 assert(entry->flag & REF_DIR); 275 dir = &entry->u.subdir; 276 if (entry->flag & REF_INCOMPLETE) { 277 read_loose_refs(entry->name, dir); 278 entry->flag &= ~REF_INCOMPLETE; 279 } 280 return dir; 281} 282 283static struct ref_entry *create_ref_entry(const char *refname, 284 const unsigned char *sha1, int flag, 285 int check_name) 286{ 287 int len; 288 struct ref_entry *ref; 289 290 if (check_name && 291 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT)) 292 die("Reference has invalid format: '%s'", refname); 293 len = strlen(refname) + 1; 294 ref = xmalloc(sizeof(struct ref_entry) + len); 295 hashcpy(ref->u.value.sha1, sha1); 296 hashclr(ref->u.value.peeled); 297 memcpy(ref->name, refname, len); 298 ref->flag = flag; 299 return ref; 300} 301 302static void clear_ref_dir(struct ref_dir *dir); 303 304static void free_ref_entry(struct ref_entry *entry) 305{ 306 if (entry->flag & REF_DIR) { 307 /* 308 * Do not use get_ref_dir() here, as that might 309 * trigger the reading of loose refs. 310 */ 311 clear_ref_dir(&entry->u.subdir); 312 } 313 free(entry); 314} 315 316/* 317 * Add a ref_entry to the end of dir (unsorted). Entry is always 318 * stored directly in dir; no recursion into subdirectories is 319 * done. 320 */ 321static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry) 322{ 323 ALLOC_GROW(dir->entries, dir->nr + 1, dir->alloc); 324 dir->entries[dir->nr++] = entry; 325 /* optimize for the case that entries are added in order */ 326 if (dir->nr == 1 || 327 (dir->nr == dir->sorted + 1 && 328 strcmp(dir->entries[dir->nr - 2]->name, 329 dir->entries[dir->nr - 1]->name) < 0)) 330 dir->sorted = dir->nr; 331} 332 333/* 334 * Clear and free all entries in dir, recursively. 335 */ 336static void clear_ref_dir(struct ref_dir *dir) 337{ 338 int i; 339 for (i = 0; i < dir->nr; i++) 340 free_ref_entry(dir->entries[i]); 341 free(dir->entries); 342 dir->sorted = dir->nr = dir->alloc = 0; 343 dir->entries = NULL; 344} 345 346/* 347 * Create a struct ref_entry object for the specified dirname. 348 * dirname is the name of the directory with a trailing slash (e.g., 349 * "refs/heads/") or "" for the top-level directory. 350 */ 351static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache, 352 const char *dirname, size_t len, 353 int incomplete) 354{ 355 struct ref_entry *direntry; 356 direntry = xcalloc(1, sizeof(struct ref_entry) + len + 1); 357 memcpy(direntry->name, dirname, len); 358 direntry->name[len] = '\0'; 359 direntry->u.subdir.ref_cache = ref_cache; 360 direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE : 0); 361 return direntry; 362} 363 364static int ref_entry_cmp(const void *a, const void *b) 365{ 366 struct ref_entry *one = *(struct ref_entry **)a; 367 struct ref_entry *two = *(struct ref_entry **)b; 368 return strcmp(one->name, two->name); 369} 370 371static void sort_ref_dir(struct ref_dir *dir); 372 373struct string_slice { 374 size_t len; 375 const char *str; 376}; 377 378static int ref_entry_cmp_sslice(const void *key_, const void *ent_) 379{ 380 const struct string_slice *key = key_; 381 const struct ref_entry *ent = *(const struct ref_entry * const *)ent_; 382 int cmp = strncmp(key->str, ent->name, key->len); 383 if (cmp) 384 return cmp; 385 return '\0' - (unsigned char)ent->name[key->len]; 386} 387 388/* 389 * Return the index of the entry with the given refname from the 390 * ref_dir (non-recursively), sorting dir if necessary. Return -1 if 391 * no such entry is found. dir must already be complete. 392 */ 393static int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len) 394{ 395 struct ref_entry **r; 396 struct string_slice key; 397 398 if (refname == NULL || !dir->nr) 399 return -1; 400 401 sort_ref_dir(dir); 402 key.len = len; 403 key.str = refname; 404 r = bsearch(&key, dir->entries, dir->nr, sizeof(*dir->entries), 405 ref_entry_cmp_sslice); 406 407 if (r == NULL) 408 return -1; 409 410 return r - dir->entries; 411} 412 413/* 414 * Search for a directory entry directly within dir (without 415 * recursing). Sort dir if necessary. subdirname must be a directory 416 * name (i.e., end in '/'). If mkdir is set, then create the 417 * directory if it is missing; otherwise, return NULL if the desired 418 * directory cannot be found. dir must already be complete. 419 */ 420static struct ref_dir *search_for_subdir(struct ref_dir *dir, 421 const char *subdirname, size_t len, 422 int mkdir) 423{ 424 int entry_index = search_ref_dir(dir, subdirname, len); 425 struct ref_entry *entry; 426 if (entry_index == -1) { 427 if (!mkdir) 428 return NULL; 429 /* 430 * Since dir is complete, the absence of a subdir 431 * means that the subdir really doesn't exist; 432 * therefore, create an empty record for it but mark 433 * the record complete. 434 */ 435 entry = create_dir_entry(dir->ref_cache, subdirname, len, 0); 436 add_entry_to_dir(dir, entry); 437 } else { 438 entry = dir->entries[entry_index]; 439 } 440 return get_ref_dir(entry); 441} 442 443/* 444 * If refname is a reference name, find the ref_dir within the dir 445 * tree that should hold refname. If refname is a directory name 446 * (i.e., ends in '/'), then return that ref_dir itself. dir must 447 * represent the top-level directory and must already be complete. 448 * Sort ref_dirs and recurse into subdirectories as necessary. If 449 * mkdir is set, then create any missing directories; otherwise, 450 * return NULL if the desired directory cannot be found. 451 */ 452static struct ref_dir *find_containing_dir(struct ref_dir *dir, 453 const char *refname, int mkdir) 454{ 455 const char *slash; 456 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) { 457 size_t dirnamelen = slash - refname + 1; 458 struct ref_dir *subdir; 459 subdir = search_for_subdir(dir, refname, dirnamelen, mkdir); 460 if (!subdir) { 461 dir = NULL; 462 break; 463 } 464 dir = subdir; 465 } 466 467 return dir; 468} 469 470/* 471 * Find the value entry with the given name in dir, sorting ref_dirs 472 * and recursing into subdirectories as necessary. If the name is not 473 * found or it corresponds to a directory entry, return NULL. 474 */ 475static struct ref_entry *find_ref(struct ref_dir *dir, const char *refname) 476{ 477 int entry_index; 478 struct ref_entry *entry; 479 dir = find_containing_dir(dir, refname, 0); 480 if (!dir) 481 return NULL; 482 entry_index = search_ref_dir(dir, refname, strlen(refname)); 483 if (entry_index == -1) 484 return NULL; 485 entry = dir->entries[entry_index]; 486 return (entry->flag & REF_DIR) ? NULL : entry; 487} 488 489/* 490 * Remove the entry with the given name from dir, recursing into 491 * subdirectories as necessary. If refname is the name of a directory 492 * (i.e., ends with '/'), then remove the directory and its contents. 493 * If the removal was successful, return the number of entries 494 * remaining in the directory entry that contained the deleted entry. 495 * If the name was not found, return -1. Please note that this 496 * function only deletes the entry from the cache; it does not delete 497 * it from the filesystem or ensure that other cache entries (which 498 * might be symbolic references to the removed entry) are updated. 499 * Nor does it remove any containing dir entries that might be made 500 * empty by the removal. dir must represent the top-level directory 501 * and must already be complete. 502 */ 503static int remove_entry(struct ref_dir *dir, const char *refname) 504{ 505 int refname_len = strlen(refname); 506 int entry_index; 507 struct ref_entry *entry; 508 int is_dir = refname[refname_len - 1] == '/'; 509 if (is_dir) { 510 /* 511 * refname represents a reference directory. Remove 512 * the trailing slash; otherwise we will get the 513 * directory *representing* refname rather than the 514 * one *containing* it. 515 */ 516 char *dirname = xmemdupz(refname, refname_len - 1); 517 dir = find_containing_dir(dir, dirname, 0); 518 free(dirname); 519 } else { 520 dir = find_containing_dir(dir, refname, 0); 521 } 522 if (!dir) 523 return -1; 524 entry_index = search_ref_dir(dir, refname, refname_len); 525 if (entry_index == -1) 526 return -1; 527 entry = dir->entries[entry_index]; 528 529 memmove(&dir->entries[entry_index], 530 &dir->entries[entry_index + 1], 531 (dir->nr - entry_index - 1) * sizeof(*dir->entries) 532 ); 533 dir->nr--; 534 if (dir->sorted > entry_index) 535 dir->sorted--; 536 free_ref_entry(entry); 537 return dir->nr; 538} 539 540/* 541 * Add a ref_entry to the ref_dir (unsorted), recursing into 542 * subdirectories as necessary. dir must represent the top-level 543 * directory. Return 0 on success. 544 */ 545static int add_ref(struct ref_dir *dir, struct ref_entry *ref) 546{ 547 dir = find_containing_dir(dir, ref->name, 1); 548 if (!dir) 549 return -1; 550 add_entry_to_dir(dir, ref); 551 return 0; 552} 553 554/* 555 * Emit a warning and return true iff ref1 and ref2 have the same name 556 * and the same sha1. Die if they have the same name but different 557 * sha1s. 558 */ 559static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2) 560{ 561 if (strcmp(ref1->name, ref2->name)) 562 return 0; 563 564 /* Duplicate name; make sure that they don't conflict: */ 565 566 if ((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR)) 567 /* This is impossible by construction */ 568 die("Reference directory conflict: %s", ref1->name); 569 570 if (hashcmp(ref1->u.value.sha1, ref2->u.value.sha1)) 571 die("Duplicated ref, and SHA1s don't match: %s", ref1->name); 572 573 warning("Duplicated ref: %s", ref1->name); 574 return 1; 575} 576 577/* 578 * Sort the entries in dir non-recursively (if they are not already 579 * sorted) and remove any duplicate entries. 580 */ 581static void sort_ref_dir(struct ref_dir *dir) 582{ 583 int i, j; 584 struct ref_entry *last = NULL; 585 586 /* 587 * This check also prevents passing a zero-length array to qsort(), 588 * which is a problem on some platforms. 589 */ 590 if (dir->sorted == dir->nr) 591 return; 592 593 qsort(dir->entries, dir->nr, sizeof(*dir->entries), ref_entry_cmp); 594 595 /* Remove any duplicates: */ 596 for (i = 0, j = 0; j < dir->nr; j++) { 597 struct ref_entry *entry = dir->entries[j]; 598 if (last && is_dup_ref(last, entry)) 599 free_ref_entry(entry); 600 else 601 last = dir->entries[i++] = entry; 602 } 603 dir->sorted = dir->nr = i; 604} 605 606/* Include broken references in a do_for_each_ref*() iteration: */ 607#define DO_FOR_EACH_INCLUDE_BROKEN 0x01 608 609/* 610 * Return true iff the reference described by entry can be resolved to 611 * an object in the database. Emit a warning if the referred-to 612 * object does not exist. 613 */ 614static int ref_resolves_to_object(struct ref_entry *entry) 615{ 616 if (entry->flag & REF_ISBROKEN) 617 return 0; 618 if (!has_sha1_file(entry->u.value.sha1)) { 619 error("%s does not point to a valid object!", entry->name); 620 return 0; 621 } 622 return 1; 623} 624 625/* 626 * current_ref is a performance hack: when iterating over references 627 * using the for_each_ref*() functions, current_ref is set to the 628 * current reference's entry before calling the callback function. If 629 * the callback function calls peel_ref(), then peel_ref() first 630 * checks whether the reference to be peeled is the current reference 631 * (it usually is) and if so, returns that reference's peeled version 632 * if it is available. This avoids a refname lookup in a common case. 633 */ 634static struct ref_entry *current_ref; 635 636typedef int each_ref_entry_fn(struct ref_entry *entry, void *cb_data); 637 638struct ref_entry_cb { 639 const char *base; 640 int trim; 641 int flags; 642 each_ref_fn *fn; 643 void *cb_data; 644}; 645 646/* 647 * Handle one reference in a do_for_each_ref*()-style iteration, 648 * calling an each_ref_fn for each entry. 649 */ 650static int do_one_ref(struct ref_entry *entry, void *cb_data) 651{ 652 struct ref_entry_cb *data = cb_data; 653 struct ref_entry *old_current_ref; 654 int retval; 655 656 if (!starts_with(entry->name, data->base)) 657 return 0; 658 659 if (!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 660 !ref_resolves_to_object(entry)) 661 return 0; 662 663 /* Store the old value, in case this is a recursive call: */ 664 old_current_ref = current_ref; 665 current_ref = entry; 666 retval = data->fn(entry->name + data->trim, entry->u.value.sha1, 667 entry->flag, data->cb_data); 668 current_ref = old_current_ref; 669 return retval; 670} 671 672/* 673 * Call fn for each reference in dir that has index in the range 674 * offset <= index < dir->nr. Recurse into subdirectories that are in 675 * that index range, sorting them before iterating. This function 676 * does not sort dir itself; it should be sorted beforehand. fn is 677 * called for all references, including broken ones. 678 */ 679static int do_for_each_entry_in_dir(struct ref_dir *dir, int offset, 680 each_ref_entry_fn fn, void *cb_data) 681{ 682 int i; 683 assert(dir->sorted == dir->nr); 684 for (i = offset; i < dir->nr; i++) { 685 struct ref_entry *entry = dir->entries[i]; 686 int retval; 687 if (entry->flag & REF_DIR) { 688 struct ref_dir *subdir = get_ref_dir(entry); 689 sort_ref_dir(subdir); 690 retval = do_for_each_entry_in_dir(subdir, 0, fn, cb_data); 691 } else { 692 retval = fn(entry, cb_data); 693 } 694 if (retval) 695 return retval; 696 } 697 return 0; 698} 699 700/* 701 * Call fn for each reference in the union of dir1 and dir2, in order 702 * by refname. Recurse into subdirectories. If a value entry appears 703 * in both dir1 and dir2, then only process the version that is in 704 * dir2. The input dirs must already be sorted, but subdirs will be 705 * sorted as needed. fn is called for all references, including 706 * broken ones. 707 */ 708static int do_for_each_entry_in_dirs(struct ref_dir *dir1, 709 struct ref_dir *dir2, 710 each_ref_entry_fn fn, void *cb_data) 711{ 712 int retval; 713 int i1 = 0, i2 = 0; 714 715 assert(dir1->sorted == dir1->nr); 716 assert(dir2->sorted == dir2->nr); 717 while (1) { 718 struct ref_entry *e1, *e2; 719 int cmp; 720 if (i1 == dir1->nr) { 721 return do_for_each_entry_in_dir(dir2, i2, fn, cb_data); 722 } 723 if (i2 == dir2->nr) { 724 return do_for_each_entry_in_dir(dir1, i1, fn, cb_data); 725 } 726 e1 = dir1->entries[i1]; 727 e2 = dir2->entries[i2]; 728 cmp = strcmp(e1->name, e2->name); 729 if (cmp == 0) { 730 if ((e1->flag & REF_DIR) && (e2->flag & REF_DIR)) { 731 /* Both are directories; descend them in parallel. */ 732 struct ref_dir *subdir1 = get_ref_dir(e1); 733 struct ref_dir *subdir2 = get_ref_dir(e2); 734 sort_ref_dir(subdir1); 735 sort_ref_dir(subdir2); 736 retval = do_for_each_entry_in_dirs( 737 subdir1, subdir2, fn, cb_data); 738 i1++; 739 i2++; 740 } else if (!(e1->flag & REF_DIR) && !(e2->flag & REF_DIR)) { 741 /* Both are references; ignore the one from dir1. */ 742 retval = fn(e2, cb_data); 743 i1++; 744 i2++; 745 } else { 746 die("conflict between reference and directory: %s", 747 e1->name); 748 } 749 } else { 750 struct ref_entry *e; 751 if (cmp < 0) { 752 e = e1; 753 i1++; 754 } else { 755 e = e2; 756 i2++; 757 } 758 if (e->flag & REF_DIR) { 759 struct ref_dir *subdir = get_ref_dir(e); 760 sort_ref_dir(subdir); 761 retval = do_for_each_entry_in_dir( 762 subdir, 0, fn, cb_data); 763 } else { 764 retval = fn(e, cb_data); 765 } 766 } 767 if (retval) 768 return retval; 769 } 770} 771 772/* 773 * Load all of the refs from the dir into our in-memory cache. The hard work 774 * of loading loose refs is done by get_ref_dir(), so we just need to recurse 775 * through all of the sub-directories. We do not even need to care about 776 * sorting, as traversal order does not matter to us. 777 */ 778static void prime_ref_dir(struct ref_dir *dir) 779{ 780 int i; 781 for (i = 0; i < dir->nr; i++) { 782 struct ref_entry *entry = dir->entries[i]; 783 if (entry->flag & REF_DIR) 784 prime_ref_dir(get_ref_dir(entry)); 785 } 786} 787/* 788 * Return true iff refname1 and refname2 conflict with each other. 789 * Two reference names conflict if one of them exactly matches the 790 * leading components of the other; e.g., "foo/bar" conflicts with 791 * both "foo" and with "foo/bar/baz" but not with "foo/bar" or 792 * "foo/barbados". 793 */ 794static int names_conflict(const char *refname1, const char *refname2) 795{ 796 for (; *refname1 && *refname1 == *refname2; refname1++, refname2++) 797 ; 798 return (*refname1 == '\0' && *refname2 == '/') 799 || (*refname1 == '/' && *refname2 == '\0'); 800} 801 802struct name_conflict_cb { 803 const char *refname; 804 const char *oldrefname; 805 const char *conflicting_refname; 806}; 807 808static int name_conflict_fn(struct ref_entry *entry, void *cb_data) 809{ 810 struct name_conflict_cb *data = (struct name_conflict_cb *)cb_data; 811 if (data->oldrefname && !strcmp(data->oldrefname, entry->name)) 812 return 0; 813 if (names_conflict(data->refname, entry->name)) { 814 data->conflicting_refname = entry->name; 815 return 1; 816 } 817 return 0; 818} 819 820/* 821 * Return true iff a reference named refname could be created without 822 * conflicting with the name of an existing reference in dir. If 823 * oldrefname is non-NULL, ignore potential conflicts with oldrefname 824 * (e.g., because oldrefname is scheduled for deletion in the same 825 * operation). 826 */ 827static int is_refname_available(const char *refname, const char *oldrefname, 828 struct ref_dir *dir) 829{ 830 struct name_conflict_cb data; 831 data.refname = refname; 832 data.oldrefname = oldrefname; 833 data.conflicting_refname = NULL; 834 835 sort_ref_dir(dir); 836 if (do_for_each_entry_in_dir(dir, 0, name_conflict_fn, &data)) { 837 error("'%s' exists; cannot create '%s'", 838 data.conflicting_refname, refname); 839 return 0; 840 } 841 return 1; 842} 843 844struct packed_ref_cache { 845 struct ref_entry *root; 846 847 /* 848 * Count of references to the data structure in this instance, 849 * including the pointer from ref_cache::packed if any. The 850 * data will not be freed as long as the reference count is 851 * nonzero. 852 */ 853 unsigned int referrers; 854 855 /* 856 * Iff the packed-refs file associated with this instance is 857 * currently locked for writing, this points at the associated 858 * lock (which is owned by somebody else). The referrer count 859 * is also incremented when the file is locked and decremented 860 * when it is unlocked. 861 */ 862 struct lock_file *lock; 863 864 /* The metadata from when this packed-refs cache was read */ 865 struct stat_validity validity; 866}; 867 868/* 869 * Future: need to be in "struct repository" 870 * when doing a full libification. 871 */ 872static struct ref_cache { 873 struct ref_cache *next; 874 struct ref_entry *loose; 875 struct packed_ref_cache *packed; 876 /* 877 * The submodule name, or "" for the main repo. We allocate 878 * length 1 rather than FLEX_ARRAY so that the main ref_cache 879 * is initialized correctly. 880 */ 881 char name[1]; 882} ref_cache, *submodule_ref_caches; 883 884/* Lock used for the main packed-refs file: */ 885static struct lock_file packlock; 886 887/* 888 * Increment the reference count of *packed_refs. 889 */ 890static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs) 891{ 892 packed_refs->referrers++; 893} 894 895/* 896 * Decrease the reference count of *packed_refs. If it goes to zero, 897 * free *packed_refs and return true; otherwise return false. 898 */ 899static int release_packed_ref_cache(struct packed_ref_cache *packed_refs) 900{ 901 if (!--packed_refs->referrers) { 902 free_ref_entry(packed_refs->root); 903 stat_validity_clear(&packed_refs->validity); 904 free(packed_refs); 905 return 1; 906 } else { 907 return 0; 908 } 909} 910 911static void clear_packed_ref_cache(struct ref_cache *refs) 912{ 913 if (refs->packed) { 914 struct packed_ref_cache *packed_refs = refs->packed; 915 916 if (packed_refs->lock) 917 die("internal error: packed-ref cache cleared while locked"); 918 refs->packed = NULL; 919 release_packed_ref_cache(packed_refs); 920 } 921} 922 923static void clear_loose_ref_cache(struct ref_cache *refs) 924{ 925 if (refs->loose) { 926 free_ref_entry(refs->loose); 927 refs->loose = NULL; 928 } 929} 930 931static struct ref_cache *create_ref_cache(const char *submodule) 932{ 933 int len; 934 struct ref_cache *refs; 935 if (!submodule) 936 submodule = ""; 937 len = strlen(submodule) + 1; 938 refs = xcalloc(1, sizeof(struct ref_cache) + len); 939 memcpy(refs->name, submodule, len); 940 return refs; 941} 942 943/* 944 * Return a pointer to a ref_cache for the specified submodule. For 945 * the main repository, use submodule==NULL. The returned structure 946 * will be allocated and initialized but not necessarily populated; it 947 * should not be freed. 948 */ 949static struct ref_cache *get_ref_cache(const char *submodule) 950{ 951 struct ref_cache *refs; 952 953 if (!submodule || !*submodule) 954 return &ref_cache; 955 956 for (refs = submodule_ref_caches; refs; refs = refs->next) 957 if (!strcmp(submodule, refs->name)) 958 return refs; 959 960 refs = create_ref_cache(submodule); 961 refs->next = submodule_ref_caches; 962 submodule_ref_caches = refs; 963 return refs; 964} 965 966/* The length of a peeled reference line in packed-refs, including EOL: */ 967#define PEELED_LINE_LENGTH 42 968 969/* 970 * The packed-refs header line that we write out. Perhaps other 971 * traits will be added later. The trailing space is required. 972 */ 973static const char PACKED_REFS_HEADER[] = 974 "# pack-refs with: peeled fully-peeled \n"; 975 976/* 977 * Parse one line from a packed-refs file. Write the SHA1 to sha1. 978 * Return a pointer to the refname within the line (null-terminated), 979 * or NULL if there was a problem. 980 */ 981static const char *parse_ref_line(char *line, unsigned char *sha1) 982{ 983 /* 984 * 42: the answer to everything. 985 * 986 * In this case, it happens to be the answer to 987 * 40 (length of sha1 hex representation) 988 * +1 (space in between hex and name) 989 * +1 (newline at the end of the line) 990 */ 991 int len = strlen(line) - 42; 992 993 if (len <= 0) 994 return NULL; 995 if (get_sha1_hex(line, sha1) < 0) 996 return NULL; 997 if (!isspace(line[40])) 998 return NULL; 999 line += 41;1000 if (isspace(*line))1001 return NULL;1002 if (line[len] != '\n')1003 return NULL;1004 line[len] = 0;10051006 return line;1007}10081009/*1010 * Read f, which is a packed-refs file, into dir.1011 *1012 * A comment line of the form "# pack-refs with: " may contain zero or1013 * more traits. We interpret the traits as follows:1014 *1015 * No traits:1016 *1017 * Probably no references are peeled. But if the file contains a1018 * peeled value for a reference, we will use it.1019 *1020 * peeled:1021 *1022 * References under "refs/tags/", if they *can* be peeled, *are*1023 * peeled in this file. References outside of "refs/tags/" are1024 * probably not peeled even if they could have been, but if we find1025 * a peeled value for such a reference we will use it.1026 *1027 * fully-peeled:1028 *1029 * All references in the file that can be peeled are peeled.1030 * Inversely (and this is more important), any references in the1031 * file for which no peeled value is recorded is not peelable. This1032 * trait should typically be written alongside "peeled" for1033 * compatibility with older clients, but we do not require it1034 * (i.e., "peeled" is a no-op if "fully-peeled" is set).1035 */1036static void read_packed_refs(FILE *f, struct ref_dir *dir)1037{1038 struct ref_entry *last = NULL;1039 char refline[PATH_MAX];1040 enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;10411042 while (fgets(refline, sizeof(refline), f)) {1043 unsigned char sha1[20];1044 const char *refname;1045 static const char header[] = "# pack-refs with:";10461047 if (!strncmp(refline, header, sizeof(header)-1)) {1048 const char *traits = refline + sizeof(header) - 1;1049 if (strstr(traits, " fully-peeled "))1050 peeled = PEELED_FULLY;1051 else if (strstr(traits, " peeled "))1052 peeled = PEELED_TAGS;1053 /* perhaps other traits later as well */1054 continue;1055 }10561057 refname = parse_ref_line(refline, sha1);1058 if (refname) {1059 last = create_ref_entry(refname, sha1, REF_ISPACKED, 1);1060 if (peeled == PEELED_FULLY ||1061 (peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))1062 last->flag |= REF_KNOWS_PEELED;1063 add_ref(dir, last);1064 continue;1065 }1066 if (last &&1067 refline[0] == '^' &&1068 strlen(refline) == PEELED_LINE_LENGTH &&1069 refline[PEELED_LINE_LENGTH - 1] == '\n' &&1070 !get_sha1_hex(refline + 1, sha1)) {1071 hashcpy(last->u.value.peeled, sha1);1072 /*1073 * Regardless of what the file header said,1074 * we definitely know the value of *this*1075 * reference:1076 */1077 last->flag |= REF_KNOWS_PEELED;1078 }1079 }1080}10811082/*1083 * Get the packed_ref_cache for the specified ref_cache, creating it1084 * if necessary.1085 */1086static struct packed_ref_cache *get_packed_ref_cache(struct ref_cache *refs)1087{1088 const char *packed_refs_file;10891090 if (*refs->name)1091 packed_refs_file = git_path_submodule(refs->name, "packed-refs");1092 else1093 packed_refs_file = git_path("packed-refs");10941095 if (refs->packed &&1096 !stat_validity_check(&refs->packed->validity, packed_refs_file))1097 clear_packed_ref_cache(refs);10981099 if (!refs->packed) {1100 FILE *f;11011102 refs->packed = xcalloc(1, sizeof(*refs->packed));1103 acquire_packed_ref_cache(refs->packed);1104 refs->packed->root = create_dir_entry(refs, "", 0, 0);1105 f = fopen(packed_refs_file, "r");1106 if (f) {1107 stat_validity_update(&refs->packed->validity, fileno(f));1108 read_packed_refs(f, get_ref_dir(refs->packed->root));1109 fclose(f);1110 }1111 }1112 return refs->packed;1113}11141115static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)1116{1117 return get_ref_dir(packed_ref_cache->root);1118}11191120static struct ref_dir *get_packed_refs(struct ref_cache *refs)1121{1122 return get_packed_ref_dir(get_packed_ref_cache(refs));1123}11241125void add_packed_ref(const char *refname, const unsigned char *sha1)1126{1127 struct packed_ref_cache *packed_ref_cache =1128 get_packed_ref_cache(&ref_cache);11291130 if (!packed_ref_cache->lock)1131 die("internal error: packed refs not locked");1132 add_ref(get_packed_ref_dir(packed_ref_cache),1133 create_ref_entry(refname, sha1, REF_ISPACKED, 1));1134}11351136/*1137 * Read the loose references from the namespace dirname into dir1138 * (without recursing). dirname must end with '/'. dir must be the1139 * directory entry corresponding to dirname.1140 */1141static void read_loose_refs(const char *dirname, struct ref_dir *dir)1142{1143 struct ref_cache *refs = dir->ref_cache;1144 DIR *d;1145 const char *path;1146 struct dirent *de;1147 int dirnamelen = strlen(dirname);1148 struct strbuf refname;11491150 if (*refs->name)1151 path = git_path_submodule(refs->name, "%s", dirname);1152 else1153 path = git_path("%s", dirname);11541155 d = opendir(path);1156 if (!d)1157 return;11581159 strbuf_init(&refname, dirnamelen + 257);1160 strbuf_add(&refname, dirname, dirnamelen);11611162 while ((de = readdir(d)) != NULL) {1163 unsigned char sha1[20];1164 struct stat st;1165 int flag;1166 const char *refdir;11671168 if (de->d_name[0] == '.')1169 continue;1170 if (ends_with(de->d_name, ".lock"))1171 continue;1172 strbuf_addstr(&refname, de->d_name);1173 refdir = *refs->name1174 ? git_path_submodule(refs->name, "%s", refname.buf)1175 : git_path("%s", refname.buf);1176 if (stat(refdir, &st) < 0) {1177 ; /* silently ignore */1178 } else if (S_ISDIR(st.st_mode)) {1179 strbuf_addch(&refname, '/');1180 add_entry_to_dir(dir,1181 create_dir_entry(refs, refname.buf,1182 refname.len, 1));1183 } else {1184 if (*refs->name) {1185 hashclr(sha1);1186 flag = 0;1187 if (resolve_gitlink_ref(refs->name, refname.buf, sha1) < 0) {1188 hashclr(sha1);1189 flag |= REF_ISBROKEN;1190 }1191 } else if (read_ref_full(refname.buf, sha1, 1, &flag)) {1192 hashclr(sha1);1193 flag |= REF_ISBROKEN;1194 }1195 add_entry_to_dir(dir,1196 create_ref_entry(refname.buf, sha1, flag, 1));1197 }1198 strbuf_setlen(&refname, dirnamelen);1199 }1200 strbuf_release(&refname);1201 closedir(d);1202}12031204static struct ref_dir *get_loose_refs(struct ref_cache *refs)1205{1206 if (!refs->loose) {1207 /*1208 * Mark the top-level directory complete because we1209 * are about to read the only subdirectory that can1210 * hold references:1211 */1212 refs->loose = create_dir_entry(refs, "", 0, 0);1213 /*1214 * Create an incomplete entry for "refs/":1215 */1216 add_entry_to_dir(get_ref_dir(refs->loose),1217 create_dir_entry(refs, "refs/", 5, 1));1218 }1219 return get_ref_dir(refs->loose);1220}12211222/* We allow "recursive" symbolic refs. Only within reason, though */1223#define MAXDEPTH 51224#define MAXREFLEN (1024)12251226/*1227 * Called by resolve_gitlink_ref_recursive() after it failed to read1228 * from the loose refs in ref_cache refs. Find <refname> in the1229 * packed-refs file for the submodule.1230 */1231static int resolve_gitlink_packed_ref(struct ref_cache *refs,1232 const char *refname, unsigned char *sha1)1233{1234 struct ref_entry *ref;1235 struct ref_dir *dir = get_packed_refs(refs);12361237 ref = find_ref(dir, refname);1238 if (ref == NULL)1239 return -1;12401241 hashcpy(sha1, ref->u.value.sha1);1242 return 0;1243}12441245static int resolve_gitlink_ref_recursive(struct ref_cache *refs,1246 const char *refname, unsigned char *sha1,1247 int recursion)1248{1249 int fd, len;1250 char buffer[128], *p;1251 char *path;12521253 if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)1254 return -1;1255 path = *refs->name1256 ? git_path_submodule(refs->name, "%s", refname)1257 : git_path("%s", refname);1258 fd = open(path, O_RDONLY);1259 if (fd < 0)1260 return resolve_gitlink_packed_ref(refs, refname, sha1);12611262 len = read(fd, buffer, sizeof(buffer)-1);1263 close(fd);1264 if (len < 0)1265 return -1;1266 while (len && isspace(buffer[len-1]))1267 len--;1268 buffer[len] = 0;12691270 /* Was it a detached head or an old-fashioned symlink? */1271 if (!get_sha1_hex(buffer, sha1))1272 return 0;12731274 /* Symref? */1275 if (strncmp(buffer, "ref:", 4))1276 return -1;1277 p = buffer + 4;1278 while (isspace(*p))1279 p++;12801281 return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);1282}12831284int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)1285{1286 int len = strlen(path), retval;1287 char *submodule;1288 struct ref_cache *refs;12891290 while (len && path[len-1] == '/')1291 len--;1292 if (!len)1293 return -1;1294 submodule = xstrndup(path, len);1295 refs = get_ref_cache(submodule);1296 free(submodule);12971298 retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);1299 return retval;1300}13011302/*1303 * Return the ref_entry for the given refname from the packed1304 * references. If it does not exist, return NULL.1305 */1306static struct ref_entry *get_packed_ref(const char *refname)1307{1308 return find_ref(get_packed_refs(&ref_cache), refname);1309}13101311/*1312 * A loose ref file doesn't exist; check for a packed ref. The1313 * options are forwarded from resolve_safe_unsafe().1314 */1315static const char *handle_missing_loose_ref(const char *refname,1316 unsigned char *sha1,1317 int reading,1318 int *flag)1319{1320 struct ref_entry *entry;13211322 /*1323 * The loose reference file does not exist; check for a packed1324 * reference.1325 */1326 entry = get_packed_ref(refname);1327 if (entry) {1328 hashcpy(sha1, entry->u.value.sha1);1329 if (flag)1330 *flag |= REF_ISPACKED;1331 return refname;1332 }1333 /* The reference is not a packed reference, either. */1334 if (reading) {1335 return NULL;1336 } else {1337 hashclr(sha1);1338 return refname;1339 }1340}13411342/* This function needs to return a meaningful errno on failure */1343const char *resolve_ref_unsafe(const char *refname, unsigned char *sha1, int reading, int *flag)1344{1345 int depth = MAXDEPTH;1346 ssize_t len;1347 char buffer[256];1348 static char refname_buffer[256];13491350 if (flag)1351 *flag = 0;13521353 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {1354 errno = EINVAL;1355 return NULL;1356 }13571358 for (;;) {1359 char path[PATH_MAX];1360 struct stat st;1361 char *buf;1362 int fd;13631364 if (--depth < 0) {1365 errno = ELOOP;1366 return NULL;1367 }13681369 git_snpath(path, sizeof(path), "%s", refname);13701371 /*1372 * We might have to loop back here to avoid a race1373 * condition: first we lstat() the file, then we try1374 * to read it as a link or as a file. But if somebody1375 * changes the type of the file (file <-> directory1376 * <-> symlink) between the lstat() and reading, then1377 * we don't want to report that as an error but rather1378 * try again starting with the lstat().1379 */1380 stat_ref:1381 if (lstat(path, &st) < 0) {1382 if (errno == ENOENT)1383 return handle_missing_loose_ref(refname, sha1,1384 reading, flag);1385 else1386 return NULL;1387 }13881389 /* Follow "normalized" - ie "refs/.." symlinks by hand */1390 if (S_ISLNK(st.st_mode)) {1391 len = readlink(path, buffer, sizeof(buffer)-1);1392 if (len < 0) {1393 if (errno == ENOENT || errno == EINVAL)1394 /* inconsistent with lstat; retry */1395 goto stat_ref;1396 else1397 return NULL;1398 }1399 buffer[len] = 0;1400 if (starts_with(buffer, "refs/") &&1401 !check_refname_format(buffer, 0)) {1402 strcpy(refname_buffer, buffer);1403 refname = refname_buffer;1404 if (flag)1405 *flag |= REF_ISSYMREF;1406 continue;1407 }1408 }14091410 /* Is it a directory? */1411 if (S_ISDIR(st.st_mode)) {1412 errno = EISDIR;1413 return NULL;1414 }14151416 /*1417 * Anything else, just open it and try to use it as1418 * a ref1419 */1420 fd = open(path, O_RDONLY);1421 if (fd < 0) {1422 if (errno == ENOENT)1423 /* inconsistent with lstat; retry */1424 goto stat_ref;1425 else1426 return NULL;1427 }1428 len = read_in_full(fd, buffer, sizeof(buffer)-1);1429 if (len < 0) {1430 int save_errno = errno;1431 close(fd);1432 errno = save_errno;1433 return NULL;1434 }1435 close(fd);1436 while (len && isspace(buffer[len-1]))1437 len--;1438 buffer[len] = '\0';14391440 /*1441 * Is it a symbolic ref?1442 */1443 if (!starts_with(buffer, "ref:")) {1444 /*1445 * Please note that FETCH_HEAD has a second1446 * line containing other data.1447 */1448 if (get_sha1_hex(buffer, sha1) ||1449 (buffer[40] != '\0' && !isspace(buffer[40]))) {1450 if (flag)1451 *flag |= REF_ISBROKEN;1452 errno = EINVAL;1453 return NULL;1454 }1455 return refname;1456 }1457 if (flag)1458 *flag |= REF_ISSYMREF;1459 buf = buffer + 4;1460 while (isspace(*buf))1461 buf++;1462 if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {1463 if (flag)1464 *flag |= REF_ISBROKEN;1465 errno = EINVAL;1466 return NULL;1467 }1468 refname = strcpy(refname_buffer, buf);1469 }1470}14711472char *resolve_refdup(const char *ref, unsigned char *sha1, int reading, int *flag)1473{1474 const char *ret = resolve_ref_unsafe(ref, sha1, reading, flag);1475 return ret ? xstrdup(ret) : NULL;1476}14771478/* The argument to filter_refs */1479struct ref_filter {1480 const char *pattern;1481 each_ref_fn *fn;1482 void *cb_data;1483};14841485int read_ref_full(const char *refname, unsigned char *sha1, int reading, int *flags)1486{1487 if (resolve_ref_unsafe(refname, sha1, reading, flags))1488 return 0;1489 return -1;1490}14911492int read_ref(const char *refname, unsigned char *sha1)1493{1494 return read_ref_full(refname, sha1, 1, NULL);1495}14961497int ref_exists(const char *refname)1498{1499 unsigned char sha1[20];1500 return !!resolve_ref_unsafe(refname, sha1, 1, NULL);1501}15021503static int filter_refs(const char *refname, const unsigned char *sha1, int flags,1504 void *data)1505{1506 struct ref_filter *filter = (struct ref_filter *)data;1507 if (wildmatch(filter->pattern, refname, 0, NULL))1508 return 0;1509 return filter->fn(refname, sha1, flags, filter->cb_data);1510}15111512enum peel_status {1513 /* object was peeled successfully: */1514 PEEL_PEELED = 0,15151516 /*1517 * object cannot be peeled because the named object (or an1518 * object referred to by a tag in the peel chain), does not1519 * exist.1520 */1521 PEEL_INVALID = -1,15221523 /* object cannot be peeled because it is not a tag: */1524 PEEL_NON_TAG = -2,15251526 /* ref_entry contains no peeled value because it is a symref: */1527 PEEL_IS_SYMREF = -3,15281529 /*1530 * ref_entry cannot be peeled because it is broken (i.e., the1531 * symbolic reference cannot even be resolved to an object1532 * name):1533 */1534 PEEL_BROKEN = -41535};15361537/*1538 * Peel the named object; i.e., if the object is a tag, resolve the1539 * tag recursively until a non-tag is found. If successful, store the1540 * result to sha1 and return PEEL_PEELED. If the object is not a tag1541 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,1542 * and leave sha1 unchanged.1543 */1544static enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)1545{1546 struct object *o = lookup_unknown_object(name);15471548 if (o->type == OBJ_NONE) {1549 int type = sha1_object_info(name, NULL);1550 if (type < 0 || !object_as_type(o, type, 0))1551 return PEEL_INVALID;1552 }15531554 if (o->type != OBJ_TAG)1555 return PEEL_NON_TAG;15561557 o = deref_tag_noverify(o);1558 if (!o)1559 return PEEL_INVALID;15601561 hashcpy(sha1, o->sha1);1562 return PEEL_PEELED;1563}15641565/*1566 * Peel the entry (if possible) and return its new peel_status. If1567 * repeel is true, re-peel the entry even if there is an old peeled1568 * value that is already stored in it.1569 *1570 * It is OK to call this function with a packed reference entry that1571 * might be stale and might even refer to an object that has since1572 * been garbage-collected. In such a case, if the entry has1573 * REF_KNOWS_PEELED then leave the status unchanged and return1574 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.1575 */1576static enum peel_status peel_entry(struct ref_entry *entry, int repeel)1577{1578 enum peel_status status;15791580 if (entry->flag & REF_KNOWS_PEELED) {1581 if (repeel) {1582 entry->flag &= ~REF_KNOWS_PEELED;1583 hashclr(entry->u.value.peeled);1584 } else {1585 return is_null_sha1(entry->u.value.peeled) ?1586 PEEL_NON_TAG : PEEL_PEELED;1587 }1588 }1589 if (entry->flag & REF_ISBROKEN)1590 return PEEL_BROKEN;1591 if (entry->flag & REF_ISSYMREF)1592 return PEEL_IS_SYMREF;15931594 status = peel_object(entry->u.value.sha1, entry->u.value.peeled);1595 if (status == PEEL_PEELED || status == PEEL_NON_TAG)1596 entry->flag |= REF_KNOWS_PEELED;1597 return status;1598}15991600int peel_ref(const char *refname, unsigned char *sha1)1601{1602 int flag;1603 unsigned char base[20];16041605 if (current_ref && (current_ref->name == refname1606 || !strcmp(current_ref->name, refname))) {1607 if (peel_entry(current_ref, 0))1608 return -1;1609 hashcpy(sha1, current_ref->u.value.peeled);1610 return 0;1611 }16121613 if (read_ref_full(refname, base, 1, &flag))1614 return -1;16151616 /*1617 * If the reference is packed, read its ref_entry from the1618 * cache in the hope that we already know its peeled value.1619 * We only try this optimization on packed references because1620 * (a) forcing the filling of the loose reference cache could1621 * be expensive and (b) loose references anyway usually do not1622 * have REF_KNOWS_PEELED.1623 */1624 if (flag & REF_ISPACKED) {1625 struct ref_entry *r = get_packed_ref(refname);1626 if (r) {1627 if (peel_entry(r, 0))1628 return -1;1629 hashcpy(sha1, r->u.value.peeled);1630 return 0;1631 }1632 }16331634 return peel_object(base, sha1);1635}16361637struct warn_if_dangling_data {1638 FILE *fp;1639 const char *refname;1640 const struct string_list *refnames;1641 const char *msg_fmt;1642};16431644static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,1645 int flags, void *cb_data)1646{1647 struct warn_if_dangling_data *d = cb_data;1648 const char *resolves_to;1649 unsigned char junk[20];16501651 if (!(flags & REF_ISSYMREF))1652 return 0;16531654 resolves_to = resolve_ref_unsafe(refname, junk, 0, NULL);1655 if (!resolves_to1656 || (d->refname1657 ? strcmp(resolves_to, d->refname)1658 : !string_list_has_string(d->refnames, resolves_to))) {1659 return 0;1660 }16611662 fprintf(d->fp, d->msg_fmt, refname);1663 fputc('\n', d->fp);1664 return 0;1665}16661667void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)1668{1669 struct warn_if_dangling_data data;16701671 data.fp = fp;1672 data.refname = refname;1673 data.refnames = NULL;1674 data.msg_fmt = msg_fmt;1675 for_each_rawref(warn_if_dangling_symref, &data);1676}16771678void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)1679{1680 struct warn_if_dangling_data data;16811682 data.fp = fp;1683 data.refname = NULL;1684 data.refnames = refnames;1685 data.msg_fmt = msg_fmt;1686 for_each_rawref(warn_if_dangling_symref, &data);1687}16881689/*1690 * Call fn for each reference in the specified ref_cache, omitting1691 * references not in the containing_dir of base. fn is called for all1692 * references, including broken ones. If fn ever returns a non-zero1693 * value, stop the iteration and return that value; otherwise, return1694 * 0.1695 */1696static int do_for_each_entry(struct ref_cache *refs, const char *base,1697 each_ref_entry_fn fn, void *cb_data)1698{1699 struct packed_ref_cache *packed_ref_cache;1700 struct ref_dir *loose_dir;1701 struct ref_dir *packed_dir;1702 int retval = 0;17031704 /*1705 * We must make sure that all loose refs are read before accessing the1706 * packed-refs file; this avoids a race condition in which loose refs1707 * are migrated to the packed-refs file by a simultaneous process, but1708 * our in-memory view is from before the migration. get_packed_ref_cache()1709 * takes care of making sure our view is up to date with what is on1710 * disk.1711 */1712 loose_dir = get_loose_refs(refs);1713 if (base && *base) {1714 loose_dir = find_containing_dir(loose_dir, base, 0);1715 }1716 if (loose_dir)1717 prime_ref_dir(loose_dir);17181719 packed_ref_cache = get_packed_ref_cache(refs);1720 acquire_packed_ref_cache(packed_ref_cache);1721 packed_dir = get_packed_ref_dir(packed_ref_cache);1722 if (base && *base) {1723 packed_dir = find_containing_dir(packed_dir, base, 0);1724 }17251726 if (packed_dir && loose_dir) {1727 sort_ref_dir(packed_dir);1728 sort_ref_dir(loose_dir);1729 retval = do_for_each_entry_in_dirs(1730 packed_dir, loose_dir, fn, cb_data);1731 } else if (packed_dir) {1732 sort_ref_dir(packed_dir);1733 retval = do_for_each_entry_in_dir(1734 packed_dir, 0, fn, cb_data);1735 } else if (loose_dir) {1736 sort_ref_dir(loose_dir);1737 retval = do_for_each_entry_in_dir(1738 loose_dir, 0, fn, cb_data);1739 }17401741 release_packed_ref_cache(packed_ref_cache);1742 return retval;1743}17441745/*1746 * Call fn for each reference in the specified ref_cache for which the1747 * refname begins with base. If trim is non-zero, then trim that many1748 * characters off the beginning of each refname before passing the1749 * refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include1750 * broken references in the iteration. If fn ever returns a non-zero1751 * value, stop the iteration and return that value; otherwise, return1752 * 0.1753 */1754static int do_for_each_ref(struct ref_cache *refs, const char *base,1755 each_ref_fn fn, int trim, int flags, void *cb_data)1756{1757 struct ref_entry_cb data;1758 data.base = base;1759 data.trim = trim;1760 data.flags = flags;1761 data.fn = fn;1762 data.cb_data = cb_data;17631764 return do_for_each_entry(refs, base, do_one_ref, &data);1765}17661767static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)1768{1769 unsigned char sha1[20];1770 int flag;17711772 if (submodule) {1773 if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)1774 return fn("HEAD", sha1, 0, cb_data);17751776 return 0;1777 }17781779 if (!read_ref_full("HEAD", sha1, 1, &flag))1780 return fn("HEAD", sha1, flag, cb_data);17811782 return 0;1783}17841785int head_ref(each_ref_fn fn, void *cb_data)1786{1787 return do_head_ref(NULL, fn, cb_data);1788}17891790int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1791{1792 return do_head_ref(submodule, fn, cb_data);1793}17941795int for_each_ref(each_ref_fn fn, void *cb_data)1796{1797 return do_for_each_ref(&ref_cache, "", fn, 0, 0, cb_data);1798}17991800int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1801{1802 return do_for_each_ref(get_ref_cache(submodule), "", fn, 0, 0, cb_data);1803}18041805int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)1806{1807 return do_for_each_ref(&ref_cache, prefix, fn, strlen(prefix), 0, cb_data);1808}18091810int for_each_ref_in_submodule(const char *submodule, const char *prefix,1811 each_ref_fn fn, void *cb_data)1812{1813 return do_for_each_ref(get_ref_cache(submodule), prefix, fn, strlen(prefix), 0, cb_data);1814}18151816int for_each_tag_ref(each_ref_fn fn, void *cb_data)1817{1818 return for_each_ref_in("refs/tags/", fn, cb_data);1819}18201821int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1822{1823 return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);1824}18251826int for_each_branch_ref(each_ref_fn fn, void *cb_data)1827{1828 return for_each_ref_in("refs/heads/", fn, cb_data);1829}18301831int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1832{1833 return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);1834}18351836int for_each_remote_ref(each_ref_fn fn, void *cb_data)1837{1838 return for_each_ref_in("refs/remotes/", fn, cb_data);1839}18401841int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1842{1843 return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);1844}18451846int for_each_replace_ref(each_ref_fn fn, void *cb_data)1847{1848 return do_for_each_ref(&ref_cache, "refs/replace/", fn, 13, 0, cb_data);1849}18501851int head_ref_namespaced(each_ref_fn fn, void *cb_data)1852{1853 struct strbuf buf = STRBUF_INIT;1854 int ret = 0;1855 unsigned char sha1[20];1856 int flag;18571858 strbuf_addf(&buf, "%sHEAD", get_git_namespace());1859 if (!read_ref_full(buf.buf, sha1, 1, &flag))1860 ret = fn(buf.buf, sha1, flag, cb_data);1861 strbuf_release(&buf);18621863 return ret;1864}18651866int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)1867{1868 struct strbuf buf = STRBUF_INIT;1869 int ret;1870 strbuf_addf(&buf, "%srefs/", get_git_namespace());1871 ret = do_for_each_ref(&ref_cache, buf.buf, fn, 0, 0, cb_data);1872 strbuf_release(&buf);1873 return ret;1874}18751876int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,1877 const char *prefix, void *cb_data)1878{1879 struct strbuf real_pattern = STRBUF_INIT;1880 struct ref_filter filter;1881 int ret;18821883 if (!prefix && !starts_with(pattern, "refs/"))1884 strbuf_addstr(&real_pattern, "refs/");1885 else if (prefix)1886 strbuf_addstr(&real_pattern, prefix);1887 strbuf_addstr(&real_pattern, pattern);18881889 if (!has_glob_specials(pattern)) {1890 /* Append implied '/' '*' if not present. */1891 if (real_pattern.buf[real_pattern.len - 1] != '/')1892 strbuf_addch(&real_pattern, '/');1893 /* No need to check for '*', there is none. */1894 strbuf_addch(&real_pattern, '*');1895 }18961897 filter.pattern = real_pattern.buf;1898 filter.fn = fn;1899 filter.cb_data = cb_data;1900 ret = for_each_ref(filter_refs, &filter);19011902 strbuf_release(&real_pattern);1903 return ret;1904}19051906int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)1907{1908 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);1909}19101911int for_each_rawref(each_ref_fn fn, void *cb_data)1912{1913 return do_for_each_ref(&ref_cache, "", fn, 0,1914 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);1915}19161917const char *prettify_refname(const char *name)1918{1919 return name + (1920 starts_with(name, "refs/heads/") ? 11 :1921 starts_with(name, "refs/tags/") ? 10 :1922 starts_with(name, "refs/remotes/") ? 13 :1923 0);1924}19251926static const char *ref_rev_parse_rules[] = {1927 "%.*s",1928 "refs/%.*s",1929 "refs/tags/%.*s",1930 "refs/heads/%.*s",1931 "refs/remotes/%.*s",1932 "refs/remotes/%.*s/HEAD",1933 NULL1934};19351936int refname_match(const char *abbrev_name, const char *full_name)1937{1938 const char **p;1939 const int abbrev_name_len = strlen(abbrev_name);19401941 for (p = ref_rev_parse_rules; *p; p++) {1942 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {1943 return 1;1944 }1945 }19461947 return 0;1948}19491950/* This function should make sure errno is meaningful on error */1951static struct ref_lock *verify_lock(struct ref_lock *lock,1952 const unsigned char *old_sha1, int mustexist)1953{1954 if (read_ref_full(lock->ref_name, lock->old_sha1, mustexist, NULL)) {1955 int save_errno = errno;1956 error("Can't verify ref %s", lock->ref_name);1957 unlock_ref(lock);1958 errno = save_errno;1959 return NULL;1960 }1961 if (hashcmp(lock->old_sha1, old_sha1)) {1962 error("Ref %s is at %s but expected %s", lock->ref_name,1963 sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));1964 unlock_ref(lock);1965 errno = EBUSY;1966 return NULL;1967 }1968 return lock;1969}19701971static int remove_empty_directories(const char *file)1972{1973 /* we want to create a file but there is a directory there;1974 * if that is an empty directory (or a directory that contains1975 * only empty directories), remove them.1976 */1977 struct strbuf path;1978 int result, save_errno;19791980 strbuf_init(&path, 20);1981 strbuf_addstr(&path, file);19821983 result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);1984 save_errno = errno;19851986 strbuf_release(&path);1987 errno = save_errno;19881989 return result;1990}19911992/*1993 * *string and *len will only be substituted, and *string returned (for1994 * later free()ing) if the string passed in is a magic short-hand form1995 * to name a branch.1996 */1997static char *substitute_branch_name(const char **string, int *len)1998{1999 struct strbuf buf = STRBUF_INIT;2000 int ret = interpret_branch_name(*string, *len, &buf);20012002 if (ret == *len) {2003 size_t size;2004 *string = strbuf_detach(&buf, &size);2005 *len = size;2006 return (char *)*string;2007 }20082009 return NULL;2010}20112012int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)2013{2014 char *last_branch = substitute_branch_name(&str, &len);2015 const char **p, *r;2016 int refs_found = 0;20172018 *ref = NULL;2019 for (p = ref_rev_parse_rules; *p; p++) {2020 char fullref[PATH_MAX];2021 unsigned char sha1_from_ref[20];2022 unsigned char *this_result;2023 int flag;20242025 this_result = refs_found ? sha1_from_ref : sha1;2026 mksnpath(fullref, sizeof(fullref), *p, len, str);2027 r = resolve_ref_unsafe(fullref, this_result, 1, &flag);2028 if (r) {2029 if (!refs_found++)2030 *ref = xstrdup(r);2031 if (!warn_ambiguous_refs)2032 break;2033 } else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {2034 warning("ignoring dangling symref %s.", fullref);2035 } else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {2036 warning("ignoring broken ref %s.", fullref);2037 }2038 }2039 free(last_branch);2040 return refs_found;2041}20422043int dwim_log(const char *str, int len, unsigned char *sha1, char **log)2044{2045 char *last_branch = substitute_branch_name(&str, &len);2046 const char **p;2047 int logs_found = 0;20482049 *log = NULL;2050 for (p = ref_rev_parse_rules; *p; p++) {2051 unsigned char hash[20];2052 char path[PATH_MAX];2053 const char *ref, *it;20542055 mksnpath(path, sizeof(path), *p, len, str);2056 ref = resolve_ref_unsafe(path, hash, 1, NULL);2057 if (!ref)2058 continue;2059 if (reflog_exists(path))2060 it = path;2061 else if (strcmp(ref, path) && reflog_exists(ref))2062 it = ref;2063 else2064 continue;2065 if (!logs_found++) {2066 *log = xstrdup(it);2067 hashcpy(sha1, hash);2068 }2069 if (!warn_ambiguous_refs)2070 break;2071 }2072 free(last_branch);2073 return logs_found;2074}20752076/*2077 * Locks a "refs/" ref returning the lock on success and NULL on failure.2078 * On failure errno is set to something meaningful.2079 */2080static struct ref_lock *lock_ref_sha1_basic(const char *refname,2081 const unsigned char *old_sha1,2082 int flags, int *type_p)2083{2084 char *ref_file;2085 const char *orig_refname = refname;2086 struct ref_lock *lock;2087 int last_errno = 0;2088 int type, lflags;2089 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));2090 int missing = 0;2091 int attempts_remaining = 3;20922093 lock = xcalloc(1, sizeof(struct ref_lock));2094 lock->lock_fd = -1;20952096 refname = resolve_ref_unsafe(refname, lock->old_sha1, mustexist, &type);2097 if (!refname && errno == EISDIR) {2098 /* we are trying to lock foo but we used to2099 * have foo/bar which now does not exist;2100 * it is normal for the empty directory 'foo'2101 * to remain.2102 */2103 ref_file = git_path("%s", orig_refname);2104 if (remove_empty_directories(ref_file)) {2105 last_errno = errno;2106 error("there are still refs under '%s'", orig_refname);2107 goto error_return;2108 }2109 refname = resolve_ref_unsafe(orig_refname, lock->old_sha1, mustexist, &type);2110 }2111 if (type_p)2112 *type_p = type;2113 if (!refname) {2114 last_errno = errno;2115 error("unable to resolve reference %s: %s",2116 orig_refname, strerror(errno));2117 goto error_return;2118 }2119 missing = is_null_sha1(lock->old_sha1);2120 /* When the ref did not exist and we are creating it,2121 * make sure there is no existing ref that is packed2122 * whose name begins with our refname, nor a ref whose2123 * name is a proper prefix of our refname.2124 */2125 if (missing &&2126 !is_refname_available(refname, NULL, get_packed_refs(&ref_cache))) {2127 last_errno = ENOTDIR;2128 goto error_return;2129 }21302131 lock->lk = xcalloc(1, sizeof(struct lock_file));21322133 lflags = 0;2134 if (flags & REF_NODEREF) {2135 refname = orig_refname;2136 lflags |= LOCK_NODEREF;2137 }2138 lock->ref_name = xstrdup(refname);2139 lock->orig_ref_name = xstrdup(orig_refname);2140 ref_file = git_path("%s", refname);2141 if (missing)2142 lock->force_write = 1;2143 if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))2144 lock->force_write = 1;21452146 retry:2147 switch (safe_create_leading_directories(ref_file)) {2148 case SCLD_OK:2149 break; /* success */2150 case SCLD_VANISHED:2151 if (--attempts_remaining > 0)2152 goto retry;2153 /* fall through */2154 default:2155 last_errno = errno;2156 error("unable to create directory for %s", ref_file);2157 goto error_return;2158 }21592160 lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);2161 if (lock->lock_fd < 0) {2162 if (errno == ENOENT && --attempts_remaining > 0)2163 /*2164 * Maybe somebody just deleted one of the2165 * directories leading to ref_file. Try2166 * again:2167 */2168 goto retry;2169 else2170 unable_to_lock_index_die(ref_file, errno);2171 }2172 return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;21732174 error_return:2175 unlock_ref(lock);2176 errno = last_errno;2177 return NULL;2178}21792180struct ref_lock *lock_any_ref_for_update(const char *refname,2181 const unsigned char *old_sha1,2182 int flags, int *type_p)2183{2184 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))2185 return NULL;2186 return lock_ref_sha1_basic(refname, old_sha1, flags, type_p);2187}21882189/*2190 * Write an entry to the packed-refs file for the specified refname.2191 * If peeled is non-NULL, write it as the entry's peeled value.2192 */2193static void write_packed_entry(int fd, char *refname, unsigned char *sha1,2194 unsigned char *peeled)2195{2196 char line[PATH_MAX + 100];2197 int len;21982199 len = snprintf(line, sizeof(line), "%s %s\n",2200 sha1_to_hex(sha1), refname);2201 /* this should not happen but just being defensive */2202 if (len > sizeof(line))2203 die("too long a refname '%s'", refname);2204 write_or_die(fd, line, len);22052206 if (peeled) {2207 if (snprintf(line, sizeof(line), "^%s\n",2208 sha1_to_hex(peeled)) != PEELED_LINE_LENGTH)2209 die("internal error");2210 write_or_die(fd, line, PEELED_LINE_LENGTH);2211 }2212}22132214/*2215 * An each_ref_entry_fn that writes the entry to a packed-refs file.2216 */2217static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)2218{2219 int *fd = cb_data;2220 enum peel_status peel_status = peel_entry(entry, 0);22212222 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2223 error("internal error: %s is not a valid packed reference!",2224 entry->name);2225 write_packed_entry(*fd, entry->name, entry->u.value.sha1,2226 peel_status == PEEL_PEELED ?2227 entry->u.value.peeled : NULL);2228 return 0;2229}22302231/* This should return a meaningful errno on failure */2232int lock_packed_refs(int flags)2233{2234 struct packed_ref_cache *packed_ref_cache;22352236 if (hold_lock_file_for_update(&packlock, git_path("packed-refs"), flags) < 0)2237 return -1;2238 /*2239 * Get the current packed-refs while holding the lock. If the2240 * packed-refs file has been modified since we last read it,2241 * this will automatically invalidate the cache and re-read2242 * the packed-refs file.2243 */2244 packed_ref_cache = get_packed_ref_cache(&ref_cache);2245 packed_ref_cache->lock = &packlock;2246 /* Increment the reference count to prevent it from being freed: */2247 acquire_packed_ref_cache(packed_ref_cache);2248 return 0;2249}22502251/*2252 * Commit the packed refs changes.2253 * On error we must make sure that errno contains a meaningful value.2254 */2255int commit_packed_refs(void)2256{2257 struct packed_ref_cache *packed_ref_cache =2258 get_packed_ref_cache(&ref_cache);2259 int error = 0;2260 int save_errno = 0;22612262 if (!packed_ref_cache->lock)2263 die("internal error: packed-refs not locked");2264 write_or_die(packed_ref_cache->lock->fd,2265 PACKED_REFS_HEADER, strlen(PACKED_REFS_HEADER));22662267 do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),2268 0, write_packed_entry_fn,2269 &packed_ref_cache->lock->fd);2270 if (commit_lock_file(packed_ref_cache->lock)) {2271 save_errno = errno;2272 error = -1;2273 }2274 packed_ref_cache->lock = NULL;2275 release_packed_ref_cache(packed_ref_cache);2276 errno = save_errno;2277 return error;2278}22792280void rollback_packed_refs(void)2281{2282 struct packed_ref_cache *packed_ref_cache =2283 get_packed_ref_cache(&ref_cache);22842285 if (!packed_ref_cache->lock)2286 die("internal error: packed-refs not locked");2287 rollback_lock_file(packed_ref_cache->lock);2288 packed_ref_cache->lock = NULL;2289 release_packed_ref_cache(packed_ref_cache);2290 clear_packed_ref_cache(&ref_cache);2291}22922293struct ref_to_prune {2294 struct ref_to_prune *next;2295 unsigned char sha1[20];2296 char name[FLEX_ARRAY];2297};22982299struct pack_refs_cb_data {2300 unsigned int flags;2301 struct ref_dir *packed_refs;2302 struct ref_to_prune *ref_to_prune;2303};23042305/*2306 * An each_ref_entry_fn that is run over loose references only. If2307 * the loose reference can be packed, add an entry in the packed ref2308 * cache. If the reference should be pruned, also add it to2309 * ref_to_prune in the pack_refs_cb_data.2310 */2311static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)2312{2313 struct pack_refs_cb_data *cb = cb_data;2314 enum peel_status peel_status;2315 struct ref_entry *packed_entry;2316 int is_tag_ref = starts_with(entry->name, "refs/tags/");23172318 /* ALWAYS pack tags */2319 if (!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)2320 return 0;23212322 /* Do not pack symbolic or broken refs: */2323 if ((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))2324 return 0;23252326 /* Add a packed ref cache entry equivalent to the loose entry. */2327 peel_status = peel_entry(entry, 1);2328 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2329 die("internal error peeling reference %s (%s)",2330 entry->name, sha1_to_hex(entry->u.value.sha1));2331 packed_entry = find_ref(cb->packed_refs, entry->name);2332 if (packed_entry) {2333 /* Overwrite existing packed entry with info from loose entry */2334 packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;2335 hashcpy(packed_entry->u.value.sha1, entry->u.value.sha1);2336 } else {2337 packed_entry = create_ref_entry(entry->name, entry->u.value.sha1,2338 REF_ISPACKED | REF_KNOWS_PEELED, 0);2339 add_ref(cb->packed_refs, packed_entry);2340 }2341 hashcpy(packed_entry->u.value.peeled, entry->u.value.peeled);23422343 /* Schedule the loose reference for pruning if requested. */2344 if ((cb->flags & PACK_REFS_PRUNE)) {2345 int namelen = strlen(entry->name) + 1;2346 struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);2347 hashcpy(n->sha1, entry->u.value.sha1);2348 strcpy(n->name, entry->name);2349 n->next = cb->ref_to_prune;2350 cb->ref_to_prune = n;2351 }2352 return 0;2353}23542355/*2356 * Remove empty parents, but spare refs/ and immediate subdirs.2357 * Note: munges *name.2358 */2359static void try_remove_empty_parents(char *name)2360{2361 char *p, *q;2362 int i;2363 p = name;2364 for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */2365 while (*p && *p != '/')2366 p++;2367 /* tolerate duplicate slashes; see check_refname_format() */2368 while (*p == '/')2369 p++;2370 }2371 for (q = p; *q; q++)2372 ;2373 while (1) {2374 while (q > p && *q != '/')2375 q--;2376 while (q > p && *(q-1) == '/')2377 q--;2378 if (q == p)2379 break;2380 *q = '\0';2381 if (rmdir(git_path("%s", name)))2382 break;2383 }2384}23852386/* make sure nobody touched the ref, and unlink */2387static void prune_ref(struct ref_to_prune *r)2388{2389 struct ref_transaction *transaction;2390 struct strbuf err = STRBUF_INIT;23912392 if (check_refname_format(r->name, 0))2393 return;23942395 transaction = ref_transaction_begin(&err);2396 if (!transaction ||2397 ref_transaction_delete(transaction, r->name, r->sha1,2398 REF_ISPRUNING, 1, &err) ||2399 ref_transaction_commit(transaction, NULL, &err)) {2400 ref_transaction_free(transaction);2401 error("%s", err.buf);2402 strbuf_release(&err);2403 return;2404 }2405 ref_transaction_free(transaction);2406 strbuf_release(&err);2407 try_remove_empty_parents(r->name);2408}24092410static void prune_refs(struct ref_to_prune *r)2411{2412 while (r) {2413 prune_ref(r);2414 r = r->next;2415 }2416}24172418int pack_refs(unsigned int flags)2419{2420 struct pack_refs_cb_data cbdata;24212422 memset(&cbdata, 0, sizeof(cbdata));2423 cbdata.flags = flags;24242425 lock_packed_refs(LOCK_DIE_ON_ERROR);2426 cbdata.packed_refs = get_packed_refs(&ref_cache);24272428 do_for_each_entry_in_dir(get_loose_refs(&ref_cache), 0,2429 pack_if_possible_fn, &cbdata);24302431 if (commit_packed_refs())2432 die_errno("unable to overwrite old ref-pack file");24332434 prune_refs(cbdata.ref_to_prune);2435 return 0;2436}24372438/*2439 * If entry is no longer needed in packed-refs, add it to the string2440 * list pointed to by cb_data. Reasons for deleting entries:2441 *2442 * - Entry is broken.2443 * - Entry is overridden by a loose ref.2444 * - Entry does not point at a valid object.2445 *2446 * In the first and third cases, also emit an error message because these2447 * are indications of repository corruption.2448 */2449static int curate_packed_ref_fn(struct ref_entry *entry, void *cb_data)2450{2451 struct string_list *refs_to_delete = cb_data;24522453 if (entry->flag & REF_ISBROKEN) {2454 /* This shouldn't happen to packed refs. */2455 error("%s is broken!", entry->name);2456 string_list_append(refs_to_delete, entry->name);2457 return 0;2458 }2459 if (!has_sha1_file(entry->u.value.sha1)) {2460 unsigned char sha1[20];2461 int flags;24622463 if (read_ref_full(entry->name, sha1, 0, &flags))2464 /* We should at least have found the packed ref. */2465 die("Internal error");2466 if ((flags & REF_ISSYMREF) || !(flags & REF_ISPACKED)) {2467 /*2468 * This packed reference is overridden by a2469 * loose reference, so it is OK that its value2470 * is no longer valid; for example, it might2471 * refer to an object that has been garbage2472 * collected. For this purpose we don't even2473 * care whether the loose reference itself is2474 * invalid, broken, symbolic, etc. Silently2475 * remove the packed reference.2476 */2477 string_list_append(refs_to_delete, entry->name);2478 return 0;2479 }2480 /*2481 * There is no overriding loose reference, so the fact2482 * that this reference doesn't refer to a valid object2483 * indicates some kind of repository corruption.2484 * Report the problem, then omit the reference from2485 * the output.2486 */2487 error("%s does not point to a valid object!", entry->name);2488 string_list_append(refs_to_delete, entry->name);2489 return 0;2490 }24912492 return 0;2493}24942495int repack_without_refs(const char **refnames, int n, struct strbuf *err)2496{2497 struct ref_dir *packed;2498 struct string_list refs_to_delete = STRING_LIST_INIT_DUP;2499 struct string_list_item *ref_to_delete;2500 int i, ret, removed = 0;25012502 /* Look for a packed ref */2503 for (i = 0; i < n; i++)2504 if (get_packed_ref(refnames[i]))2505 break;25062507 /* Avoid locking if we have nothing to do */2508 if (i == n)2509 return 0; /* no refname exists in packed refs */25102511 if (lock_packed_refs(0)) {2512 if (err) {2513 unable_to_lock_message(git_path("packed-refs"), errno,2514 err);2515 return -1;2516 }2517 unable_to_lock_error(git_path("packed-refs"), errno);2518 return error("cannot delete '%s' from packed refs", refnames[i]);2519 }2520 packed = get_packed_refs(&ref_cache);25212522 /* Remove refnames from the cache */2523 for (i = 0; i < n; i++)2524 if (remove_entry(packed, refnames[i]) != -1)2525 removed = 1;2526 if (!removed) {2527 /*2528 * All packed entries disappeared while we were2529 * acquiring the lock.2530 */2531 rollback_packed_refs();2532 return 0;2533 }25342535 /* Remove any other accumulated cruft */2536 do_for_each_entry_in_dir(packed, 0, curate_packed_ref_fn, &refs_to_delete);2537 for_each_string_list_item(ref_to_delete, &refs_to_delete) {2538 if (remove_entry(packed, ref_to_delete->string) == -1)2539 die("internal error");2540 }25412542 /* Write what remains */2543 ret = commit_packed_refs();2544 if (ret && err)2545 strbuf_addf(err, "unable to overwrite old ref-pack file: %s",2546 strerror(errno));2547 return ret;2548}25492550static int delete_ref_loose(struct ref_lock *lock, int flag)2551{2552 if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {2553 /* loose */2554 int err, i = strlen(lock->lk->filename) - 5; /* .lock */25552556 lock->lk->filename[i] = 0;2557 err = unlink_or_warn(lock->lk->filename);2558 lock->lk->filename[i] = '.';2559 if (err && errno != ENOENT)2560 return 1;2561 }2562 return 0;2563}25642565int delete_ref(const char *refname, const unsigned char *sha1, int delopt)2566{2567 struct ref_transaction *transaction;2568 struct strbuf err = STRBUF_INIT;25692570 transaction = ref_transaction_begin(&err);2571 if (!transaction ||2572 ref_transaction_delete(transaction, refname, sha1, delopt,2573 sha1 && !is_null_sha1(sha1), &err) ||2574 ref_transaction_commit(transaction, NULL, &err)) {2575 error("%s", err.buf);2576 ref_transaction_free(transaction);2577 strbuf_release(&err);2578 return 1;2579 }2580 ref_transaction_free(transaction);2581 strbuf_release(&err);2582 return 0;2583}25842585/*2586 * People using contrib's git-new-workdir have .git/logs/refs ->2587 * /some/other/path/.git/logs/refs, and that may live on another device.2588 *2589 * IOW, to avoid cross device rename errors, the temporary renamed log must2590 * live into logs/refs.2591 */2592#define TMP_RENAMED_LOG "logs/refs/.tmp-renamed-log"25932594static int rename_tmp_log(const char *newrefname)2595{2596 int attempts_remaining = 4;25972598 retry:2599 switch (safe_create_leading_directories(git_path("logs/%s", newrefname))) {2600 case SCLD_OK:2601 break; /* success */2602 case SCLD_VANISHED:2603 if (--attempts_remaining > 0)2604 goto retry;2605 /* fall through */2606 default:2607 error("unable to create directory for %s", newrefname);2608 return -1;2609 }26102611 if (rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newrefname))) {2612 if ((errno==EISDIR || errno==ENOTDIR) && --attempts_remaining > 0) {2613 /*2614 * rename(a, b) when b is an existing2615 * directory ought to result in ISDIR, but2616 * Solaris 5.8 gives ENOTDIR. Sheesh.2617 */2618 if (remove_empty_directories(git_path("logs/%s", newrefname))) {2619 error("Directory not empty: logs/%s", newrefname);2620 return -1;2621 }2622 goto retry;2623 } else if (errno == ENOENT && --attempts_remaining > 0) {2624 /*2625 * Maybe another process just deleted one of2626 * the directories in the path to newrefname.2627 * Try again from the beginning.2628 */2629 goto retry;2630 } else {2631 error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",2632 newrefname, strerror(errno));2633 return -1;2634 }2635 }2636 return 0;2637}26382639int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)2640{2641 unsigned char sha1[20], orig_sha1[20];2642 int flag = 0, logmoved = 0;2643 struct ref_lock *lock;2644 struct stat loginfo;2645 int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);2646 const char *symref = NULL;26472648 if (log && S_ISLNK(loginfo.st_mode))2649 return error("reflog for %s is a symlink", oldrefname);26502651 symref = resolve_ref_unsafe(oldrefname, orig_sha1, 1, &flag);2652 if (flag & REF_ISSYMREF)2653 return error("refname %s is a symbolic ref, renaming it is not supported",2654 oldrefname);2655 if (!symref)2656 return error("refname %s not found", oldrefname);26572658 if (!is_refname_available(newrefname, oldrefname, get_packed_refs(&ref_cache)))2659 return 1;26602661 if (!is_refname_available(newrefname, oldrefname, get_loose_refs(&ref_cache)))2662 return 1;26632664 if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))2665 return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",2666 oldrefname, strerror(errno));26672668 if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {2669 error("unable to delete old %s", oldrefname);2670 goto rollback;2671 }26722673 if (!read_ref_full(newrefname, sha1, 1, &flag) &&2674 delete_ref(newrefname, sha1, REF_NODEREF)) {2675 if (errno==EISDIR) {2676 if (remove_empty_directories(git_path("%s", newrefname))) {2677 error("Directory not empty: %s", newrefname);2678 goto rollback;2679 }2680 } else {2681 error("unable to delete existing %s", newrefname);2682 goto rollback;2683 }2684 }26852686 if (log && rename_tmp_log(newrefname))2687 goto rollback;26882689 logmoved = log;26902691 lock = lock_ref_sha1_basic(newrefname, NULL, 0, NULL);2692 if (!lock) {2693 error("unable to lock %s for update", newrefname);2694 goto rollback;2695 }2696 lock->force_write = 1;2697 hashcpy(lock->old_sha1, orig_sha1);2698 if (write_ref_sha1(lock, orig_sha1, logmsg)) {2699 error("unable to write current sha1 into %s", newrefname);2700 goto rollback;2701 }27022703 return 0;27042705 rollback:2706 lock = lock_ref_sha1_basic(oldrefname, NULL, 0, NULL);2707 if (!lock) {2708 error("unable to lock %s for rollback", oldrefname);2709 goto rollbacklog;2710 }27112712 lock->force_write = 1;2713 flag = log_all_ref_updates;2714 log_all_ref_updates = 0;2715 if (write_ref_sha1(lock, orig_sha1, NULL))2716 error("unable to write current sha1 into %s", oldrefname);2717 log_all_ref_updates = flag;27182719 rollbacklog:2720 if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))2721 error("unable to restore logfile %s from %s: %s",2722 oldrefname, newrefname, strerror(errno));2723 if (!logmoved && log &&2724 rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))2725 error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",2726 oldrefname, strerror(errno));27272728 return 1;2729}27302731int close_ref(struct ref_lock *lock)2732{2733 if (close_lock_file(lock->lk))2734 return -1;2735 lock->lock_fd = -1;2736 return 0;2737}27382739int commit_ref(struct ref_lock *lock)2740{2741 if (commit_lock_file(lock->lk))2742 return -1;2743 lock->lock_fd = -1;2744 return 0;2745}27462747void unlock_ref(struct ref_lock *lock)2748{2749 /* Do not free lock->lk -- atexit() still looks at them */2750 if (lock->lk)2751 rollback_lock_file(lock->lk);2752 free(lock->ref_name);2753 free(lock->orig_ref_name);2754 free(lock);2755}27562757/*2758 * copy the reflog message msg to buf, which has been allocated sufficiently2759 * large, while cleaning up the whitespaces. Especially, convert LF to space,2760 * because reflog file is one line per entry.2761 */2762static int copy_msg(char *buf, const char *msg)2763{2764 char *cp = buf;2765 char c;2766 int wasspace = 1;27672768 *cp++ = '\t';2769 while ((c = *msg++)) {2770 if (wasspace && isspace(c))2771 continue;2772 wasspace = isspace(c);2773 if (wasspace)2774 c = ' ';2775 *cp++ = c;2776 }2777 while (buf < cp && isspace(cp[-1]))2778 cp--;2779 *cp++ = '\n';2780 return cp - buf;2781}27822783/* This function must set a meaningful errno on failure */2784int log_ref_setup(const char *refname, char *logfile, int bufsize)2785{2786 int logfd, oflags = O_APPEND | O_WRONLY;27872788 git_snpath(logfile, bufsize, "logs/%s", refname);2789 if (log_all_ref_updates &&2790 (starts_with(refname, "refs/heads/") ||2791 starts_with(refname, "refs/remotes/") ||2792 starts_with(refname, "refs/notes/") ||2793 !strcmp(refname, "HEAD"))) {2794 if (safe_create_leading_directories(logfile) < 0) {2795 int save_errno = errno;2796 error("unable to create directory for %s", logfile);2797 errno = save_errno;2798 return -1;2799 }2800 oflags |= O_CREAT;2801 }28022803 logfd = open(logfile, oflags, 0666);2804 if (logfd < 0) {2805 if (!(oflags & O_CREAT) && errno == ENOENT)2806 return 0;28072808 if ((oflags & O_CREAT) && errno == EISDIR) {2809 if (remove_empty_directories(logfile)) {2810 int save_errno = errno;2811 error("There are still logs under '%s'",2812 logfile);2813 errno = save_errno;2814 return -1;2815 }2816 logfd = open(logfile, oflags, 0666);2817 }28182819 if (logfd < 0) {2820 int save_errno = errno;2821 error("Unable to append to %s: %s", logfile,2822 strerror(errno));2823 errno = save_errno;2824 return -1;2825 }2826 }28272828 adjust_shared_perm(logfile);2829 close(logfd);2830 return 0;2831}28322833static int log_ref_write(const char *refname, const unsigned char *old_sha1,2834 const unsigned char *new_sha1, const char *msg)2835{2836 int logfd, result, written, oflags = O_APPEND | O_WRONLY;2837 unsigned maxlen, len;2838 int msglen;2839 char log_file[PATH_MAX];2840 char *logrec;2841 const char *committer;28422843 if (log_all_ref_updates < 0)2844 log_all_ref_updates = !is_bare_repository();28452846 result = log_ref_setup(refname, log_file, sizeof(log_file));2847 if (result)2848 return result;28492850 logfd = open(log_file, oflags);2851 if (logfd < 0)2852 return 0;2853 msglen = msg ? strlen(msg) : 0;2854 committer = git_committer_info(0);2855 maxlen = strlen(committer) + msglen + 100;2856 logrec = xmalloc(maxlen);2857 len = sprintf(logrec, "%s %s %s\n",2858 sha1_to_hex(old_sha1),2859 sha1_to_hex(new_sha1),2860 committer);2861 if (msglen)2862 len += copy_msg(logrec + len - 1, msg) - 1;2863 written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;2864 free(logrec);2865 if (written != len) {2866 int save_errno = errno;2867 close(logfd);2868 error("Unable to append to %s", log_file);2869 errno = save_errno;2870 return -1;2871 }2872 if (close(logfd)) {2873 int save_errno = errno;2874 error("Unable to append to %s", log_file);2875 errno = save_errno;2876 return -1;2877 }2878 return 0;2879}28802881int is_branch(const char *refname)2882{2883 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");2884}28852886/* This function must return a meaningful errno */2887int write_ref_sha1(struct ref_lock *lock,2888 const unsigned char *sha1, const char *logmsg)2889{2890 static char term = '\n';2891 struct object *o;28922893 if (!lock) {2894 errno = EINVAL;2895 return -1;2896 }2897 if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {2898 unlock_ref(lock);2899 return 0;2900 }2901 o = parse_object(sha1);2902 if (!o) {2903 error("Trying to write ref %s with nonexistent object %s",2904 lock->ref_name, sha1_to_hex(sha1));2905 unlock_ref(lock);2906 errno = EINVAL;2907 return -1;2908 }2909 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {2910 error("Trying to write non-commit object %s to branch %s",2911 sha1_to_hex(sha1), lock->ref_name);2912 unlock_ref(lock);2913 errno = EINVAL;2914 return -1;2915 }2916 if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||2917 write_in_full(lock->lock_fd, &term, 1) != 1 ||2918 close_ref(lock) < 0) {2919 int save_errno = errno;2920 error("Couldn't write %s", lock->lk->filename);2921 unlock_ref(lock);2922 errno = save_errno;2923 return -1;2924 }2925 clear_loose_ref_cache(&ref_cache);2926 if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||2927 (strcmp(lock->ref_name, lock->orig_ref_name) &&2928 log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {2929 unlock_ref(lock);2930 return -1;2931 }2932 if (strcmp(lock->orig_ref_name, "HEAD") != 0) {2933 /*2934 * Special hack: If a branch is updated directly and HEAD2935 * points to it (may happen on the remote side of a push2936 * for example) then logically the HEAD reflog should be2937 * updated too.2938 * A generic solution implies reverse symref information,2939 * but finding all symrefs pointing to the given branch2940 * would be rather costly for this rare event (the direct2941 * update of a branch) to be worth it. So let's cheat and2942 * check with HEAD only which should cover 99% of all usage2943 * scenarios (even 100% of the default ones).2944 */2945 unsigned char head_sha1[20];2946 int head_flag;2947 const char *head_ref;2948 head_ref = resolve_ref_unsafe("HEAD", head_sha1, 1, &head_flag);2949 if (head_ref && (head_flag & REF_ISSYMREF) &&2950 !strcmp(head_ref, lock->ref_name))2951 log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);2952 }2953 if (commit_ref(lock)) {2954 error("Couldn't set %s", lock->ref_name);2955 unlock_ref(lock);2956 return -1;2957 }2958 unlock_ref(lock);2959 return 0;2960}29612962int create_symref(const char *ref_target, const char *refs_heads_master,2963 const char *logmsg)2964{2965 const char *lockpath;2966 char ref[1000];2967 int fd, len, written;2968 char *git_HEAD = git_pathdup("%s", ref_target);2969 unsigned char old_sha1[20], new_sha1[20];29702971 if (logmsg && read_ref(ref_target, old_sha1))2972 hashclr(old_sha1);29732974 if (safe_create_leading_directories(git_HEAD) < 0)2975 return error("unable to create directory for %s", git_HEAD);29762977#ifndef NO_SYMLINK_HEAD2978 if (prefer_symlink_refs) {2979 unlink(git_HEAD);2980 if (!symlink(refs_heads_master, git_HEAD))2981 goto done;2982 fprintf(stderr, "no symlink - falling back to symbolic ref\n");2983 }2984#endif29852986 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);2987 if (sizeof(ref) <= len) {2988 error("refname too long: %s", refs_heads_master);2989 goto error_free_return;2990 }2991 lockpath = mkpath("%s.lock", git_HEAD);2992 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);2993 if (fd < 0) {2994 error("Unable to open %s for writing", lockpath);2995 goto error_free_return;2996 }2997 written = write_in_full(fd, ref, len);2998 if (close(fd) != 0 || written != len) {2999 error("Unable to write to %s", lockpath);3000 goto error_unlink_return;3001 }3002 if (rename(lockpath, git_HEAD) < 0) {3003 error("Unable to create %s", git_HEAD);3004 goto error_unlink_return;3005 }3006 if (adjust_shared_perm(git_HEAD)) {3007 error("Unable to fix permissions on %s", lockpath);3008 error_unlink_return:3009 unlink_or_warn(lockpath);3010 error_free_return:3011 free(git_HEAD);3012 return -1;3013 }30143015#ifndef NO_SYMLINK_HEAD3016 done:3017#endif3018 if (logmsg && !read_ref(refs_heads_master, new_sha1))3019 log_ref_write(ref_target, old_sha1, new_sha1, logmsg);30203021 free(git_HEAD);3022 return 0;3023}30243025struct read_ref_at_cb {3026 const char *refname;3027 unsigned long at_time;3028 int cnt;3029 int reccnt;3030 unsigned char *sha1;3031 int found_it;30323033 unsigned char osha1[20];3034 unsigned char nsha1[20];3035 int tz;3036 unsigned long date;3037 char **msg;3038 unsigned long *cutoff_time;3039 int *cutoff_tz;3040 int *cutoff_cnt;3041};30423043static int read_ref_at_ent(unsigned char *osha1, unsigned char *nsha1,3044 const char *email, unsigned long timestamp, int tz,3045 const char *message, void *cb_data)3046{3047 struct read_ref_at_cb *cb = cb_data;30483049 cb->reccnt++;3050 cb->tz = tz;3051 cb->date = timestamp;30523053 if (timestamp <= cb->at_time || cb->cnt == 0) {3054 if (cb->msg)3055 *cb->msg = xstrdup(message);3056 if (cb->cutoff_time)3057 *cb->cutoff_time = timestamp;3058 if (cb->cutoff_tz)3059 *cb->cutoff_tz = tz;3060 if (cb->cutoff_cnt)3061 *cb->cutoff_cnt = cb->reccnt - 1;3062 /*3063 * we have not yet updated cb->[n|o]sha1 so they still3064 * hold the values for the previous record.3065 */3066 if (!is_null_sha1(cb->osha1)) {3067 hashcpy(cb->sha1, nsha1);3068 if (hashcmp(cb->osha1, nsha1))3069 warning("Log for ref %s has gap after %s.",3070 cb->refname, show_date(cb->date, cb->tz, DATE_RFC2822));3071 }3072 else if (cb->date == cb->at_time)3073 hashcpy(cb->sha1, nsha1);3074 else if (hashcmp(nsha1, cb->sha1))3075 warning("Log for ref %s unexpectedly ended on %s.",3076 cb->refname, show_date(cb->date, cb->tz,3077 DATE_RFC2822));3078 hashcpy(cb->osha1, osha1);3079 hashcpy(cb->nsha1, nsha1);3080 cb->found_it = 1;3081 return 1;3082 }3083 hashcpy(cb->osha1, osha1);3084 hashcpy(cb->nsha1, nsha1);3085 if (cb->cnt > 0)3086 cb->cnt--;3087 return 0;3088}30893090static int read_ref_at_ent_oldest(unsigned char *osha1, unsigned char *nsha1,3091 const char *email, unsigned long timestamp,3092 int tz, const char *message, void *cb_data)3093{3094 struct read_ref_at_cb *cb = cb_data;30953096 if (cb->msg)3097 *cb->msg = xstrdup(message);3098 if (cb->cutoff_time)3099 *cb->cutoff_time = timestamp;3100 if (cb->cutoff_tz)3101 *cb->cutoff_tz = tz;3102 if (cb->cutoff_cnt)3103 *cb->cutoff_cnt = cb->reccnt;3104 hashcpy(cb->sha1, osha1);3105 if (is_null_sha1(cb->sha1))3106 hashcpy(cb->sha1, nsha1);3107 /* We just want the first entry */3108 return 1;3109}31103111int read_ref_at(const char *refname, unsigned long at_time, int cnt,3112 unsigned char *sha1, char **msg,3113 unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)3114{3115 struct read_ref_at_cb cb;31163117 memset(&cb, 0, sizeof(cb));3118 cb.refname = refname;3119 cb.at_time = at_time;3120 cb.cnt = cnt;3121 cb.msg = msg;3122 cb.cutoff_time = cutoff_time;3123 cb.cutoff_tz = cutoff_tz;3124 cb.cutoff_cnt = cutoff_cnt;3125 cb.sha1 = sha1;31263127 for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);31283129 if (!cb.reccnt)3130 die("Log for %s is empty.", refname);3131 if (cb.found_it)3132 return 0;31333134 for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);31353136 return 1;3137}31383139int reflog_exists(const char *refname)3140{3141 struct stat st;31423143 return !lstat(git_path("logs/%s", refname), &st) &&3144 S_ISREG(st.st_mode);3145}31463147int delete_reflog(const char *refname)3148{3149 return remove_path(git_path("logs/%s", refname));3150}31513152static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)3153{3154 unsigned char osha1[20], nsha1[20];3155 char *email_end, *message;3156 unsigned long timestamp;3157 int tz;31583159 /* old SP new SP name <email> SP time TAB msg LF */3160 if (sb->len < 83 || sb->buf[sb->len - 1] != '\n' ||3161 get_sha1_hex(sb->buf, osha1) || sb->buf[40] != ' ' ||3162 get_sha1_hex(sb->buf + 41, nsha1) || sb->buf[81] != ' ' ||3163 !(email_end = strchr(sb->buf + 82, '>')) ||3164 email_end[1] != ' ' ||3165 !(timestamp = strtoul(email_end + 2, &message, 10)) ||3166 !message || message[0] != ' ' ||3167 (message[1] != '+' && message[1] != '-') ||3168 !isdigit(message[2]) || !isdigit(message[3]) ||3169 !isdigit(message[4]) || !isdigit(message[5]))3170 return 0; /* corrupt? */3171 email_end[1] = '\0';3172 tz = strtol(message + 1, NULL, 10);3173 if (message[6] != '\t')3174 message += 6;3175 else3176 message += 7;3177 return fn(osha1, nsha1, sb->buf + 82, timestamp, tz, message, cb_data);3178}31793180static char *find_beginning_of_line(char *bob, char *scan)3181{3182 while (bob < scan && *(--scan) != '\n')3183 ; /* keep scanning backwards */3184 /*3185 * Return either beginning of the buffer, or LF at the end of3186 * the previous line.3187 */3188 return scan;3189}31903191int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data)3192{3193 struct strbuf sb = STRBUF_INIT;3194 FILE *logfp;3195 long pos;3196 int ret = 0, at_tail = 1;31973198 logfp = fopen(git_path("logs/%s", refname), "r");3199 if (!logfp)3200 return -1;32013202 /* Jump to the end */3203 if (fseek(logfp, 0, SEEK_END) < 0)3204 return error("cannot seek back reflog for %s: %s",3205 refname, strerror(errno));3206 pos = ftell(logfp);3207 while (!ret && 0 < pos) {3208 int cnt;3209 size_t nread;3210 char buf[BUFSIZ];3211 char *endp, *scanp;32123213 /* Fill next block from the end */3214 cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;3215 if (fseek(logfp, pos - cnt, SEEK_SET))3216 return error("cannot seek back reflog for %s: %s",3217 refname, strerror(errno));3218 nread = fread(buf, cnt, 1, logfp);3219 if (nread != 1)3220 return error("cannot read %d bytes from reflog for %s: %s",3221 cnt, refname, strerror(errno));3222 pos -= cnt;32233224 scanp = endp = buf + cnt;3225 if (at_tail && scanp[-1] == '\n')3226 /* Looking at the final LF at the end of the file */3227 scanp--;3228 at_tail = 0;32293230 while (buf < scanp) {3231 /*3232 * terminating LF of the previous line, or the beginning3233 * of the buffer.3234 */3235 char *bp;32363237 bp = find_beginning_of_line(buf, scanp);32383239 if (*bp != '\n') {3240 strbuf_splice(&sb, 0, 0, buf, endp - buf);3241 if (pos)3242 break; /* need to fill another block */3243 scanp = buf - 1; /* leave loop */3244 } else {3245 /*3246 * (bp + 1) thru endp is the beginning of the3247 * current line we have in sb3248 */3249 strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1));3250 scanp = bp;3251 endp = bp + 1;3252 }3253 ret = show_one_reflog_ent(&sb, fn, cb_data);3254 strbuf_reset(&sb);3255 if (ret)3256 break;3257 }32583259 }3260 if (!ret && sb.len)3261 ret = show_one_reflog_ent(&sb, fn, cb_data);32623263 fclose(logfp);3264 strbuf_release(&sb);3265 return ret;3266}32673268int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)3269{3270 FILE *logfp;3271 struct strbuf sb = STRBUF_INIT;3272 int ret = 0;32733274 logfp = fopen(git_path("logs/%s", refname), "r");3275 if (!logfp)3276 return -1;32773278 while (!ret && !strbuf_getwholeline(&sb, logfp, '\n'))3279 ret = show_one_reflog_ent(&sb, fn, cb_data);3280 fclose(logfp);3281 strbuf_release(&sb);3282 return ret;3283}3284/*3285 * Call fn for each reflog in the namespace indicated by name. name3286 * must be empty or end with '/'. Name will be used as a scratch3287 * space, but its contents will be restored before return.3288 */3289static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data)3290{3291 DIR *d = opendir(git_path("logs/%s", name->buf));3292 int retval = 0;3293 struct dirent *de;3294 int oldlen = name->len;32953296 if (!d)3297 return name->len ? errno : 0;32983299 while ((de = readdir(d)) != NULL) {3300 struct stat st;33013302 if (de->d_name[0] == '.')3303 continue;3304 if (ends_with(de->d_name, ".lock"))3305 continue;3306 strbuf_addstr(name, de->d_name);3307 if (stat(git_path("logs/%s", name->buf), &st) < 0) {3308 ; /* silently ignore */3309 } else {3310 if (S_ISDIR(st.st_mode)) {3311 strbuf_addch(name, '/');3312 retval = do_for_each_reflog(name, fn, cb_data);3313 } else {3314 unsigned char sha1[20];3315 if (read_ref_full(name->buf, sha1, 0, NULL))3316 retval = error("bad ref for %s", name->buf);3317 else3318 retval = fn(name->buf, sha1, 0, cb_data);3319 }3320 if (retval)3321 break;3322 }3323 strbuf_setlen(name, oldlen);3324 }3325 closedir(d);3326 return retval;3327}33283329int for_each_reflog(each_ref_fn fn, void *cb_data)3330{3331 int retval;3332 struct strbuf name;3333 strbuf_init(&name, PATH_MAX);3334 retval = do_for_each_reflog(&name, fn, cb_data);3335 strbuf_release(&name);3336 return retval;3337}33383339/**3340 * Information needed for a single ref update. Set new_sha1 to the3341 * new value or to zero to delete the ref. To check the old value3342 * while locking the ref, set have_old to 1 and set old_sha1 to the3343 * value or to zero to ensure the ref does not exist before update.3344 */3345struct ref_update {3346 unsigned char new_sha1[20];3347 unsigned char old_sha1[20];3348 int flags; /* REF_NODEREF? */3349 int have_old; /* 1 if old_sha1 is valid, 0 otherwise */3350 struct ref_lock *lock;3351 int type;3352 const char refname[FLEX_ARRAY];3353};33543355/*3356 * Transaction states.3357 * OPEN: The transaction is in a valid state and can accept new updates.3358 * An OPEN transaction can be committed.3359 * CLOSED: A closed transaction is no longer active and no other operations3360 * than free can be used on it in this state.3361 * A transaction can either become closed by successfully committing3362 * an active transaction or if there is a failure while building3363 * the transaction thus rendering it failed/inactive.3364 */3365enum ref_transaction_state {3366 REF_TRANSACTION_OPEN = 0,3367 REF_TRANSACTION_CLOSED = 13368};33693370/*3371 * Data structure for holding a reference transaction, which can3372 * consist of checks and updates to multiple references, carried out3373 * as atomically as possible. This structure is opaque to callers.3374 */3375struct ref_transaction {3376 struct ref_update **updates;3377 size_t alloc;3378 size_t nr;3379 enum ref_transaction_state state;3380};33813382struct ref_transaction *ref_transaction_begin(struct strbuf *err)3383{3384 return xcalloc(1, sizeof(struct ref_transaction));3385}33863387void ref_transaction_free(struct ref_transaction *transaction)3388{3389 int i;33903391 if (!transaction)3392 return;33933394 for (i = 0; i < transaction->nr; i++)3395 free(transaction->updates[i]);33963397 free(transaction->updates);3398 free(transaction);3399}34003401static struct ref_update *add_update(struct ref_transaction *transaction,3402 const char *refname)3403{3404 size_t len = strlen(refname);3405 struct ref_update *update = xcalloc(1, sizeof(*update) + len + 1);34063407 strcpy((char *)update->refname, refname);3408 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);3409 transaction->updates[transaction->nr++] = update;3410 return update;3411}34123413int ref_transaction_update(struct ref_transaction *transaction,3414 const char *refname,3415 const unsigned char *new_sha1,3416 const unsigned char *old_sha1,3417 int flags, int have_old,3418 struct strbuf *err)3419{3420 struct ref_update *update;34213422 if (transaction->state != REF_TRANSACTION_OPEN)3423 die("BUG: update called for transaction that is not open");34243425 if (have_old && !old_sha1)3426 die("BUG: have_old is true but old_sha1 is NULL");34273428 update = add_update(transaction, refname);3429 hashcpy(update->new_sha1, new_sha1);3430 update->flags = flags;3431 update->have_old = have_old;3432 if (have_old)3433 hashcpy(update->old_sha1, old_sha1);3434 return 0;3435}34363437int ref_transaction_create(struct ref_transaction *transaction,3438 const char *refname,3439 const unsigned char *new_sha1,3440 int flags,3441 struct strbuf *err)3442{3443 struct ref_update *update;34443445 if (transaction->state != REF_TRANSACTION_OPEN)3446 die("BUG: create called for transaction that is not open");34473448 if (!new_sha1 || is_null_sha1(new_sha1))3449 die("BUG: create ref with null new_sha1");34503451 update = add_update(transaction, refname);34523453 hashcpy(update->new_sha1, new_sha1);3454 hashclr(update->old_sha1);3455 update->flags = flags;3456 update->have_old = 1;3457 return 0;3458}34593460int ref_transaction_delete(struct ref_transaction *transaction,3461 const char *refname,3462 const unsigned char *old_sha1,3463 int flags, int have_old,3464 struct strbuf *err)3465{3466 struct ref_update *update;34673468 if (transaction->state != REF_TRANSACTION_OPEN)3469 die("BUG: delete called for transaction that is not open");34703471 if (have_old && !old_sha1)3472 die("BUG: have_old is true but old_sha1 is NULL");34733474 update = add_update(transaction, refname);3475 update->flags = flags;3476 update->have_old = have_old;3477 if (have_old) {3478 assert(!is_null_sha1(old_sha1));3479 hashcpy(update->old_sha1, old_sha1);3480 }3481 return 0;3482}34833484int update_ref(const char *action, const char *refname,3485 const unsigned char *sha1, const unsigned char *oldval,3486 int flags, enum action_on_err onerr)3487{3488 struct ref_transaction *t;3489 struct strbuf err = STRBUF_INIT;34903491 t = ref_transaction_begin(&err);3492 if (!t ||3493 ref_transaction_update(t, refname, sha1, oldval, flags,3494 !!oldval, &err) ||3495 ref_transaction_commit(t, action, &err)) {3496 const char *str = "update_ref failed for ref '%s': %s";34973498 ref_transaction_free(t);3499 switch (onerr) {3500 case UPDATE_REFS_MSG_ON_ERR:3501 error(str, refname, err.buf);3502 break;3503 case UPDATE_REFS_DIE_ON_ERR:3504 die(str, refname, err.buf);3505 break;3506 case UPDATE_REFS_QUIET_ON_ERR:3507 break;3508 }3509 strbuf_release(&err);3510 return 1;3511 }3512 strbuf_release(&err);3513 ref_transaction_free(t);3514 return 0;3515}35163517static int ref_update_compare(const void *r1, const void *r2)3518{3519 const struct ref_update * const *u1 = r1;3520 const struct ref_update * const *u2 = r2;3521 return strcmp((*u1)->refname, (*u2)->refname);3522}35233524static int ref_update_reject_duplicates(struct ref_update **updates, int n,3525 struct strbuf *err)3526{3527 int i;3528 for (i = 1; i < n; i++)3529 if (!strcmp(updates[i - 1]->refname, updates[i]->refname)) {3530 const char *str =3531 "Multiple updates for ref '%s' not allowed.";3532 if (err)3533 strbuf_addf(err, str, updates[i]->refname);35343535 return 1;3536 }3537 return 0;3538}35393540int ref_transaction_commit(struct ref_transaction *transaction,3541 const char *msg, struct strbuf *err)3542{3543 int ret = 0, delnum = 0, i;3544 const char **delnames;3545 int n = transaction->nr;3546 struct ref_update **updates = transaction->updates;35473548 if (transaction->state != REF_TRANSACTION_OPEN)3549 die("BUG: commit called for transaction that is not open");35503551 if (!n) {3552 transaction->state = REF_TRANSACTION_CLOSED;3553 return 0;3554 }35553556 /* Allocate work space */3557 delnames = xmalloc(sizeof(*delnames) * n);35583559 /* Copy, sort, and reject duplicate refs */3560 qsort(updates, n, sizeof(*updates), ref_update_compare);3561 ret = ref_update_reject_duplicates(updates, n, err);3562 if (ret)3563 goto cleanup;35643565 /* Acquire all locks while verifying old values */3566 for (i = 0; i < n; i++) {3567 struct ref_update *update = updates[i];35683569 update->lock = lock_any_ref_for_update(update->refname,3570 (update->have_old ?3571 update->old_sha1 :3572 NULL),3573 update->flags,3574 &update->type);3575 if (!update->lock) {3576 if (err)3577 strbuf_addf(err, "Cannot lock the ref '%s'.",3578 update->refname);3579 ret = 1;3580 goto cleanup;3581 }3582 }35833584 /* Perform updates first so live commits remain referenced */3585 for (i = 0; i < n; i++) {3586 struct ref_update *update = updates[i];35873588 if (!is_null_sha1(update->new_sha1)) {3589 ret = write_ref_sha1(update->lock, update->new_sha1,3590 msg);3591 update->lock = NULL; /* freed by write_ref_sha1 */3592 if (ret) {3593 if (err)3594 strbuf_addf(err, "Cannot update the ref '%s'.",3595 update->refname);3596 goto cleanup;3597 }3598 }3599 }36003601 /* Perform deletes now that updates are safely completed */3602 for (i = 0; i < n; i++) {3603 struct ref_update *update = updates[i];36043605 if (update->lock) {3606 ret |= delete_ref_loose(update->lock, update->type);3607 if (!(update->flags & REF_ISPRUNING))3608 delnames[delnum++] = update->lock->ref_name;3609 }3610 }36113612 ret |= repack_without_refs(delnames, delnum, err);3613 for (i = 0; i < delnum; i++)3614 unlink_or_warn(git_path("logs/%s", delnames[i]));3615 clear_loose_ref_cache(&ref_cache);36163617cleanup:3618 transaction->state = REF_TRANSACTION_CLOSED;36193620 for (i = 0; i < n; i++)3621 if (updates[i]->lock)3622 unlock_ref(updates[i]->lock);3623 free(delnames);3624 return ret;3625}36263627char *shorten_unambiguous_ref(const char *refname, int strict)3628{3629 int i;3630 static char **scanf_fmts;3631 static int nr_rules;3632 char *short_name;36333634 if (!nr_rules) {3635 /*3636 * Pre-generate scanf formats from ref_rev_parse_rules[].3637 * Generate a format suitable for scanf from a3638 * ref_rev_parse_rules rule by interpolating "%s" at the3639 * location of the "%.*s".3640 */3641 size_t total_len = 0;3642 size_t offset = 0;36433644 /* the rule list is NULL terminated, count them first */3645 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)3646 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */3647 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;36483649 scanf_fmts = xmalloc(nr_rules * sizeof(char *) + total_len);36503651 offset = 0;3652 for (i = 0; i < nr_rules; i++) {3653 assert(offset < total_len);3654 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;3655 offset += snprintf(scanf_fmts[i], total_len - offset,3656 ref_rev_parse_rules[i], 2, "%s") + 1;3657 }3658 }36593660 /* bail out if there are no rules */3661 if (!nr_rules)3662 return xstrdup(refname);36633664 /* buffer for scanf result, at most refname must fit */3665 short_name = xstrdup(refname);36663667 /* skip first rule, it will always match */3668 for (i = nr_rules - 1; i > 0 ; --i) {3669 int j;3670 int rules_to_fail = i;3671 int short_name_len;36723673 if (1 != sscanf(refname, scanf_fmts[i], short_name))3674 continue;36753676 short_name_len = strlen(short_name);36773678 /*3679 * in strict mode, all (except the matched one) rules3680 * must fail to resolve to a valid non-ambiguous ref3681 */3682 if (strict)3683 rules_to_fail = nr_rules;36843685 /*3686 * check if the short name resolves to a valid ref,3687 * but use only rules prior to the matched one3688 */3689 for (j = 0; j < rules_to_fail; j++) {3690 const char *rule = ref_rev_parse_rules[j];3691 char refname[PATH_MAX];36923693 /* skip matched rule */3694 if (i == j)3695 continue;36963697 /*3698 * the short name is ambiguous, if it resolves3699 * (with this previous rule) to a valid ref3700 * read_ref() returns 0 on success3701 */3702 mksnpath(refname, sizeof(refname),3703 rule, short_name_len, short_name);3704 if (ref_exists(refname))3705 break;3706 }37073708 /*3709 * short name is non-ambiguous if all previous rules3710 * haven't resolved to a valid ref3711 */3712 if (j == rules_to_fail)3713 return short_name;3714 }37153716 free(short_name);3717 return xstrdup(refname);3718}37193720static struct string_list *hide_refs;37213722int parse_hide_refs_config(const char *var, const char *value, const char *section)3723{3724 if (!strcmp("transfer.hiderefs", var) ||3725 /* NEEDSWORK: use parse_config_key() once both are merged */3726 (starts_with(var, section) && var[strlen(section)] == '.' &&3727 !strcmp(var + strlen(section), ".hiderefs"))) {3728 char *ref;3729 int len;37303731 if (!value)3732 return config_error_nonbool(var);3733 ref = xstrdup(value);3734 len = strlen(ref);3735 while (len && ref[len - 1] == '/')3736 ref[--len] = '\0';3737 if (!hide_refs) {3738 hide_refs = xcalloc(1, sizeof(*hide_refs));3739 hide_refs->strdup_strings = 1;3740 }3741 string_list_append(hide_refs, ref);3742 }3743 return 0;3744}37453746int ref_is_hidden(const char *refname)3747{3748 struct string_list_item *item;37493750 if (!hide_refs)3751 return 0;3752 for_each_string_list_item(item, hide_refs) {3753 int len;3754 if (!starts_with(refname, item->string))3755 continue;3756 len = strlen(item->string);3757 if (!refname[len] || refname[len] == '/')3758 return 1;3759 }3760 return 0;3761}