1#include "cache.h" 2#include "refs.h" 3#include "object.h" 4#include "tag.h" 5#include "dir.h" 6#include "string-list.h" 7 8/* 9 * How to handle various characters in refnames: 10 * 0: An acceptable character for refs 11 * 1: End-of-component 12 * 2: ., look for a preceding . to reject .. in refs 13 * 3: {, look for a preceding @ to reject @{ in refs 14 * 4: A bad character: ASCII control characters, "~", "^", ":" or SP 15 */ 16static unsigned char refname_disposition[256] = { 17 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 18 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 19 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 2, 1, 20 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4, 21 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 22 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 4, 0, 23 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 4, 4 25}; 26 27/* 28 * Used as a flag to ref_transaction_delete when a loose ref is being 29 * pruned. 30 */ 31#define REF_ISPRUNING 0x0100 32/* 33 * Try to read one refname component from the front of refname. 34 * Return the length of the component found, or -1 if the component is 35 * not legal. It is legal if it is something reasonable to have under 36 * ".git/refs/"; We do not like it if: 37 * 38 * - any path component of it begins with ".", or 39 * - it has double dots "..", or 40 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or 41 * - it ends with a "/". 42 * - it ends with ".lock" 43 * - it contains a "\" (backslash) 44 */ 45static int check_refname_component(const char *refname, int flags) 46{ 47 const char *cp; 48 char last = '\0'; 49 50 for (cp = refname; ; cp++) { 51 int ch = *cp & 255; 52 unsigned char disp = refname_disposition[ch]; 53 switch (disp) { 54 case 1: 55 goto out; 56 case 2: 57 if (last == '.') 58 return -1; /* Refname contains "..". */ 59 break; 60 case 3: 61 if (last == '@') 62 return -1; /* Refname contains "@{". */ 63 break; 64 case 4: 65 return -1; 66 } 67 last = ch; 68 } 69out: 70 if (cp == refname) 71 return 0; /* Component has zero length. */ 72 if (refname[0] == '.') { 73 if (!(flags & REFNAME_DOT_COMPONENT)) 74 return -1; /* Component starts with '.'. */ 75 /* 76 * Even if leading dots are allowed, don't allow "." 77 * as a component (".." is prevented by a rule above). 78 */ 79 if (refname[1] == '\0') 80 return -1; /* Component equals ".". */ 81 } 82 if (cp - refname >= 5 && !memcmp(cp - 5, ".lock", 5)) 83 return -1; /* Refname ends with ".lock". */ 84 return cp - refname; 85} 86 87int check_refname_format(const char *refname, int flags) 88{ 89 int component_len, component_count = 0; 90 91 if (!strcmp(refname, "@")) 92 /* Refname is a single character '@'. */ 93 return -1; 94 95 while (1) { 96 /* We are at the start of a path component. */ 97 component_len = check_refname_component(refname, flags); 98 if (component_len <= 0) { 99 if ((flags & REFNAME_REFSPEC_PATTERN) && 100 refname[0] == '*' && 101 (refname[1] == '\0' || refname[1] == '/')) { 102 /* Accept one wildcard as a full refname component. */ 103 flags &= ~REFNAME_REFSPEC_PATTERN; 104 component_len = 1; 105 } else { 106 return -1; 107 } 108 } 109 component_count++; 110 if (refname[component_len] == '\0') 111 break; 112 /* Skip to next component. */ 113 refname += component_len + 1; 114 } 115 116 if (refname[component_len - 1] == '.') 117 return -1; /* Refname ends with '.'. */ 118 if (!(flags & REFNAME_ALLOW_ONELEVEL) && component_count < 2) 119 return -1; /* Refname has only one component. */ 120 return 0; 121} 122 123struct ref_entry; 124 125/* 126 * Information used (along with the information in ref_entry) to 127 * describe a single cached reference. This data structure only 128 * occurs embedded in a union in struct ref_entry, and only when 129 * (ref_entry->flag & REF_DIR) is zero. 130 */ 131struct ref_value { 132 /* 133 * The name of the object to which this reference resolves 134 * (which may be a tag object). If REF_ISBROKEN, this is 135 * null. If REF_ISSYMREF, then this is the name of the object 136 * referred to by the last reference in the symlink chain. 137 */ 138 unsigned char sha1[20]; 139 140 /* 141 * If REF_KNOWS_PEELED, then this field holds the peeled value 142 * of this reference, or null if the reference is known not to 143 * be peelable. See the documentation for peel_ref() for an 144 * exact definition of "peelable". 145 */ 146 unsigned char peeled[20]; 147}; 148 149struct ref_cache; 150 151/* 152 * Information used (along with the information in ref_entry) to 153 * describe a level in the hierarchy of references. This data 154 * structure only occurs embedded in a union in struct ref_entry, and 155 * only when (ref_entry.flag & REF_DIR) is set. In that case, 156 * (ref_entry.flag & REF_INCOMPLETE) determines whether the references 157 * in the directory have already been read: 158 * 159 * (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose 160 * or packed references, already read. 161 * 162 * (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose 163 * references that hasn't been read yet (nor has any of its 164 * subdirectories). 165 * 166 * Entries within a directory are stored within a growable array of 167 * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i < 168 * sorted are sorted by their component name in strcmp() order and the 169 * remaining entries are unsorted. 170 * 171 * Loose references are read lazily, one directory at a time. When a 172 * directory of loose references is read, then all of the references 173 * in that directory are stored, and REF_INCOMPLETE stubs are created 174 * for any subdirectories, but the subdirectories themselves are not 175 * read. The reading is triggered by get_ref_dir(). 176 */ 177struct ref_dir { 178 int nr, alloc; 179 180 /* 181 * Entries with index 0 <= i < sorted are sorted by name. New 182 * entries are appended to the list unsorted, and are sorted 183 * only when required; thus we avoid the need to sort the list 184 * after the addition of every reference. 185 */ 186 int sorted; 187 188 /* A pointer to the ref_cache that contains this ref_dir. */ 189 struct ref_cache *ref_cache; 190 191 struct ref_entry **entries; 192}; 193 194/* 195 * Bit values for ref_entry::flag. REF_ISSYMREF=0x01, 196 * REF_ISPACKED=0x02, and REF_ISBROKEN=0x04 are public values; see 197 * refs.h. 198 */ 199 200/* 201 * The field ref_entry->u.value.peeled of this value entry contains 202 * the correct peeled value for the reference, which might be 203 * null_sha1 if the reference is not a tag or if it is broken. 204 */ 205#define REF_KNOWS_PEELED 0x08 206 207/* ref_entry represents a directory of references */ 208#define REF_DIR 0x10 209 210/* 211 * Entry has not yet been read from disk (used only for REF_DIR 212 * entries representing loose references) 213 */ 214#define REF_INCOMPLETE 0x20 215 216/* 217 * A ref_entry represents either a reference or a "subdirectory" of 218 * references. 219 * 220 * Each directory in the reference namespace is represented by a 221 * ref_entry with (flags & REF_DIR) set and containing a subdir member 222 * that holds the entries in that directory that have been read so 223 * far. If (flags & REF_INCOMPLETE) is set, then the directory and 224 * its subdirectories haven't been read yet. REF_INCOMPLETE is only 225 * used for loose reference directories. 226 * 227 * References are represented by a ref_entry with (flags & REF_DIR) 228 * unset and a value member that describes the reference's value. The 229 * flag member is at the ref_entry level, but it is also needed to 230 * interpret the contents of the value field (in other words, a 231 * ref_value object is not very much use without the enclosing 232 * ref_entry). 233 * 234 * Reference names cannot end with slash and directories' names are 235 * always stored with a trailing slash (except for the top-level 236 * directory, which is always denoted by ""). This has two nice 237 * consequences: (1) when the entries in each subdir are sorted 238 * lexicographically by name (as they usually are), the references in 239 * a whole tree can be generated in lexicographic order by traversing 240 * the tree in left-to-right, depth-first order; (2) the names of 241 * references and subdirectories cannot conflict, and therefore the 242 * presence of an empty subdirectory does not block the creation of a 243 * similarly-named reference. (The fact that reference names with the 244 * same leading components can conflict *with each other* is a 245 * separate issue that is regulated by is_refname_available().) 246 * 247 * Please note that the name field contains the fully-qualified 248 * reference (or subdirectory) name. Space could be saved by only 249 * storing the relative names. But that would require the full names 250 * to be generated on the fly when iterating in do_for_each_ref(), and 251 * would break callback functions, who have always been able to assume 252 * that the name strings that they are passed will not be freed during 253 * the iteration. 254 */ 255struct ref_entry { 256 unsigned char flag; /* ISSYMREF? ISPACKED? */ 257 union { 258 struct ref_value value; /* if not (flags&REF_DIR) */ 259 struct ref_dir subdir; /* if (flags&REF_DIR) */ 260 } u; 261 /* 262 * The full name of the reference (e.g., "refs/heads/master") 263 * or the full name of the directory with a trailing slash 264 * (e.g., "refs/heads/"): 265 */ 266 char name[FLEX_ARRAY]; 267}; 268 269static void read_loose_refs(const char *dirname, struct ref_dir *dir); 270 271static struct ref_dir *get_ref_dir(struct ref_entry *entry) 272{ 273 struct ref_dir *dir; 274 assert(entry->flag & REF_DIR); 275 dir = &entry->u.subdir; 276 if (entry->flag & REF_INCOMPLETE) { 277 read_loose_refs(entry->name, dir); 278 entry->flag &= ~REF_INCOMPLETE; 279 } 280 return dir; 281} 282 283static struct ref_entry *create_ref_entry(const char *refname, 284 const unsigned char *sha1, int flag, 285 int check_name) 286{ 287 int len; 288 struct ref_entry *ref; 289 290 if (check_name && 291 check_refname_format(refname, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT)) 292 die("Reference has invalid format: '%s'", refname); 293 len = strlen(refname) + 1; 294 ref = xmalloc(sizeof(struct ref_entry) + len); 295 hashcpy(ref->u.value.sha1, sha1); 296 hashclr(ref->u.value.peeled); 297 memcpy(ref->name, refname, len); 298 ref->flag = flag; 299 return ref; 300} 301 302static void clear_ref_dir(struct ref_dir *dir); 303 304static void free_ref_entry(struct ref_entry *entry) 305{ 306 if (entry->flag & REF_DIR) { 307 /* 308 * Do not use get_ref_dir() here, as that might 309 * trigger the reading of loose refs. 310 */ 311 clear_ref_dir(&entry->u.subdir); 312 } 313 free(entry); 314} 315 316/* 317 * Add a ref_entry to the end of dir (unsorted). Entry is always 318 * stored directly in dir; no recursion into subdirectories is 319 * done. 320 */ 321static void add_entry_to_dir(struct ref_dir *dir, struct ref_entry *entry) 322{ 323 ALLOC_GROW(dir->entries, dir->nr + 1, dir->alloc); 324 dir->entries[dir->nr++] = entry; 325 /* optimize for the case that entries are added in order */ 326 if (dir->nr == 1 || 327 (dir->nr == dir->sorted + 1 && 328 strcmp(dir->entries[dir->nr - 2]->name, 329 dir->entries[dir->nr - 1]->name) < 0)) 330 dir->sorted = dir->nr; 331} 332 333/* 334 * Clear and free all entries in dir, recursively. 335 */ 336static void clear_ref_dir(struct ref_dir *dir) 337{ 338 int i; 339 for (i = 0; i < dir->nr; i++) 340 free_ref_entry(dir->entries[i]); 341 free(dir->entries); 342 dir->sorted = dir->nr = dir->alloc = 0; 343 dir->entries = NULL; 344} 345 346/* 347 * Create a struct ref_entry object for the specified dirname. 348 * dirname is the name of the directory with a trailing slash (e.g., 349 * "refs/heads/") or "" for the top-level directory. 350 */ 351static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache, 352 const char *dirname, size_t len, 353 int incomplete) 354{ 355 struct ref_entry *direntry; 356 direntry = xcalloc(1, sizeof(struct ref_entry) + len + 1); 357 memcpy(direntry->name, dirname, len); 358 direntry->name[len] = '\0'; 359 direntry->u.subdir.ref_cache = ref_cache; 360 direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE : 0); 361 return direntry; 362} 363 364static int ref_entry_cmp(const void *a, const void *b) 365{ 366 struct ref_entry *one = *(struct ref_entry **)a; 367 struct ref_entry *two = *(struct ref_entry **)b; 368 return strcmp(one->name, two->name); 369} 370 371static void sort_ref_dir(struct ref_dir *dir); 372 373struct string_slice { 374 size_t len; 375 const char *str; 376}; 377 378static int ref_entry_cmp_sslice(const void *key_, const void *ent_) 379{ 380 const struct string_slice *key = key_; 381 const struct ref_entry *ent = *(const struct ref_entry * const *)ent_; 382 int cmp = strncmp(key->str, ent->name, key->len); 383 if (cmp) 384 return cmp; 385 return '\0' - (unsigned char)ent->name[key->len]; 386} 387 388/* 389 * Return the index of the entry with the given refname from the 390 * ref_dir (non-recursively), sorting dir if necessary. Return -1 if 391 * no such entry is found. dir must already be complete. 392 */ 393static int search_ref_dir(struct ref_dir *dir, const char *refname, size_t len) 394{ 395 struct ref_entry **r; 396 struct string_slice key; 397 398 if (refname == NULL || !dir->nr) 399 return -1; 400 401 sort_ref_dir(dir); 402 key.len = len; 403 key.str = refname; 404 r = bsearch(&key, dir->entries, dir->nr, sizeof(*dir->entries), 405 ref_entry_cmp_sslice); 406 407 if (r == NULL) 408 return -1; 409 410 return r - dir->entries; 411} 412 413/* 414 * Search for a directory entry directly within dir (without 415 * recursing). Sort dir if necessary. subdirname must be a directory 416 * name (i.e., end in '/'). If mkdir is set, then create the 417 * directory if it is missing; otherwise, return NULL if the desired 418 * directory cannot be found. dir must already be complete. 419 */ 420static struct ref_dir *search_for_subdir(struct ref_dir *dir, 421 const char *subdirname, size_t len, 422 int mkdir) 423{ 424 int entry_index = search_ref_dir(dir, subdirname, len); 425 struct ref_entry *entry; 426 if (entry_index == -1) { 427 if (!mkdir) 428 return NULL; 429 /* 430 * Since dir is complete, the absence of a subdir 431 * means that the subdir really doesn't exist; 432 * therefore, create an empty record for it but mark 433 * the record complete. 434 */ 435 entry = create_dir_entry(dir->ref_cache, subdirname, len, 0); 436 add_entry_to_dir(dir, entry); 437 } else { 438 entry = dir->entries[entry_index]; 439 } 440 return get_ref_dir(entry); 441} 442 443/* 444 * If refname is a reference name, find the ref_dir within the dir 445 * tree that should hold refname. If refname is a directory name 446 * (i.e., ends in '/'), then return that ref_dir itself. dir must 447 * represent the top-level directory and must already be complete. 448 * Sort ref_dirs and recurse into subdirectories as necessary. If 449 * mkdir is set, then create any missing directories; otherwise, 450 * return NULL if the desired directory cannot be found. 451 */ 452static struct ref_dir *find_containing_dir(struct ref_dir *dir, 453 const char *refname, int mkdir) 454{ 455 const char *slash; 456 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) { 457 size_t dirnamelen = slash - refname + 1; 458 struct ref_dir *subdir; 459 subdir = search_for_subdir(dir, refname, dirnamelen, mkdir); 460 if (!subdir) { 461 dir = NULL; 462 break; 463 } 464 dir = subdir; 465 } 466 467 return dir; 468} 469 470/* 471 * Find the value entry with the given name in dir, sorting ref_dirs 472 * and recursing into subdirectories as necessary. If the name is not 473 * found or it corresponds to a directory entry, return NULL. 474 */ 475static struct ref_entry *find_ref(struct ref_dir *dir, const char *refname) 476{ 477 int entry_index; 478 struct ref_entry *entry; 479 dir = find_containing_dir(dir, refname, 0); 480 if (!dir) 481 return NULL; 482 entry_index = search_ref_dir(dir, refname, strlen(refname)); 483 if (entry_index == -1) 484 return NULL; 485 entry = dir->entries[entry_index]; 486 return (entry->flag & REF_DIR) ? NULL : entry; 487} 488 489/* 490 * Remove the entry with the given name from dir, recursing into 491 * subdirectories as necessary. If refname is the name of a directory 492 * (i.e., ends with '/'), then remove the directory and its contents. 493 * If the removal was successful, return the number of entries 494 * remaining in the directory entry that contained the deleted entry. 495 * If the name was not found, return -1. Please note that this 496 * function only deletes the entry from the cache; it does not delete 497 * it from the filesystem or ensure that other cache entries (which 498 * might be symbolic references to the removed entry) are updated. 499 * Nor does it remove any containing dir entries that might be made 500 * empty by the removal. dir must represent the top-level directory 501 * and must already be complete. 502 */ 503static int remove_entry(struct ref_dir *dir, const char *refname) 504{ 505 int refname_len = strlen(refname); 506 int entry_index; 507 struct ref_entry *entry; 508 int is_dir = refname[refname_len - 1] == '/'; 509 if (is_dir) { 510 /* 511 * refname represents a reference directory. Remove 512 * the trailing slash; otherwise we will get the 513 * directory *representing* refname rather than the 514 * one *containing* it. 515 */ 516 char *dirname = xmemdupz(refname, refname_len - 1); 517 dir = find_containing_dir(dir, dirname, 0); 518 free(dirname); 519 } else { 520 dir = find_containing_dir(dir, refname, 0); 521 } 522 if (!dir) 523 return -1; 524 entry_index = search_ref_dir(dir, refname, refname_len); 525 if (entry_index == -1) 526 return -1; 527 entry = dir->entries[entry_index]; 528 529 memmove(&dir->entries[entry_index], 530 &dir->entries[entry_index + 1], 531 (dir->nr - entry_index - 1) * sizeof(*dir->entries) 532 ); 533 dir->nr--; 534 if (dir->sorted > entry_index) 535 dir->sorted--; 536 free_ref_entry(entry); 537 return dir->nr; 538} 539 540/* 541 * Add a ref_entry to the ref_dir (unsorted), recursing into 542 * subdirectories as necessary. dir must represent the top-level 543 * directory. Return 0 on success. 544 */ 545static int add_ref(struct ref_dir *dir, struct ref_entry *ref) 546{ 547 dir = find_containing_dir(dir, ref->name, 1); 548 if (!dir) 549 return -1; 550 add_entry_to_dir(dir, ref); 551 return 0; 552} 553 554/* 555 * Emit a warning and return true iff ref1 and ref2 have the same name 556 * and the same sha1. Die if they have the same name but different 557 * sha1s. 558 */ 559static int is_dup_ref(const struct ref_entry *ref1, const struct ref_entry *ref2) 560{ 561 if (strcmp(ref1->name, ref2->name)) 562 return 0; 563 564 /* Duplicate name; make sure that they don't conflict: */ 565 566 if ((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR)) 567 /* This is impossible by construction */ 568 die("Reference directory conflict: %s", ref1->name); 569 570 if (hashcmp(ref1->u.value.sha1, ref2->u.value.sha1)) 571 die("Duplicated ref, and SHA1s don't match: %s", ref1->name); 572 573 warning("Duplicated ref: %s", ref1->name); 574 return 1; 575} 576 577/* 578 * Sort the entries in dir non-recursively (if they are not already 579 * sorted) and remove any duplicate entries. 580 */ 581static void sort_ref_dir(struct ref_dir *dir) 582{ 583 int i, j; 584 struct ref_entry *last = NULL; 585 586 /* 587 * This check also prevents passing a zero-length array to qsort(), 588 * which is a problem on some platforms. 589 */ 590 if (dir->sorted == dir->nr) 591 return; 592 593 qsort(dir->entries, dir->nr, sizeof(*dir->entries), ref_entry_cmp); 594 595 /* Remove any duplicates: */ 596 for (i = 0, j = 0; j < dir->nr; j++) { 597 struct ref_entry *entry = dir->entries[j]; 598 if (last && is_dup_ref(last, entry)) 599 free_ref_entry(entry); 600 else 601 last = dir->entries[i++] = entry; 602 } 603 dir->sorted = dir->nr = i; 604} 605 606/* Include broken references in a do_for_each_ref*() iteration: */ 607#define DO_FOR_EACH_INCLUDE_BROKEN 0x01 608 609/* 610 * Return true iff the reference described by entry can be resolved to 611 * an object in the database. Emit a warning if the referred-to 612 * object does not exist. 613 */ 614static int ref_resolves_to_object(struct ref_entry *entry) 615{ 616 if (entry->flag & REF_ISBROKEN) 617 return 0; 618 if (!has_sha1_file(entry->u.value.sha1)) { 619 error("%s does not point to a valid object!", entry->name); 620 return 0; 621 } 622 return 1; 623} 624 625/* 626 * current_ref is a performance hack: when iterating over references 627 * using the for_each_ref*() functions, current_ref is set to the 628 * current reference's entry before calling the callback function. If 629 * the callback function calls peel_ref(), then peel_ref() first 630 * checks whether the reference to be peeled is the current reference 631 * (it usually is) and if so, returns that reference's peeled version 632 * if it is available. This avoids a refname lookup in a common case. 633 */ 634static struct ref_entry *current_ref; 635 636typedef int each_ref_entry_fn(struct ref_entry *entry, void *cb_data); 637 638struct ref_entry_cb { 639 const char *base; 640 int trim; 641 int flags; 642 each_ref_fn *fn; 643 void *cb_data; 644}; 645 646/* 647 * Handle one reference in a do_for_each_ref*()-style iteration, 648 * calling an each_ref_fn for each entry. 649 */ 650static int do_one_ref(struct ref_entry *entry, void *cb_data) 651{ 652 struct ref_entry_cb *data = cb_data; 653 struct ref_entry *old_current_ref; 654 int retval; 655 656 if (!starts_with(entry->name, data->base)) 657 return 0; 658 659 if (!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 660 !ref_resolves_to_object(entry)) 661 return 0; 662 663 /* Store the old value, in case this is a recursive call: */ 664 old_current_ref = current_ref; 665 current_ref = entry; 666 retval = data->fn(entry->name + data->trim, entry->u.value.sha1, 667 entry->flag, data->cb_data); 668 current_ref = old_current_ref; 669 return retval; 670} 671 672/* 673 * Call fn for each reference in dir that has index in the range 674 * offset <= index < dir->nr. Recurse into subdirectories that are in 675 * that index range, sorting them before iterating. This function 676 * does not sort dir itself; it should be sorted beforehand. fn is 677 * called for all references, including broken ones. 678 */ 679static int do_for_each_entry_in_dir(struct ref_dir *dir, int offset, 680 each_ref_entry_fn fn, void *cb_data) 681{ 682 int i; 683 assert(dir->sorted == dir->nr); 684 for (i = offset; i < dir->nr; i++) { 685 struct ref_entry *entry = dir->entries[i]; 686 int retval; 687 if (entry->flag & REF_DIR) { 688 struct ref_dir *subdir = get_ref_dir(entry); 689 sort_ref_dir(subdir); 690 retval = do_for_each_entry_in_dir(subdir, 0, fn, cb_data); 691 } else { 692 retval = fn(entry, cb_data); 693 } 694 if (retval) 695 return retval; 696 } 697 return 0; 698} 699 700/* 701 * Call fn for each reference in the union of dir1 and dir2, in order 702 * by refname. Recurse into subdirectories. If a value entry appears 703 * in both dir1 and dir2, then only process the version that is in 704 * dir2. The input dirs must already be sorted, but subdirs will be 705 * sorted as needed. fn is called for all references, including 706 * broken ones. 707 */ 708static int do_for_each_entry_in_dirs(struct ref_dir *dir1, 709 struct ref_dir *dir2, 710 each_ref_entry_fn fn, void *cb_data) 711{ 712 int retval; 713 int i1 = 0, i2 = 0; 714 715 assert(dir1->sorted == dir1->nr); 716 assert(dir2->sorted == dir2->nr); 717 while (1) { 718 struct ref_entry *e1, *e2; 719 int cmp; 720 if (i1 == dir1->nr) { 721 return do_for_each_entry_in_dir(dir2, i2, fn, cb_data); 722 } 723 if (i2 == dir2->nr) { 724 return do_for_each_entry_in_dir(dir1, i1, fn, cb_data); 725 } 726 e1 = dir1->entries[i1]; 727 e2 = dir2->entries[i2]; 728 cmp = strcmp(e1->name, e2->name); 729 if (cmp == 0) { 730 if ((e1->flag & REF_DIR) && (e2->flag & REF_DIR)) { 731 /* Both are directories; descend them in parallel. */ 732 struct ref_dir *subdir1 = get_ref_dir(e1); 733 struct ref_dir *subdir2 = get_ref_dir(e2); 734 sort_ref_dir(subdir1); 735 sort_ref_dir(subdir2); 736 retval = do_for_each_entry_in_dirs( 737 subdir1, subdir2, fn, cb_data); 738 i1++; 739 i2++; 740 } else if (!(e1->flag & REF_DIR) && !(e2->flag & REF_DIR)) { 741 /* Both are references; ignore the one from dir1. */ 742 retval = fn(e2, cb_data); 743 i1++; 744 i2++; 745 } else { 746 die("conflict between reference and directory: %s", 747 e1->name); 748 } 749 } else { 750 struct ref_entry *e; 751 if (cmp < 0) { 752 e = e1; 753 i1++; 754 } else { 755 e = e2; 756 i2++; 757 } 758 if (e->flag & REF_DIR) { 759 struct ref_dir *subdir = get_ref_dir(e); 760 sort_ref_dir(subdir); 761 retval = do_for_each_entry_in_dir( 762 subdir, 0, fn, cb_data); 763 } else { 764 retval = fn(e, cb_data); 765 } 766 } 767 if (retval) 768 return retval; 769 } 770} 771 772/* 773 * Load all of the refs from the dir into our in-memory cache. The hard work 774 * of loading loose refs is done by get_ref_dir(), so we just need to recurse 775 * through all of the sub-directories. We do not even need to care about 776 * sorting, as traversal order does not matter to us. 777 */ 778static void prime_ref_dir(struct ref_dir *dir) 779{ 780 int i; 781 for (i = 0; i < dir->nr; i++) { 782 struct ref_entry *entry = dir->entries[i]; 783 if (entry->flag & REF_DIR) 784 prime_ref_dir(get_ref_dir(entry)); 785 } 786} 787 788static int entry_matches(struct ref_entry *entry, const char *refname) 789{ 790 return refname && !strcmp(entry->name, refname); 791} 792 793struct nonmatching_ref_data { 794 const char *skip; 795 struct ref_entry *found; 796}; 797 798static int nonmatching_ref_fn(struct ref_entry *entry, void *vdata) 799{ 800 struct nonmatching_ref_data *data = vdata; 801 802 if (entry_matches(entry, data->skip)) 803 return 0; 804 805 data->found = entry; 806 return 1; 807} 808 809static void report_refname_conflict(struct ref_entry *entry, 810 const char *refname) 811{ 812 error("'%s' exists; cannot create '%s'", entry->name, refname); 813} 814 815/* 816 * Return true iff a reference named refname could be created without 817 * conflicting with the name of an existing reference in dir. If 818 * oldrefname is non-NULL, ignore potential conflicts with oldrefname 819 * (e.g., because oldrefname is scheduled for deletion in the same 820 * operation). 821 * 822 * Two reference names conflict if one of them exactly matches the 823 * leading components of the other; e.g., "foo/bar" conflicts with 824 * both "foo" and with "foo/bar/baz" but not with "foo/bar" or 825 * "foo/barbados". 826 */ 827static int is_refname_available(const char *refname, const char *oldrefname, 828 struct ref_dir *dir) 829{ 830 const char *slash; 831 size_t len; 832 int pos; 833 char *dirname; 834 835 for (slash = strchr(refname, '/'); slash; slash = strchr(slash + 1, '/')) { 836 /* 837 * We are still at a leading dir of the refname; we are 838 * looking for a conflict with a leaf entry. 839 * 840 * If we find one, we still must make sure it is 841 * not "oldrefname". 842 */ 843 pos = search_ref_dir(dir, refname, slash - refname); 844 if (pos >= 0) { 845 struct ref_entry *entry = dir->entries[pos]; 846 if (entry_matches(entry, oldrefname)) 847 return 1; 848 report_refname_conflict(entry, refname); 849 return 0; 850 } 851 852 853 /* 854 * Otherwise, we can try to continue our search with 855 * the next component; if we come up empty, we know 856 * there is nothing under this whole prefix. 857 */ 858 pos = search_ref_dir(dir, refname, slash + 1 - refname); 859 if (pos < 0) 860 return 1; 861 862 dir = get_ref_dir(dir->entries[pos]); 863 } 864 865 /* 866 * We are at the leaf of our refname; we want to 867 * make sure there are no directories which match it. 868 */ 869 len = strlen(refname); 870 dirname = xmallocz(len + 1); 871 sprintf(dirname, "%s/", refname); 872 pos = search_ref_dir(dir, dirname, len + 1); 873 free(dirname); 874 875 if (pos >= 0) { 876 /* 877 * We found a directory named "refname". It is a 878 * problem iff it contains any ref that is not 879 * "oldrefname". 880 */ 881 struct ref_entry *entry = dir->entries[pos]; 882 struct ref_dir *dir = get_ref_dir(entry); 883 struct nonmatching_ref_data data; 884 885 data.skip = oldrefname; 886 sort_ref_dir(dir); 887 if (!do_for_each_entry_in_dir(dir, 0, nonmatching_ref_fn, &data)) 888 return 1; 889 890 report_refname_conflict(data.found, refname); 891 return 0; 892 } 893 894 /* 895 * There is no point in searching for another leaf 896 * node which matches it; such an entry would be the 897 * ref we are looking for, not a conflict. 898 */ 899 return 1; 900} 901 902struct packed_ref_cache { 903 struct ref_entry *root; 904 905 /* 906 * Count of references to the data structure in this instance, 907 * including the pointer from ref_cache::packed if any. The 908 * data will not be freed as long as the reference count is 909 * nonzero. 910 */ 911 unsigned int referrers; 912 913 /* 914 * Iff the packed-refs file associated with this instance is 915 * currently locked for writing, this points at the associated 916 * lock (which is owned by somebody else). The referrer count 917 * is also incremented when the file is locked and decremented 918 * when it is unlocked. 919 */ 920 struct lock_file *lock; 921 922 /* The metadata from when this packed-refs cache was read */ 923 struct stat_validity validity; 924}; 925 926/* 927 * Future: need to be in "struct repository" 928 * when doing a full libification. 929 */ 930static struct ref_cache { 931 struct ref_cache *next; 932 struct ref_entry *loose; 933 struct packed_ref_cache *packed; 934 /* 935 * The submodule name, or "" for the main repo. We allocate 936 * length 1 rather than FLEX_ARRAY so that the main ref_cache 937 * is initialized correctly. 938 */ 939 char name[1]; 940} ref_cache, *submodule_ref_caches; 941 942/* Lock used for the main packed-refs file: */ 943static struct lock_file packlock; 944 945/* 946 * Increment the reference count of *packed_refs. 947 */ 948static void acquire_packed_ref_cache(struct packed_ref_cache *packed_refs) 949{ 950 packed_refs->referrers++; 951} 952 953/* 954 * Decrease the reference count of *packed_refs. If it goes to zero, 955 * free *packed_refs and return true; otherwise return false. 956 */ 957static int release_packed_ref_cache(struct packed_ref_cache *packed_refs) 958{ 959 if (!--packed_refs->referrers) { 960 free_ref_entry(packed_refs->root); 961 stat_validity_clear(&packed_refs->validity); 962 free(packed_refs); 963 return 1; 964 } else { 965 return 0; 966 } 967} 968 969static void clear_packed_ref_cache(struct ref_cache *refs) 970{ 971 if (refs->packed) { 972 struct packed_ref_cache *packed_refs = refs->packed; 973 974 if (packed_refs->lock) 975 die("internal error: packed-ref cache cleared while locked"); 976 refs->packed = NULL; 977 release_packed_ref_cache(packed_refs); 978 } 979} 980 981static void clear_loose_ref_cache(struct ref_cache *refs) 982{ 983 if (refs->loose) { 984 free_ref_entry(refs->loose); 985 refs->loose = NULL; 986 } 987} 988 989static struct ref_cache *create_ref_cache(const char *submodule) 990{ 991 int len; 992 struct ref_cache *refs; 993 if (!submodule) 994 submodule = ""; 995 len = strlen(submodule) + 1; 996 refs = xcalloc(1, sizeof(struct ref_cache) + len); 997 memcpy(refs->name, submodule, len); 998 return refs; 999}10001001/*1002 * Return a pointer to a ref_cache for the specified submodule. For1003 * the main repository, use submodule==NULL. The returned structure1004 * will be allocated and initialized but not necessarily populated; it1005 * should not be freed.1006 */1007static struct ref_cache *get_ref_cache(const char *submodule)1008{1009 struct ref_cache *refs;10101011 if (!submodule || !*submodule)1012 return &ref_cache;10131014 for (refs = submodule_ref_caches; refs; refs = refs->next)1015 if (!strcmp(submodule, refs->name))1016 return refs;10171018 refs = create_ref_cache(submodule);1019 refs->next = submodule_ref_caches;1020 submodule_ref_caches = refs;1021 return refs;1022}10231024/* The length of a peeled reference line in packed-refs, including EOL: */1025#define PEELED_LINE_LENGTH 4210261027/*1028 * The packed-refs header line that we write out. Perhaps other1029 * traits will be added later. The trailing space is required.1030 */1031static const char PACKED_REFS_HEADER[] =1032 "# pack-refs with: peeled fully-peeled \n";10331034/*1035 * Parse one line from a packed-refs file. Write the SHA1 to sha1.1036 * Return a pointer to the refname within the line (null-terminated),1037 * or NULL if there was a problem.1038 */1039static const char *parse_ref_line(char *line, unsigned char *sha1)1040{1041 /*1042 * 42: the answer to everything.1043 *1044 * In this case, it happens to be the answer to1045 * 40 (length of sha1 hex representation)1046 * +1 (space in between hex and name)1047 * +1 (newline at the end of the line)1048 */1049 int len = strlen(line) - 42;10501051 if (len <= 0)1052 return NULL;1053 if (get_sha1_hex(line, sha1) < 0)1054 return NULL;1055 if (!isspace(line[40]))1056 return NULL;1057 line += 41;1058 if (isspace(*line))1059 return NULL;1060 if (line[len] != '\n')1061 return NULL;1062 line[len] = 0;10631064 return line;1065}10661067/*1068 * Read f, which is a packed-refs file, into dir.1069 *1070 * A comment line of the form "# pack-refs with: " may contain zero or1071 * more traits. We interpret the traits as follows:1072 *1073 * No traits:1074 *1075 * Probably no references are peeled. But if the file contains a1076 * peeled value for a reference, we will use it.1077 *1078 * peeled:1079 *1080 * References under "refs/tags/", if they *can* be peeled, *are*1081 * peeled in this file. References outside of "refs/tags/" are1082 * probably not peeled even if they could have been, but if we find1083 * a peeled value for such a reference we will use it.1084 *1085 * fully-peeled:1086 *1087 * All references in the file that can be peeled are peeled.1088 * Inversely (and this is more important), any references in the1089 * file for which no peeled value is recorded is not peelable. This1090 * trait should typically be written alongside "peeled" for1091 * compatibility with older clients, but we do not require it1092 * (i.e., "peeled" is a no-op if "fully-peeled" is set).1093 */1094static void read_packed_refs(FILE *f, struct ref_dir *dir)1095{1096 struct ref_entry *last = NULL;1097 char refline[PATH_MAX];1098 enum { PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;10991100 while (fgets(refline, sizeof(refline), f)) {1101 unsigned char sha1[20];1102 const char *refname;1103 static const char header[] = "# pack-refs with:";11041105 if (!strncmp(refline, header, sizeof(header)-1)) {1106 const char *traits = refline + sizeof(header) - 1;1107 if (strstr(traits, " fully-peeled "))1108 peeled = PEELED_FULLY;1109 else if (strstr(traits, " peeled "))1110 peeled = PEELED_TAGS;1111 /* perhaps other traits later as well */1112 continue;1113 }11141115 refname = parse_ref_line(refline, sha1);1116 if (refname) {1117 last = create_ref_entry(refname, sha1, REF_ISPACKED, 1);1118 if (peeled == PEELED_FULLY ||1119 (peeled == PEELED_TAGS && starts_with(refname, "refs/tags/")))1120 last->flag |= REF_KNOWS_PEELED;1121 add_ref(dir, last);1122 continue;1123 }1124 if (last &&1125 refline[0] == '^' &&1126 strlen(refline) == PEELED_LINE_LENGTH &&1127 refline[PEELED_LINE_LENGTH - 1] == '\n' &&1128 !get_sha1_hex(refline + 1, sha1)) {1129 hashcpy(last->u.value.peeled, sha1);1130 /*1131 * Regardless of what the file header said,1132 * we definitely know the value of *this*1133 * reference:1134 */1135 last->flag |= REF_KNOWS_PEELED;1136 }1137 }1138}11391140/*1141 * Get the packed_ref_cache for the specified ref_cache, creating it1142 * if necessary.1143 */1144static struct packed_ref_cache *get_packed_ref_cache(struct ref_cache *refs)1145{1146 const char *packed_refs_file;11471148 if (*refs->name)1149 packed_refs_file = git_path_submodule(refs->name, "packed-refs");1150 else1151 packed_refs_file = git_path("packed-refs");11521153 if (refs->packed &&1154 !stat_validity_check(&refs->packed->validity, packed_refs_file))1155 clear_packed_ref_cache(refs);11561157 if (!refs->packed) {1158 FILE *f;11591160 refs->packed = xcalloc(1, sizeof(*refs->packed));1161 acquire_packed_ref_cache(refs->packed);1162 refs->packed->root = create_dir_entry(refs, "", 0, 0);1163 f = fopen(packed_refs_file, "r");1164 if (f) {1165 stat_validity_update(&refs->packed->validity, fileno(f));1166 read_packed_refs(f, get_ref_dir(refs->packed->root));1167 fclose(f);1168 }1169 }1170 return refs->packed;1171}11721173static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)1174{1175 return get_ref_dir(packed_ref_cache->root);1176}11771178static struct ref_dir *get_packed_refs(struct ref_cache *refs)1179{1180 return get_packed_ref_dir(get_packed_ref_cache(refs));1181}11821183void add_packed_ref(const char *refname, const unsigned char *sha1)1184{1185 struct packed_ref_cache *packed_ref_cache =1186 get_packed_ref_cache(&ref_cache);11871188 if (!packed_ref_cache->lock)1189 die("internal error: packed refs not locked");1190 add_ref(get_packed_ref_dir(packed_ref_cache),1191 create_ref_entry(refname, sha1, REF_ISPACKED, 1));1192}11931194/*1195 * Read the loose references from the namespace dirname into dir1196 * (without recursing). dirname must end with '/'. dir must be the1197 * directory entry corresponding to dirname.1198 */1199static void read_loose_refs(const char *dirname, struct ref_dir *dir)1200{1201 struct ref_cache *refs = dir->ref_cache;1202 DIR *d;1203 const char *path;1204 struct dirent *de;1205 int dirnamelen = strlen(dirname);1206 struct strbuf refname;12071208 if (*refs->name)1209 path = git_path_submodule(refs->name, "%s", dirname);1210 else1211 path = git_path("%s", dirname);12121213 d = opendir(path);1214 if (!d)1215 return;12161217 strbuf_init(&refname, dirnamelen + 257);1218 strbuf_add(&refname, dirname, dirnamelen);12191220 while ((de = readdir(d)) != NULL) {1221 unsigned char sha1[20];1222 struct stat st;1223 int flag;1224 const char *refdir;12251226 if (de->d_name[0] == '.')1227 continue;1228 if (ends_with(de->d_name, ".lock"))1229 continue;1230 strbuf_addstr(&refname, de->d_name);1231 refdir = *refs->name1232 ? git_path_submodule(refs->name, "%s", refname.buf)1233 : git_path("%s", refname.buf);1234 if (stat(refdir, &st) < 0) {1235 ; /* silently ignore */1236 } else if (S_ISDIR(st.st_mode)) {1237 strbuf_addch(&refname, '/');1238 add_entry_to_dir(dir,1239 create_dir_entry(refs, refname.buf,1240 refname.len, 1));1241 } else {1242 if (*refs->name) {1243 hashclr(sha1);1244 flag = 0;1245 if (resolve_gitlink_ref(refs->name, refname.buf, sha1) < 0) {1246 hashclr(sha1);1247 flag |= REF_ISBROKEN;1248 }1249 } else if (read_ref_full(refname.buf, sha1, 1, &flag)) {1250 hashclr(sha1);1251 flag |= REF_ISBROKEN;1252 }1253 add_entry_to_dir(dir,1254 create_ref_entry(refname.buf, sha1, flag, 1));1255 }1256 strbuf_setlen(&refname, dirnamelen);1257 }1258 strbuf_release(&refname);1259 closedir(d);1260}12611262static struct ref_dir *get_loose_refs(struct ref_cache *refs)1263{1264 if (!refs->loose) {1265 /*1266 * Mark the top-level directory complete because we1267 * are about to read the only subdirectory that can1268 * hold references:1269 */1270 refs->loose = create_dir_entry(refs, "", 0, 0);1271 /*1272 * Create an incomplete entry for "refs/":1273 */1274 add_entry_to_dir(get_ref_dir(refs->loose),1275 create_dir_entry(refs, "refs/", 5, 1));1276 }1277 return get_ref_dir(refs->loose);1278}12791280/* We allow "recursive" symbolic refs. Only within reason, though */1281#define MAXDEPTH 51282#define MAXREFLEN (1024)12831284/*1285 * Called by resolve_gitlink_ref_recursive() after it failed to read1286 * from the loose refs in ref_cache refs. Find <refname> in the1287 * packed-refs file for the submodule.1288 */1289static int resolve_gitlink_packed_ref(struct ref_cache *refs,1290 const char *refname, unsigned char *sha1)1291{1292 struct ref_entry *ref;1293 struct ref_dir *dir = get_packed_refs(refs);12941295 ref = find_ref(dir, refname);1296 if (ref == NULL)1297 return -1;12981299 hashcpy(sha1, ref->u.value.sha1);1300 return 0;1301}13021303static int resolve_gitlink_ref_recursive(struct ref_cache *refs,1304 const char *refname, unsigned char *sha1,1305 int recursion)1306{1307 int fd, len;1308 char buffer[128], *p;1309 char *path;13101311 if (recursion > MAXDEPTH || strlen(refname) > MAXREFLEN)1312 return -1;1313 path = *refs->name1314 ? git_path_submodule(refs->name, "%s", refname)1315 : git_path("%s", refname);1316 fd = open(path, O_RDONLY);1317 if (fd < 0)1318 return resolve_gitlink_packed_ref(refs, refname, sha1);13191320 len = read(fd, buffer, sizeof(buffer)-1);1321 close(fd);1322 if (len < 0)1323 return -1;1324 while (len && isspace(buffer[len-1]))1325 len--;1326 buffer[len] = 0;13271328 /* Was it a detached head or an old-fashioned symlink? */1329 if (!get_sha1_hex(buffer, sha1))1330 return 0;13311332 /* Symref? */1333 if (strncmp(buffer, "ref:", 4))1334 return -1;1335 p = buffer + 4;1336 while (isspace(*p))1337 p++;13381339 return resolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);1340}13411342int resolve_gitlink_ref(const char *path, const char *refname, unsigned char *sha1)1343{1344 int len = strlen(path), retval;1345 char *submodule;1346 struct ref_cache *refs;13471348 while (len && path[len-1] == '/')1349 len--;1350 if (!len)1351 return -1;1352 submodule = xstrndup(path, len);1353 refs = get_ref_cache(submodule);1354 free(submodule);13551356 retval = resolve_gitlink_ref_recursive(refs, refname, sha1, 0);1357 return retval;1358}13591360/*1361 * Return the ref_entry for the given refname from the packed1362 * references. If it does not exist, return NULL.1363 */1364static struct ref_entry *get_packed_ref(const char *refname)1365{1366 return find_ref(get_packed_refs(&ref_cache), refname);1367}13681369/*1370 * A loose ref file doesn't exist; check for a packed ref. The1371 * options are forwarded from resolve_safe_unsafe().1372 */1373static const char *handle_missing_loose_ref(const char *refname,1374 unsigned char *sha1,1375 int reading,1376 int *flag)1377{1378 struct ref_entry *entry;13791380 /*1381 * The loose reference file does not exist; check for a packed1382 * reference.1383 */1384 entry = get_packed_ref(refname);1385 if (entry) {1386 hashcpy(sha1, entry->u.value.sha1);1387 if (flag)1388 *flag |= REF_ISPACKED;1389 return refname;1390 }1391 /* The reference is not a packed reference, either. */1392 if (reading) {1393 return NULL;1394 } else {1395 hashclr(sha1);1396 return refname;1397 }1398}13991400/* This function needs to return a meaningful errno on failure */1401const char *resolve_ref_unsafe(const char *refname, unsigned char *sha1, int reading, int *flag)1402{1403 int depth = MAXDEPTH;1404 ssize_t len;1405 char buffer[256];1406 static char refname_buffer[256];14071408 if (flag)1409 *flag = 0;14101411 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL)) {1412 errno = EINVAL;1413 return NULL;1414 }14151416 for (;;) {1417 char path[PATH_MAX];1418 struct stat st;1419 char *buf;1420 int fd;14211422 if (--depth < 0) {1423 errno = ELOOP;1424 return NULL;1425 }14261427 git_snpath(path, sizeof(path), "%s", refname);14281429 /*1430 * We might have to loop back here to avoid a race1431 * condition: first we lstat() the file, then we try1432 * to read it as a link or as a file. But if somebody1433 * changes the type of the file (file <-> directory1434 * <-> symlink) between the lstat() and reading, then1435 * we don't want to report that as an error but rather1436 * try again starting with the lstat().1437 */1438 stat_ref:1439 if (lstat(path, &st) < 0) {1440 if (errno == ENOENT)1441 return handle_missing_loose_ref(refname, sha1,1442 reading, flag);1443 else1444 return NULL;1445 }14461447 /* Follow "normalized" - ie "refs/.." symlinks by hand */1448 if (S_ISLNK(st.st_mode)) {1449 len = readlink(path, buffer, sizeof(buffer)-1);1450 if (len < 0) {1451 if (errno == ENOENT || errno == EINVAL)1452 /* inconsistent with lstat; retry */1453 goto stat_ref;1454 else1455 return NULL;1456 }1457 buffer[len] = 0;1458 if (starts_with(buffer, "refs/") &&1459 !check_refname_format(buffer, 0)) {1460 strcpy(refname_buffer, buffer);1461 refname = refname_buffer;1462 if (flag)1463 *flag |= REF_ISSYMREF;1464 continue;1465 }1466 }14671468 /* Is it a directory? */1469 if (S_ISDIR(st.st_mode)) {1470 errno = EISDIR;1471 return NULL;1472 }14731474 /*1475 * Anything else, just open it and try to use it as1476 * a ref1477 */1478 fd = open(path, O_RDONLY);1479 if (fd < 0) {1480 if (errno == ENOENT)1481 /* inconsistent with lstat; retry */1482 goto stat_ref;1483 else1484 return NULL;1485 }1486 len = read_in_full(fd, buffer, sizeof(buffer)-1);1487 if (len < 0) {1488 int save_errno = errno;1489 close(fd);1490 errno = save_errno;1491 return NULL;1492 }1493 close(fd);1494 while (len && isspace(buffer[len-1]))1495 len--;1496 buffer[len] = '\0';14971498 /*1499 * Is it a symbolic ref?1500 */1501 if (!starts_with(buffer, "ref:")) {1502 /*1503 * Please note that FETCH_HEAD has a second1504 * line containing other data.1505 */1506 if (get_sha1_hex(buffer, sha1) ||1507 (buffer[40] != '\0' && !isspace(buffer[40]))) {1508 if (flag)1509 *flag |= REF_ISBROKEN;1510 errno = EINVAL;1511 return NULL;1512 }1513 return refname;1514 }1515 if (flag)1516 *flag |= REF_ISSYMREF;1517 buf = buffer + 4;1518 while (isspace(*buf))1519 buf++;1520 if (check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {1521 if (flag)1522 *flag |= REF_ISBROKEN;1523 errno = EINVAL;1524 return NULL;1525 }1526 refname = strcpy(refname_buffer, buf);1527 }1528}15291530char *resolve_refdup(const char *ref, unsigned char *sha1, int reading, int *flag)1531{1532 const char *ret = resolve_ref_unsafe(ref, sha1, reading, flag);1533 return ret ? xstrdup(ret) : NULL;1534}15351536/* The argument to filter_refs */1537struct ref_filter {1538 const char *pattern;1539 each_ref_fn *fn;1540 void *cb_data;1541};15421543int read_ref_full(const char *refname, unsigned char *sha1, int reading, int *flags)1544{1545 if (resolve_ref_unsafe(refname, sha1, reading, flags))1546 return 0;1547 return -1;1548}15491550int read_ref(const char *refname, unsigned char *sha1)1551{1552 return read_ref_full(refname, sha1, 1, NULL);1553}15541555int ref_exists(const char *refname)1556{1557 unsigned char sha1[20];1558 return !!resolve_ref_unsafe(refname, sha1, 1, NULL);1559}15601561static int filter_refs(const char *refname, const unsigned char *sha1, int flags,1562 void *data)1563{1564 struct ref_filter *filter = (struct ref_filter *)data;1565 if (wildmatch(filter->pattern, refname, 0, NULL))1566 return 0;1567 return filter->fn(refname, sha1, flags, filter->cb_data);1568}15691570enum peel_status {1571 /* object was peeled successfully: */1572 PEEL_PEELED = 0,15731574 /*1575 * object cannot be peeled because the named object (or an1576 * object referred to by a tag in the peel chain), does not1577 * exist.1578 */1579 PEEL_INVALID = -1,15801581 /* object cannot be peeled because it is not a tag: */1582 PEEL_NON_TAG = -2,15831584 /* ref_entry contains no peeled value because it is a symref: */1585 PEEL_IS_SYMREF = -3,15861587 /*1588 * ref_entry cannot be peeled because it is broken (i.e., the1589 * symbolic reference cannot even be resolved to an object1590 * name):1591 */1592 PEEL_BROKEN = -41593};15941595/*1596 * Peel the named object; i.e., if the object is a tag, resolve the1597 * tag recursively until a non-tag is found. If successful, store the1598 * result to sha1 and return PEEL_PEELED. If the object is not a tag1599 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,1600 * and leave sha1 unchanged.1601 */1602static enum peel_status peel_object(const unsigned char *name, unsigned char *sha1)1603{1604 struct object *o = lookup_unknown_object(name);16051606 if (o->type == OBJ_NONE) {1607 int type = sha1_object_info(name, NULL);1608 if (type < 0 || !object_as_type(o, type, 0))1609 return PEEL_INVALID;1610 }16111612 if (o->type != OBJ_TAG)1613 return PEEL_NON_TAG;16141615 o = deref_tag_noverify(o);1616 if (!o)1617 return PEEL_INVALID;16181619 hashcpy(sha1, o->sha1);1620 return PEEL_PEELED;1621}16221623/*1624 * Peel the entry (if possible) and return its new peel_status. If1625 * repeel is true, re-peel the entry even if there is an old peeled1626 * value that is already stored in it.1627 *1628 * It is OK to call this function with a packed reference entry that1629 * might be stale and might even refer to an object that has since1630 * been garbage-collected. In such a case, if the entry has1631 * REF_KNOWS_PEELED then leave the status unchanged and return1632 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.1633 */1634static enum peel_status peel_entry(struct ref_entry *entry, int repeel)1635{1636 enum peel_status status;16371638 if (entry->flag & REF_KNOWS_PEELED) {1639 if (repeel) {1640 entry->flag &= ~REF_KNOWS_PEELED;1641 hashclr(entry->u.value.peeled);1642 } else {1643 return is_null_sha1(entry->u.value.peeled) ?1644 PEEL_NON_TAG : PEEL_PEELED;1645 }1646 }1647 if (entry->flag & REF_ISBROKEN)1648 return PEEL_BROKEN;1649 if (entry->flag & REF_ISSYMREF)1650 return PEEL_IS_SYMREF;16511652 status = peel_object(entry->u.value.sha1, entry->u.value.peeled);1653 if (status == PEEL_PEELED || status == PEEL_NON_TAG)1654 entry->flag |= REF_KNOWS_PEELED;1655 return status;1656}16571658int peel_ref(const char *refname, unsigned char *sha1)1659{1660 int flag;1661 unsigned char base[20];16621663 if (current_ref && (current_ref->name == refname1664 || !strcmp(current_ref->name, refname))) {1665 if (peel_entry(current_ref, 0))1666 return -1;1667 hashcpy(sha1, current_ref->u.value.peeled);1668 return 0;1669 }16701671 if (read_ref_full(refname, base, 1, &flag))1672 return -1;16731674 /*1675 * If the reference is packed, read its ref_entry from the1676 * cache in the hope that we already know its peeled value.1677 * We only try this optimization on packed references because1678 * (a) forcing the filling of the loose reference cache could1679 * be expensive and (b) loose references anyway usually do not1680 * have REF_KNOWS_PEELED.1681 */1682 if (flag & REF_ISPACKED) {1683 struct ref_entry *r = get_packed_ref(refname);1684 if (r) {1685 if (peel_entry(r, 0))1686 return -1;1687 hashcpy(sha1, r->u.value.peeled);1688 return 0;1689 }1690 }16911692 return peel_object(base, sha1);1693}16941695struct warn_if_dangling_data {1696 FILE *fp;1697 const char *refname;1698 const struct string_list *refnames;1699 const char *msg_fmt;1700};17011702static int warn_if_dangling_symref(const char *refname, const unsigned char *sha1,1703 int flags, void *cb_data)1704{1705 struct warn_if_dangling_data *d = cb_data;1706 const char *resolves_to;1707 unsigned char junk[20];17081709 if (!(flags & REF_ISSYMREF))1710 return 0;17111712 resolves_to = resolve_ref_unsafe(refname, junk, 0, NULL);1713 if (!resolves_to1714 || (d->refname1715 ? strcmp(resolves_to, d->refname)1716 : !string_list_has_string(d->refnames, resolves_to))) {1717 return 0;1718 }17191720 fprintf(d->fp, d->msg_fmt, refname);1721 fputc('\n', d->fp);1722 return 0;1723}17241725void warn_dangling_symref(FILE *fp, const char *msg_fmt, const char *refname)1726{1727 struct warn_if_dangling_data data;17281729 data.fp = fp;1730 data.refname = refname;1731 data.refnames = NULL;1732 data.msg_fmt = msg_fmt;1733 for_each_rawref(warn_if_dangling_symref, &data);1734}17351736void warn_dangling_symrefs(FILE *fp, const char *msg_fmt, const struct string_list *refnames)1737{1738 struct warn_if_dangling_data data;17391740 data.fp = fp;1741 data.refname = NULL;1742 data.refnames = refnames;1743 data.msg_fmt = msg_fmt;1744 for_each_rawref(warn_if_dangling_symref, &data);1745}17461747/*1748 * Call fn for each reference in the specified ref_cache, omitting1749 * references not in the containing_dir of base. fn is called for all1750 * references, including broken ones. If fn ever returns a non-zero1751 * value, stop the iteration and return that value; otherwise, return1752 * 0.1753 */1754static int do_for_each_entry(struct ref_cache *refs, const char *base,1755 each_ref_entry_fn fn, void *cb_data)1756{1757 struct packed_ref_cache *packed_ref_cache;1758 struct ref_dir *loose_dir;1759 struct ref_dir *packed_dir;1760 int retval = 0;17611762 /*1763 * We must make sure that all loose refs are read before accessing the1764 * packed-refs file; this avoids a race condition in which loose refs1765 * are migrated to the packed-refs file by a simultaneous process, but1766 * our in-memory view is from before the migration. get_packed_ref_cache()1767 * takes care of making sure our view is up to date with what is on1768 * disk.1769 */1770 loose_dir = get_loose_refs(refs);1771 if (base && *base) {1772 loose_dir = find_containing_dir(loose_dir, base, 0);1773 }1774 if (loose_dir)1775 prime_ref_dir(loose_dir);17761777 packed_ref_cache = get_packed_ref_cache(refs);1778 acquire_packed_ref_cache(packed_ref_cache);1779 packed_dir = get_packed_ref_dir(packed_ref_cache);1780 if (base && *base) {1781 packed_dir = find_containing_dir(packed_dir, base, 0);1782 }17831784 if (packed_dir && loose_dir) {1785 sort_ref_dir(packed_dir);1786 sort_ref_dir(loose_dir);1787 retval = do_for_each_entry_in_dirs(1788 packed_dir, loose_dir, fn, cb_data);1789 } else if (packed_dir) {1790 sort_ref_dir(packed_dir);1791 retval = do_for_each_entry_in_dir(1792 packed_dir, 0, fn, cb_data);1793 } else if (loose_dir) {1794 sort_ref_dir(loose_dir);1795 retval = do_for_each_entry_in_dir(1796 loose_dir, 0, fn, cb_data);1797 }17981799 release_packed_ref_cache(packed_ref_cache);1800 return retval;1801}18021803/*1804 * Call fn for each reference in the specified ref_cache for which the1805 * refname begins with base. If trim is non-zero, then trim that many1806 * characters off the beginning of each refname before passing the1807 * refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include1808 * broken references in the iteration. If fn ever returns a non-zero1809 * value, stop the iteration and return that value; otherwise, return1810 * 0.1811 */1812static int do_for_each_ref(struct ref_cache *refs, const char *base,1813 each_ref_fn fn, int trim, int flags, void *cb_data)1814{1815 struct ref_entry_cb data;1816 data.base = base;1817 data.trim = trim;1818 data.flags = flags;1819 data.fn = fn;1820 data.cb_data = cb_data;18211822 return do_for_each_entry(refs, base, do_one_ref, &data);1823}18241825static int do_head_ref(const char *submodule, each_ref_fn fn, void *cb_data)1826{1827 unsigned char sha1[20];1828 int flag;18291830 if (submodule) {1831 if (resolve_gitlink_ref(submodule, "HEAD", sha1) == 0)1832 return fn("HEAD", sha1, 0, cb_data);18331834 return 0;1835 }18361837 if (!read_ref_full("HEAD", sha1, 1, &flag))1838 return fn("HEAD", sha1, flag, cb_data);18391840 return 0;1841}18421843int head_ref(each_ref_fn fn, void *cb_data)1844{1845 return do_head_ref(NULL, fn, cb_data);1846}18471848int head_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1849{1850 return do_head_ref(submodule, fn, cb_data);1851}18521853int for_each_ref(each_ref_fn fn, void *cb_data)1854{1855 return do_for_each_ref(&ref_cache, "", fn, 0, 0, cb_data);1856}18571858int for_each_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1859{1860 return do_for_each_ref(get_ref_cache(submodule), "", fn, 0, 0, cb_data);1861}18621863int for_each_ref_in(const char *prefix, each_ref_fn fn, void *cb_data)1864{1865 return do_for_each_ref(&ref_cache, prefix, fn, strlen(prefix), 0, cb_data);1866}18671868int for_each_ref_in_submodule(const char *submodule, const char *prefix,1869 each_ref_fn fn, void *cb_data)1870{1871 return do_for_each_ref(get_ref_cache(submodule), prefix, fn, strlen(prefix), 0, cb_data);1872}18731874int for_each_tag_ref(each_ref_fn fn, void *cb_data)1875{1876 return for_each_ref_in("refs/tags/", fn, cb_data);1877}18781879int for_each_tag_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1880{1881 return for_each_ref_in_submodule(submodule, "refs/tags/", fn, cb_data);1882}18831884int for_each_branch_ref(each_ref_fn fn, void *cb_data)1885{1886 return for_each_ref_in("refs/heads/", fn, cb_data);1887}18881889int for_each_branch_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1890{1891 return for_each_ref_in_submodule(submodule, "refs/heads/", fn, cb_data);1892}18931894int for_each_remote_ref(each_ref_fn fn, void *cb_data)1895{1896 return for_each_ref_in("refs/remotes/", fn, cb_data);1897}18981899int for_each_remote_ref_submodule(const char *submodule, each_ref_fn fn, void *cb_data)1900{1901 return for_each_ref_in_submodule(submodule, "refs/remotes/", fn, cb_data);1902}19031904int for_each_replace_ref(each_ref_fn fn, void *cb_data)1905{1906 return do_for_each_ref(&ref_cache, "refs/replace/", fn, 13, 0, cb_data);1907}19081909int head_ref_namespaced(each_ref_fn fn, void *cb_data)1910{1911 struct strbuf buf = STRBUF_INIT;1912 int ret = 0;1913 unsigned char sha1[20];1914 int flag;19151916 strbuf_addf(&buf, "%sHEAD", get_git_namespace());1917 if (!read_ref_full(buf.buf, sha1, 1, &flag))1918 ret = fn(buf.buf, sha1, flag, cb_data);1919 strbuf_release(&buf);19201921 return ret;1922}19231924int for_each_namespaced_ref(each_ref_fn fn, void *cb_data)1925{1926 struct strbuf buf = STRBUF_INIT;1927 int ret;1928 strbuf_addf(&buf, "%srefs/", get_git_namespace());1929 ret = do_for_each_ref(&ref_cache, buf.buf, fn, 0, 0, cb_data);1930 strbuf_release(&buf);1931 return ret;1932}19331934int for_each_glob_ref_in(each_ref_fn fn, const char *pattern,1935 const char *prefix, void *cb_data)1936{1937 struct strbuf real_pattern = STRBUF_INIT;1938 struct ref_filter filter;1939 int ret;19401941 if (!prefix && !starts_with(pattern, "refs/"))1942 strbuf_addstr(&real_pattern, "refs/");1943 else if (prefix)1944 strbuf_addstr(&real_pattern, prefix);1945 strbuf_addstr(&real_pattern, pattern);19461947 if (!has_glob_specials(pattern)) {1948 /* Append implied '/' '*' if not present. */1949 if (real_pattern.buf[real_pattern.len - 1] != '/')1950 strbuf_addch(&real_pattern, '/');1951 /* No need to check for '*', there is none. */1952 strbuf_addch(&real_pattern, '*');1953 }19541955 filter.pattern = real_pattern.buf;1956 filter.fn = fn;1957 filter.cb_data = cb_data;1958 ret = for_each_ref(filter_refs, &filter);19591960 strbuf_release(&real_pattern);1961 return ret;1962}19631964int for_each_glob_ref(each_ref_fn fn, const char *pattern, void *cb_data)1965{1966 return for_each_glob_ref_in(fn, pattern, NULL, cb_data);1967}19681969int for_each_rawref(each_ref_fn fn, void *cb_data)1970{1971 return do_for_each_ref(&ref_cache, "", fn, 0,1972 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);1973}19741975const char *prettify_refname(const char *name)1976{1977 return name + (1978 starts_with(name, "refs/heads/") ? 11 :1979 starts_with(name, "refs/tags/") ? 10 :1980 starts_with(name, "refs/remotes/") ? 13 :1981 0);1982}19831984static const char *ref_rev_parse_rules[] = {1985 "%.*s",1986 "refs/%.*s",1987 "refs/tags/%.*s",1988 "refs/heads/%.*s",1989 "refs/remotes/%.*s",1990 "refs/remotes/%.*s/HEAD",1991 NULL1992};19931994int refname_match(const char *abbrev_name, const char *full_name)1995{1996 const char **p;1997 const int abbrev_name_len = strlen(abbrev_name);19981999 for (p = ref_rev_parse_rules; *p; p++) {2000 if (!strcmp(full_name, mkpath(*p, abbrev_name_len, abbrev_name))) {2001 return 1;2002 }2003 }20042005 return 0;2006}20072008/* This function should make sure errno is meaningful on error */2009static struct ref_lock *verify_lock(struct ref_lock *lock,2010 const unsigned char *old_sha1, int mustexist)2011{2012 if (read_ref_full(lock->ref_name, lock->old_sha1, mustexist, NULL)) {2013 int save_errno = errno;2014 error("Can't verify ref %s", lock->ref_name);2015 unlock_ref(lock);2016 errno = save_errno;2017 return NULL;2018 }2019 if (hashcmp(lock->old_sha1, old_sha1)) {2020 error("Ref %s is at %s but expected %s", lock->ref_name,2021 sha1_to_hex(lock->old_sha1), sha1_to_hex(old_sha1));2022 unlock_ref(lock);2023 errno = EBUSY;2024 return NULL;2025 }2026 return lock;2027}20282029static int remove_empty_directories(const char *file)2030{2031 /* we want to create a file but there is a directory there;2032 * if that is an empty directory (or a directory that contains2033 * only empty directories), remove them.2034 */2035 struct strbuf path;2036 int result, save_errno;20372038 strbuf_init(&path, 20);2039 strbuf_addstr(&path, file);20402041 result = remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);2042 save_errno = errno;20432044 strbuf_release(&path);2045 errno = save_errno;20462047 return result;2048}20492050/*2051 * *string and *len will only be substituted, and *string returned (for2052 * later free()ing) if the string passed in is a magic short-hand form2053 * to name a branch.2054 */2055static char *substitute_branch_name(const char **string, int *len)2056{2057 struct strbuf buf = STRBUF_INIT;2058 int ret = interpret_branch_name(*string, *len, &buf);20592060 if (ret == *len) {2061 size_t size;2062 *string = strbuf_detach(&buf, &size);2063 *len = size;2064 return (char *)*string;2065 }20662067 return NULL;2068}20692070int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref)2071{2072 char *last_branch = substitute_branch_name(&str, &len);2073 const char **p, *r;2074 int refs_found = 0;20752076 *ref = NULL;2077 for (p = ref_rev_parse_rules; *p; p++) {2078 char fullref[PATH_MAX];2079 unsigned char sha1_from_ref[20];2080 unsigned char *this_result;2081 int flag;20822083 this_result = refs_found ? sha1_from_ref : sha1;2084 mksnpath(fullref, sizeof(fullref), *p, len, str);2085 r = resolve_ref_unsafe(fullref, this_result, 1, &flag);2086 if (r) {2087 if (!refs_found++)2088 *ref = xstrdup(r);2089 if (!warn_ambiguous_refs)2090 break;2091 } else if ((flag & REF_ISSYMREF) && strcmp(fullref, "HEAD")) {2092 warning("ignoring dangling symref %s.", fullref);2093 } else if ((flag & REF_ISBROKEN) && strchr(fullref, '/')) {2094 warning("ignoring broken ref %s.", fullref);2095 }2096 }2097 free(last_branch);2098 return refs_found;2099}21002101int dwim_log(const char *str, int len, unsigned char *sha1, char **log)2102{2103 char *last_branch = substitute_branch_name(&str, &len);2104 const char **p;2105 int logs_found = 0;21062107 *log = NULL;2108 for (p = ref_rev_parse_rules; *p; p++) {2109 unsigned char hash[20];2110 char path[PATH_MAX];2111 const char *ref, *it;21122113 mksnpath(path, sizeof(path), *p, len, str);2114 ref = resolve_ref_unsafe(path, hash, 1, NULL);2115 if (!ref)2116 continue;2117 if (reflog_exists(path))2118 it = path;2119 else if (strcmp(ref, path) && reflog_exists(ref))2120 it = ref;2121 else2122 continue;2123 if (!logs_found++) {2124 *log = xstrdup(it);2125 hashcpy(sha1, hash);2126 }2127 if (!warn_ambiguous_refs)2128 break;2129 }2130 free(last_branch);2131 return logs_found;2132}21332134/*2135 * Locks a "refs/" ref returning the lock on success and NULL on failure.2136 * On failure errno is set to something meaningful.2137 */2138static struct ref_lock *lock_ref_sha1_basic(const char *refname,2139 const unsigned char *old_sha1,2140 int flags, int *type_p)2141{2142 char *ref_file;2143 const char *orig_refname = refname;2144 struct ref_lock *lock;2145 int last_errno = 0;2146 int type, lflags;2147 int mustexist = (old_sha1 && !is_null_sha1(old_sha1));2148 int missing = 0;2149 int attempts_remaining = 3;21502151 lock = xcalloc(1, sizeof(struct ref_lock));2152 lock->lock_fd = -1;21532154 refname = resolve_ref_unsafe(refname, lock->old_sha1, mustexist, &type);2155 if (!refname && errno == EISDIR) {2156 /* we are trying to lock foo but we used to2157 * have foo/bar which now does not exist;2158 * it is normal for the empty directory 'foo'2159 * to remain.2160 */2161 ref_file = git_path("%s", orig_refname);2162 if (remove_empty_directories(ref_file)) {2163 last_errno = errno;2164 error("there are still refs under '%s'", orig_refname);2165 goto error_return;2166 }2167 refname = resolve_ref_unsafe(orig_refname, lock->old_sha1, mustexist, &type);2168 }2169 if (type_p)2170 *type_p = type;2171 if (!refname) {2172 last_errno = errno;2173 error("unable to resolve reference %s: %s",2174 orig_refname, strerror(errno));2175 goto error_return;2176 }2177 missing = is_null_sha1(lock->old_sha1);2178 /* When the ref did not exist and we are creating it,2179 * make sure there is no existing ref that is packed2180 * whose name begins with our refname, nor a ref whose2181 * name is a proper prefix of our refname.2182 */2183 if (missing &&2184 !is_refname_available(refname, NULL, get_packed_refs(&ref_cache))) {2185 last_errno = ENOTDIR;2186 goto error_return;2187 }21882189 lock->lk = xcalloc(1, sizeof(struct lock_file));21902191 lflags = 0;2192 if (flags & REF_NODEREF) {2193 refname = orig_refname;2194 lflags |= LOCK_NODEREF;2195 }2196 lock->ref_name = xstrdup(refname);2197 lock->orig_ref_name = xstrdup(orig_refname);2198 ref_file = git_path("%s", refname);2199 if (missing)2200 lock->force_write = 1;2201 if ((flags & REF_NODEREF) && (type & REF_ISSYMREF))2202 lock->force_write = 1;22032204 retry:2205 switch (safe_create_leading_directories(ref_file)) {2206 case SCLD_OK:2207 break; /* success */2208 case SCLD_VANISHED:2209 if (--attempts_remaining > 0)2210 goto retry;2211 /* fall through */2212 default:2213 last_errno = errno;2214 error("unable to create directory for %s", ref_file);2215 goto error_return;2216 }22172218 lock->lock_fd = hold_lock_file_for_update(lock->lk, ref_file, lflags);2219 if (lock->lock_fd < 0) {2220 if (errno == ENOENT && --attempts_remaining > 0)2221 /*2222 * Maybe somebody just deleted one of the2223 * directories leading to ref_file. Try2224 * again:2225 */2226 goto retry;2227 else2228 unable_to_lock_index_die(ref_file, errno);2229 }2230 return old_sha1 ? verify_lock(lock, old_sha1, mustexist) : lock;22312232 error_return:2233 unlock_ref(lock);2234 errno = last_errno;2235 return NULL;2236}22372238struct ref_lock *lock_any_ref_for_update(const char *refname,2239 const unsigned char *old_sha1,2240 int flags, int *type_p)2241{2242 if (check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))2243 return NULL;2244 return lock_ref_sha1_basic(refname, old_sha1, flags, type_p);2245}22462247/*2248 * Write an entry to the packed-refs file for the specified refname.2249 * If peeled is non-NULL, write it as the entry's peeled value.2250 */2251static void write_packed_entry(FILE *fh, char *refname, unsigned char *sha1,2252 unsigned char *peeled)2253{2254 fprintf_or_die(fh, "%s %s\n", sha1_to_hex(sha1), refname);2255 if (peeled)2256 fprintf_or_die(fh, "^%s\n", sha1_to_hex(peeled));2257}22582259/*2260 * An each_ref_entry_fn that writes the entry to a packed-refs file.2261 */2262static int write_packed_entry_fn(struct ref_entry *entry, void *cb_data)2263{2264 enum peel_status peel_status = peel_entry(entry, 0);22652266 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2267 error("internal error: %s is not a valid packed reference!",2268 entry->name);2269 write_packed_entry(cb_data, entry->name, entry->u.value.sha1,2270 peel_status == PEEL_PEELED ?2271 entry->u.value.peeled : NULL);2272 return 0;2273}22742275/* This should return a meaningful errno on failure */2276int lock_packed_refs(int flags)2277{2278 struct packed_ref_cache *packed_ref_cache;22792280 if (hold_lock_file_for_update(&packlock, git_path("packed-refs"), flags) < 0)2281 return -1;2282 /*2283 * Get the current packed-refs while holding the lock. If the2284 * packed-refs file has been modified since we last read it,2285 * this will automatically invalidate the cache and re-read2286 * the packed-refs file.2287 */2288 packed_ref_cache = get_packed_ref_cache(&ref_cache);2289 packed_ref_cache->lock = &packlock;2290 /* Increment the reference count to prevent it from being freed: */2291 acquire_packed_ref_cache(packed_ref_cache);2292 return 0;2293}22942295/*2296 * Commit the packed refs changes.2297 * On error we must make sure that errno contains a meaningful value.2298 */2299int commit_packed_refs(void)2300{2301 struct packed_ref_cache *packed_ref_cache =2302 get_packed_ref_cache(&ref_cache);2303 int error = 0;2304 int save_errno = 0;2305 FILE *out;23062307 if (!packed_ref_cache->lock)2308 die("internal error: packed-refs not locked");23092310 out = fdopen(packed_ref_cache->lock->fd, "w");2311 if (!out)2312 die_errno("unable to fdopen packed-refs descriptor");23132314 fprintf_or_die(out, "%s", PACKED_REFS_HEADER);2315 do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),2316 0, write_packed_entry_fn, out);2317 if (fclose(out))2318 die_errno("write error");2319 packed_ref_cache->lock->fd = -1;23202321 if (commit_lock_file(packed_ref_cache->lock)) {2322 save_errno = errno;2323 error = -1;2324 }2325 packed_ref_cache->lock = NULL;2326 release_packed_ref_cache(packed_ref_cache);2327 errno = save_errno;2328 return error;2329}23302331void rollback_packed_refs(void)2332{2333 struct packed_ref_cache *packed_ref_cache =2334 get_packed_ref_cache(&ref_cache);23352336 if (!packed_ref_cache->lock)2337 die("internal error: packed-refs not locked");2338 rollback_lock_file(packed_ref_cache->lock);2339 packed_ref_cache->lock = NULL;2340 release_packed_ref_cache(packed_ref_cache);2341 clear_packed_ref_cache(&ref_cache);2342}23432344struct ref_to_prune {2345 struct ref_to_prune *next;2346 unsigned char sha1[20];2347 char name[FLEX_ARRAY];2348};23492350struct pack_refs_cb_data {2351 unsigned int flags;2352 struct ref_dir *packed_refs;2353 struct ref_to_prune *ref_to_prune;2354};23552356/*2357 * An each_ref_entry_fn that is run over loose references only. If2358 * the loose reference can be packed, add an entry in the packed ref2359 * cache. If the reference should be pruned, also add it to2360 * ref_to_prune in the pack_refs_cb_data.2361 */2362static int pack_if_possible_fn(struct ref_entry *entry, void *cb_data)2363{2364 struct pack_refs_cb_data *cb = cb_data;2365 enum peel_status peel_status;2366 struct ref_entry *packed_entry;2367 int is_tag_ref = starts_with(entry->name, "refs/tags/");23682369 /* ALWAYS pack tags */2370 if (!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)2371 return 0;23722373 /* Do not pack symbolic or broken refs: */2374 if ((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))2375 return 0;23762377 /* Add a packed ref cache entry equivalent to the loose entry. */2378 peel_status = peel_entry(entry, 1);2379 if (peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2380 die("internal error peeling reference %s (%s)",2381 entry->name, sha1_to_hex(entry->u.value.sha1));2382 packed_entry = find_ref(cb->packed_refs, entry->name);2383 if (packed_entry) {2384 /* Overwrite existing packed entry with info from loose entry */2385 packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;2386 hashcpy(packed_entry->u.value.sha1, entry->u.value.sha1);2387 } else {2388 packed_entry = create_ref_entry(entry->name, entry->u.value.sha1,2389 REF_ISPACKED | REF_KNOWS_PEELED, 0);2390 add_ref(cb->packed_refs, packed_entry);2391 }2392 hashcpy(packed_entry->u.value.peeled, entry->u.value.peeled);23932394 /* Schedule the loose reference for pruning if requested. */2395 if ((cb->flags & PACK_REFS_PRUNE)) {2396 int namelen = strlen(entry->name) + 1;2397 struct ref_to_prune *n = xcalloc(1, sizeof(*n) + namelen);2398 hashcpy(n->sha1, entry->u.value.sha1);2399 strcpy(n->name, entry->name);2400 n->next = cb->ref_to_prune;2401 cb->ref_to_prune = n;2402 }2403 return 0;2404}24052406/*2407 * Remove empty parents, but spare refs/ and immediate subdirs.2408 * Note: munges *name.2409 */2410static void try_remove_empty_parents(char *name)2411{2412 char *p, *q;2413 int i;2414 p = name;2415 for (i = 0; i < 2; i++) { /* refs/{heads,tags,...}/ */2416 while (*p && *p != '/')2417 p++;2418 /* tolerate duplicate slashes; see check_refname_format() */2419 while (*p == '/')2420 p++;2421 }2422 for (q = p; *q; q++)2423 ;2424 while (1) {2425 while (q > p && *q != '/')2426 q--;2427 while (q > p && *(q-1) == '/')2428 q--;2429 if (q == p)2430 break;2431 *q = '\0';2432 if (rmdir(git_path("%s", name)))2433 break;2434 }2435}24362437/* make sure nobody touched the ref, and unlink */2438static void prune_ref(struct ref_to_prune *r)2439{2440 struct ref_transaction *transaction;2441 struct strbuf err = STRBUF_INIT;24422443 if (check_refname_format(r->name, 0))2444 return;24452446 transaction = ref_transaction_begin(&err);2447 if (!transaction ||2448 ref_transaction_delete(transaction, r->name, r->sha1,2449 REF_ISPRUNING, 1, &err) ||2450 ref_transaction_commit(transaction, NULL, &err)) {2451 ref_transaction_free(transaction);2452 error("%s", err.buf);2453 strbuf_release(&err);2454 return;2455 }2456 ref_transaction_free(transaction);2457 strbuf_release(&err);2458 try_remove_empty_parents(r->name);2459}24602461static void prune_refs(struct ref_to_prune *r)2462{2463 while (r) {2464 prune_ref(r);2465 r = r->next;2466 }2467}24682469int pack_refs(unsigned int flags)2470{2471 struct pack_refs_cb_data cbdata;24722473 memset(&cbdata, 0, sizeof(cbdata));2474 cbdata.flags = flags;24752476 lock_packed_refs(LOCK_DIE_ON_ERROR);2477 cbdata.packed_refs = get_packed_refs(&ref_cache);24782479 do_for_each_entry_in_dir(get_loose_refs(&ref_cache), 0,2480 pack_if_possible_fn, &cbdata);24812482 if (commit_packed_refs())2483 die_errno("unable to overwrite old ref-pack file");24842485 prune_refs(cbdata.ref_to_prune);2486 return 0;2487}24882489/*2490 * If entry is no longer needed in packed-refs, add it to the string2491 * list pointed to by cb_data. Reasons for deleting entries:2492 *2493 * - Entry is broken.2494 * - Entry is overridden by a loose ref.2495 * - Entry does not point at a valid object.2496 *2497 * In the first and third cases, also emit an error message because these2498 * are indications of repository corruption.2499 */2500static int curate_packed_ref_fn(struct ref_entry *entry, void *cb_data)2501{2502 struct string_list *refs_to_delete = cb_data;25032504 if (entry->flag & REF_ISBROKEN) {2505 /* This shouldn't happen to packed refs. */2506 error("%s is broken!", entry->name);2507 string_list_append(refs_to_delete, entry->name);2508 return 0;2509 }2510 if (!has_sha1_file(entry->u.value.sha1)) {2511 unsigned char sha1[20];2512 int flags;25132514 if (read_ref_full(entry->name, sha1, 0, &flags))2515 /* We should at least have found the packed ref. */2516 die("Internal error");2517 if ((flags & REF_ISSYMREF) || !(flags & REF_ISPACKED)) {2518 /*2519 * This packed reference is overridden by a2520 * loose reference, so it is OK that its value2521 * is no longer valid; for example, it might2522 * refer to an object that has been garbage2523 * collected. For this purpose we don't even2524 * care whether the loose reference itself is2525 * invalid, broken, symbolic, etc. Silently2526 * remove the packed reference.2527 */2528 string_list_append(refs_to_delete, entry->name);2529 return 0;2530 }2531 /*2532 * There is no overriding loose reference, so the fact2533 * that this reference doesn't refer to a valid object2534 * indicates some kind of repository corruption.2535 * Report the problem, then omit the reference from2536 * the output.2537 */2538 error("%s does not point to a valid object!", entry->name);2539 string_list_append(refs_to_delete, entry->name);2540 return 0;2541 }25422543 return 0;2544}25452546int repack_without_refs(const char **refnames, int n, struct strbuf *err)2547{2548 struct ref_dir *packed;2549 struct string_list refs_to_delete = STRING_LIST_INIT_DUP;2550 struct string_list_item *ref_to_delete;2551 int i, ret, removed = 0;25522553 /* Look for a packed ref */2554 for (i = 0; i < n; i++)2555 if (get_packed_ref(refnames[i]))2556 break;25572558 /* Avoid locking if we have nothing to do */2559 if (i == n)2560 return 0; /* no refname exists in packed refs */25612562 if (lock_packed_refs(0)) {2563 if (err) {2564 unable_to_lock_message(git_path("packed-refs"), errno,2565 err);2566 return -1;2567 }2568 unable_to_lock_error(git_path("packed-refs"), errno);2569 return error("cannot delete '%s' from packed refs", refnames[i]);2570 }2571 packed = get_packed_refs(&ref_cache);25722573 /* Remove refnames from the cache */2574 for (i = 0; i < n; i++)2575 if (remove_entry(packed, refnames[i]) != -1)2576 removed = 1;2577 if (!removed) {2578 /*2579 * All packed entries disappeared while we were2580 * acquiring the lock.2581 */2582 rollback_packed_refs();2583 return 0;2584 }25852586 /* Remove any other accumulated cruft */2587 do_for_each_entry_in_dir(packed, 0, curate_packed_ref_fn, &refs_to_delete);2588 for_each_string_list_item(ref_to_delete, &refs_to_delete) {2589 if (remove_entry(packed, ref_to_delete->string) == -1)2590 die("internal error");2591 }25922593 /* Write what remains */2594 ret = commit_packed_refs();2595 if (ret && err)2596 strbuf_addf(err, "unable to overwrite old ref-pack file: %s",2597 strerror(errno));2598 return ret;2599}26002601static int delete_ref_loose(struct ref_lock *lock, int flag)2602{2603 if (!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {2604 /* loose */2605 int err, i = strlen(lock->lk->filename) - 5; /* .lock */26062607 lock->lk->filename[i] = 0;2608 err = unlink_or_warn(lock->lk->filename);2609 lock->lk->filename[i] = '.';2610 if (err && errno != ENOENT)2611 return 1;2612 }2613 return 0;2614}26152616int delete_ref(const char *refname, const unsigned char *sha1, int delopt)2617{2618 struct ref_transaction *transaction;2619 struct strbuf err = STRBUF_INIT;26202621 transaction = ref_transaction_begin(&err);2622 if (!transaction ||2623 ref_transaction_delete(transaction, refname, sha1, delopt,2624 sha1 && !is_null_sha1(sha1), &err) ||2625 ref_transaction_commit(transaction, NULL, &err)) {2626 error("%s", err.buf);2627 ref_transaction_free(transaction);2628 strbuf_release(&err);2629 return 1;2630 }2631 ref_transaction_free(transaction);2632 strbuf_release(&err);2633 return 0;2634}26352636/*2637 * People using contrib's git-new-workdir have .git/logs/refs ->2638 * /some/other/path/.git/logs/refs, and that may live on another device.2639 *2640 * IOW, to avoid cross device rename errors, the temporary renamed log must2641 * live into logs/refs.2642 */2643#define TMP_RENAMED_LOG "logs/refs/.tmp-renamed-log"26442645static int rename_tmp_log(const char *newrefname)2646{2647 int attempts_remaining = 4;26482649 retry:2650 switch (safe_create_leading_directories(git_path("logs/%s", newrefname))) {2651 case SCLD_OK:2652 break; /* success */2653 case SCLD_VANISHED:2654 if (--attempts_remaining > 0)2655 goto retry;2656 /* fall through */2657 default:2658 error("unable to create directory for %s", newrefname);2659 return -1;2660 }26612662 if (rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", newrefname))) {2663 if ((errno==EISDIR || errno==ENOTDIR) && --attempts_remaining > 0) {2664 /*2665 * rename(a, b) when b is an existing2666 * directory ought to result in ISDIR, but2667 * Solaris 5.8 gives ENOTDIR. Sheesh.2668 */2669 if (remove_empty_directories(git_path("logs/%s", newrefname))) {2670 error("Directory not empty: logs/%s", newrefname);2671 return -1;2672 }2673 goto retry;2674 } else if (errno == ENOENT && --attempts_remaining > 0) {2675 /*2676 * Maybe another process just deleted one of2677 * the directories in the path to newrefname.2678 * Try again from the beginning.2679 */2680 goto retry;2681 } else {2682 error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s: %s",2683 newrefname, strerror(errno));2684 return -1;2685 }2686 }2687 return 0;2688}26892690int rename_ref(const char *oldrefname, const char *newrefname, const char *logmsg)2691{2692 unsigned char sha1[20], orig_sha1[20];2693 int flag = 0, logmoved = 0;2694 struct ref_lock *lock;2695 struct stat loginfo;2696 int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);2697 const char *symref = NULL;26982699 if (log && S_ISLNK(loginfo.st_mode))2700 return error("reflog for %s is a symlink", oldrefname);27012702 symref = resolve_ref_unsafe(oldrefname, orig_sha1, 1, &flag);2703 if (flag & REF_ISSYMREF)2704 return error("refname %s is a symbolic ref, renaming it is not supported",2705 oldrefname);2706 if (!symref)2707 return error("refname %s not found", oldrefname);27082709 if (!is_refname_available(newrefname, oldrefname, get_packed_refs(&ref_cache)))2710 return 1;27112712 if (!is_refname_available(newrefname, oldrefname, get_loose_refs(&ref_cache)))2713 return 1;27142715 if (log && rename(git_path("logs/%s", oldrefname), git_path(TMP_RENAMED_LOG)))2716 return error("unable to move logfile logs/%s to "TMP_RENAMED_LOG": %s",2717 oldrefname, strerror(errno));27182719 if (delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {2720 error("unable to delete old %s", oldrefname);2721 goto rollback;2722 }27232724 if (!read_ref_full(newrefname, sha1, 1, &flag) &&2725 delete_ref(newrefname, sha1, REF_NODEREF)) {2726 if (errno==EISDIR) {2727 if (remove_empty_directories(git_path("%s", newrefname))) {2728 error("Directory not empty: %s", newrefname);2729 goto rollback;2730 }2731 } else {2732 error("unable to delete existing %s", newrefname);2733 goto rollback;2734 }2735 }27362737 if (log && rename_tmp_log(newrefname))2738 goto rollback;27392740 logmoved = log;27412742 lock = lock_ref_sha1_basic(newrefname, NULL, 0, NULL);2743 if (!lock) {2744 error("unable to lock %s for update", newrefname);2745 goto rollback;2746 }2747 lock->force_write = 1;2748 hashcpy(lock->old_sha1, orig_sha1);2749 if (write_ref_sha1(lock, orig_sha1, logmsg)) {2750 error("unable to write current sha1 into %s", newrefname);2751 goto rollback;2752 }27532754 return 0;27552756 rollback:2757 lock = lock_ref_sha1_basic(oldrefname, NULL, 0, NULL);2758 if (!lock) {2759 error("unable to lock %s for rollback", oldrefname);2760 goto rollbacklog;2761 }27622763 lock->force_write = 1;2764 flag = log_all_ref_updates;2765 log_all_ref_updates = 0;2766 if (write_ref_sha1(lock, orig_sha1, NULL))2767 error("unable to write current sha1 into %s", oldrefname);2768 log_all_ref_updates = flag;27692770 rollbacklog:2771 if (logmoved && rename(git_path("logs/%s", newrefname), git_path("logs/%s", oldrefname)))2772 error("unable to restore logfile %s from %s: %s",2773 oldrefname, newrefname, strerror(errno));2774 if (!logmoved && log &&2775 rename(git_path(TMP_RENAMED_LOG), git_path("logs/%s", oldrefname)))2776 error("unable to restore logfile %s from "TMP_RENAMED_LOG": %s",2777 oldrefname, strerror(errno));27782779 return 1;2780}27812782int close_ref(struct ref_lock *lock)2783{2784 if (close_lock_file(lock->lk))2785 return -1;2786 lock->lock_fd = -1;2787 return 0;2788}27892790int commit_ref(struct ref_lock *lock)2791{2792 if (commit_lock_file(lock->lk))2793 return -1;2794 lock->lock_fd = -1;2795 return 0;2796}27972798void unlock_ref(struct ref_lock *lock)2799{2800 /* Do not free lock->lk -- atexit() still looks at them */2801 if (lock->lk)2802 rollback_lock_file(lock->lk);2803 free(lock->ref_name);2804 free(lock->orig_ref_name);2805 free(lock);2806}28072808/*2809 * copy the reflog message msg to buf, which has been allocated sufficiently2810 * large, while cleaning up the whitespaces. Especially, convert LF to space,2811 * because reflog file is one line per entry.2812 */2813static int copy_msg(char *buf, const char *msg)2814{2815 char *cp = buf;2816 char c;2817 int wasspace = 1;28182819 *cp++ = '\t';2820 while ((c = *msg++)) {2821 if (wasspace && isspace(c))2822 continue;2823 wasspace = isspace(c);2824 if (wasspace)2825 c = ' ';2826 *cp++ = c;2827 }2828 while (buf < cp && isspace(cp[-1]))2829 cp--;2830 *cp++ = '\n';2831 return cp - buf;2832}28332834/* This function must set a meaningful errno on failure */2835int log_ref_setup(const char *refname, char *logfile, int bufsize)2836{2837 int logfd, oflags = O_APPEND | O_WRONLY;28382839 git_snpath(logfile, bufsize, "logs/%s", refname);2840 if (log_all_ref_updates &&2841 (starts_with(refname, "refs/heads/") ||2842 starts_with(refname, "refs/remotes/") ||2843 starts_with(refname, "refs/notes/") ||2844 !strcmp(refname, "HEAD"))) {2845 if (safe_create_leading_directories(logfile) < 0) {2846 int save_errno = errno;2847 error("unable to create directory for %s", logfile);2848 errno = save_errno;2849 return -1;2850 }2851 oflags |= O_CREAT;2852 }28532854 logfd = open(logfile, oflags, 0666);2855 if (logfd < 0) {2856 if (!(oflags & O_CREAT) && errno == ENOENT)2857 return 0;28582859 if ((oflags & O_CREAT) && errno == EISDIR) {2860 if (remove_empty_directories(logfile)) {2861 int save_errno = errno;2862 error("There are still logs under '%s'",2863 logfile);2864 errno = save_errno;2865 return -1;2866 }2867 logfd = open(logfile, oflags, 0666);2868 }28692870 if (logfd < 0) {2871 int save_errno = errno;2872 error("Unable to append to %s: %s", logfile,2873 strerror(errno));2874 errno = save_errno;2875 return -1;2876 }2877 }28782879 adjust_shared_perm(logfile);2880 close(logfd);2881 return 0;2882}28832884static int log_ref_write(const char *refname, const unsigned char *old_sha1,2885 const unsigned char *new_sha1, const char *msg)2886{2887 int logfd, result, written, oflags = O_APPEND | O_WRONLY;2888 unsigned maxlen, len;2889 int msglen;2890 char log_file[PATH_MAX];2891 char *logrec;2892 const char *committer;28932894 if (log_all_ref_updates < 0)2895 log_all_ref_updates = !is_bare_repository();28962897 result = log_ref_setup(refname, log_file, sizeof(log_file));2898 if (result)2899 return result;29002901 logfd = open(log_file, oflags);2902 if (logfd < 0)2903 return 0;2904 msglen = msg ? strlen(msg) : 0;2905 committer = git_committer_info(0);2906 maxlen = strlen(committer) + msglen + 100;2907 logrec = xmalloc(maxlen);2908 len = sprintf(logrec, "%s %s %s\n",2909 sha1_to_hex(old_sha1),2910 sha1_to_hex(new_sha1),2911 committer);2912 if (msglen)2913 len += copy_msg(logrec + len - 1, msg) - 1;2914 written = len <= maxlen ? write_in_full(logfd, logrec, len) : -1;2915 free(logrec);2916 if (written != len) {2917 int save_errno = errno;2918 close(logfd);2919 error("Unable to append to %s", log_file);2920 errno = save_errno;2921 return -1;2922 }2923 if (close(logfd)) {2924 int save_errno = errno;2925 error("Unable to append to %s", log_file);2926 errno = save_errno;2927 return -1;2928 }2929 return 0;2930}29312932int is_branch(const char *refname)2933{2934 return !strcmp(refname, "HEAD") || starts_with(refname, "refs/heads/");2935}29362937/* This function must return a meaningful errno */2938int write_ref_sha1(struct ref_lock *lock,2939 const unsigned char *sha1, const char *logmsg)2940{2941 static char term = '\n';2942 struct object *o;29432944 if (!lock) {2945 errno = EINVAL;2946 return -1;2947 }2948 if (!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {2949 unlock_ref(lock);2950 return 0;2951 }2952 o = parse_object(sha1);2953 if (!o) {2954 error("Trying to write ref %s with nonexistent object %s",2955 lock->ref_name, sha1_to_hex(sha1));2956 unlock_ref(lock);2957 errno = EINVAL;2958 return -1;2959 }2960 if (o->type != OBJ_COMMIT && is_branch(lock->ref_name)) {2961 error("Trying to write non-commit object %s to branch %s",2962 sha1_to_hex(sha1), lock->ref_name);2963 unlock_ref(lock);2964 errno = EINVAL;2965 return -1;2966 }2967 if (write_in_full(lock->lock_fd, sha1_to_hex(sha1), 40) != 40 ||2968 write_in_full(lock->lock_fd, &term, 1) != 1 ||2969 close_ref(lock) < 0) {2970 int save_errno = errno;2971 error("Couldn't write %s", lock->lk->filename);2972 unlock_ref(lock);2973 errno = save_errno;2974 return -1;2975 }2976 clear_loose_ref_cache(&ref_cache);2977 if (log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) < 0 ||2978 (strcmp(lock->ref_name, lock->orig_ref_name) &&2979 log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) < 0)) {2980 unlock_ref(lock);2981 return -1;2982 }2983 if (strcmp(lock->orig_ref_name, "HEAD") != 0) {2984 /*2985 * Special hack: If a branch is updated directly and HEAD2986 * points to it (may happen on the remote side of a push2987 * for example) then logically the HEAD reflog should be2988 * updated too.2989 * A generic solution implies reverse symref information,2990 * but finding all symrefs pointing to the given branch2991 * would be rather costly for this rare event (the direct2992 * update of a branch) to be worth it. So let's cheat and2993 * check with HEAD only which should cover 99% of all usage2994 * scenarios (even 100% of the default ones).2995 */2996 unsigned char head_sha1[20];2997 int head_flag;2998 const char *head_ref;2999 head_ref = resolve_ref_unsafe("HEAD", head_sha1, 1, &head_flag);3000 if (head_ref && (head_flag & REF_ISSYMREF) &&3001 !strcmp(head_ref, lock->ref_name))3002 log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);3003 }3004 if (commit_ref(lock)) {3005 error("Couldn't set %s", lock->ref_name);3006 unlock_ref(lock);3007 return -1;3008 }3009 unlock_ref(lock);3010 return 0;3011}30123013int create_symref(const char *ref_target, const char *refs_heads_master,3014 const char *logmsg)3015{3016 const char *lockpath;3017 char ref[1000];3018 int fd, len, written;3019 char *git_HEAD = git_pathdup("%s", ref_target);3020 unsigned char old_sha1[20], new_sha1[20];30213022 if (logmsg && read_ref(ref_target, old_sha1))3023 hashclr(old_sha1);30243025 if (safe_create_leading_directories(git_HEAD) < 0)3026 return error("unable to create directory for %s", git_HEAD);30273028#ifndef NO_SYMLINK_HEAD3029 if (prefer_symlink_refs) {3030 unlink(git_HEAD);3031 if (!symlink(refs_heads_master, git_HEAD))3032 goto done;3033 fprintf(stderr, "no symlink - falling back to symbolic ref\n");3034 }3035#endif30363037 len = snprintf(ref, sizeof(ref), "ref: %s\n", refs_heads_master);3038 if (sizeof(ref) <= len) {3039 error("refname too long: %s", refs_heads_master);3040 goto error_free_return;3041 }3042 lockpath = mkpath("%s.lock", git_HEAD);3043 fd = open(lockpath, O_CREAT | O_EXCL | O_WRONLY, 0666);3044 if (fd < 0) {3045 error("Unable to open %s for writing", lockpath);3046 goto error_free_return;3047 }3048 written = write_in_full(fd, ref, len);3049 if (close(fd) != 0 || written != len) {3050 error("Unable to write to %s", lockpath);3051 goto error_unlink_return;3052 }3053 if (rename(lockpath, git_HEAD) < 0) {3054 error("Unable to create %s", git_HEAD);3055 goto error_unlink_return;3056 }3057 if (adjust_shared_perm(git_HEAD)) {3058 error("Unable to fix permissions on %s", lockpath);3059 error_unlink_return:3060 unlink_or_warn(lockpath);3061 error_free_return:3062 free(git_HEAD);3063 return -1;3064 }30653066#ifndef NO_SYMLINK_HEAD3067 done:3068#endif3069 if (logmsg && !read_ref(refs_heads_master, new_sha1))3070 log_ref_write(ref_target, old_sha1, new_sha1, logmsg);30713072 free(git_HEAD);3073 return 0;3074}30753076struct read_ref_at_cb {3077 const char *refname;3078 unsigned long at_time;3079 int cnt;3080 int reccnt;3081 unsigned char *sha1;3082 int found_it;30833084 unsigned char osha1[20];3085 unsigned char nsha1[20];3086 int tz;3087 unsigned long date;3088 char **msg;3089 unsigned long *cutoff_time;3090 int *cutoff_tz;3091 int *cutoff_cnt;3092};30933094static int read_ref_at_ent(unsigned char *osha1, unsigned char *nsha1,3095 const char *email, unsigned long timestamp, int tz,3096 const char *message, void *cb_data)3097{3098 struct read_ref_at_cb *cb = cb_data;30993100 cb->reccnt++;3101 cb->tz = tz;3102 cb->date = timestamp;31033104 if (timestamp <= cb->at_time || cb->cnt == 0) {3105 if (cb->msg)3106 *cb->msg = xstrdup(message);3107 if (cb->cutoff_time)3108 *cb->cutoff_time = timestamp;3109 if (cb->cutoff_tz)3110 *cb->cutoff_tz = tz;3111 if (cb->cutoff_cnt)3112 *cb->cutoff_cnt = cb->reccnt - 1;3113 /*3114 * we have not yet updated cb->[n|o]sha1 so they still3115 * hold the values for the previous record.3116 */3117 if (!is_null_sha1(cb->osha1)) {3118 hashcpy(cb->sha1, nsha1);3119 if (hashcmp(cb->osha1, nsha1))3120 warning("Log for ref %s has gap after %s.",3121 cb->refname, show_date(cb->date, cb->tz, DATE_RFC2822));3122 }3123 else if (cb->date == cb->at_time)3124 hashcpy(cb->sha1, nsha1);3125 else if (hashcmp(nsha1, cb->sha1))3126 warning("Log for ref %s unexpectedly ended on %s.",3127 cb->refname, show_date(cb->date, cb->tz,3128 DATE_RFC2822));3129 hashcpy(cb->osha1, osha1);3130 hashcpy(cb->nsha1, nsha1);3131 cb->found_it = 1;3132 return 1;3133 }3134 hashcpy(cb->osha1, osha1);3135 hashcpy(cb->nsha1, nsha1);3136 if (cb->cnt > 0)3137 cb->cnt--;3138 return 0;3139}31403141static int read_ref_at_ent_oldest(unsigned char *osha1, unsigned char *nsha1,3142 const char *email, unsigned long timestamp,3143 int tz, const char *message, void *cb_data)3144{3145 struct read_ref_at_cb *cb = cb_data;31463147 if (cb->msg)3148 *cb->msg = xstrdup(message);3149 if (cb->cutoff_time)3150 *cb->cutoff_time = timestamp;3151 if (cb->cutoff_tz)3152 *cb->cutoff_tz = tz;3153 if (cb->cutoff_cnt)3154 *cb->cutoff_cnt = cb->reccnt;3155 hashcpy(cb->sha1, osha1);3156 if (is_null_sha1(cb->sha1))3157 hashcpy(cb->sha1, nsha1);3158 /* We just want the first entry */3159 return 1;3160}31613162int read_ref_at(const char *refname, unsigned int flags, unsigned long at_time, int cnt,3163 unsigned char *sha1, char **msg,3164 unsigned long *cutoff_time, int *cutoff_tz, int *cutoff_cnt)3165{3166 struct read_ref_at_cb cb;31673168 memset(&cb, 0, sizeof(cb));3169 cb.refname = refname;3170 cb.at_time = at_time;3171 cb.cnt = cnt;3172 cb.msg = msg;3173 cb.cutoff_time = cutoff_time;3174 cb.cutoff_tz = cutoff_tz;3175 cb.cutoff_cnt = cutoff_cnt;3176 cb.sha1 = sha1;31773178 for_each_reflog_ent_reverse(refname, read_ref_at_ent, &cb);31793180 if (!cb.reccnt) {3181 if (flags & GET_SHA1_QUIETLY)3182 exit(128);3183 else3184 die("Log for %s is empty.", refname);3185 }3186 if (cb.found_it)3187 return 0;31883189 for_each_reflog_ent(refname, read_ref_at_ent_oldest, &cb);31903191 return 1;3192}31933194int reflog_exists(const char *refname)3195{3196 struct stat st;31973198 return !lstat(git_path("logs/%s", refname), &st) &&3199 S_ISREG(st.st_mode);3200}32013202int delete_reflog(const char *refname)3203{3204 return remove_path(git_path("logs/%s", refname));3205}32063207static int show_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn, void *cb_data)3208{3209 unsigned char osha1[20], nsha1[20];3210 char *email_end, *message;3211 unsigned long timestamp;3212 int tz;32133214 /* old SP new SP name <email> SP time TAB msg LF */3215 if (sb->len < 83 || sb->buf[sb->len - 1] != '\n' ||3216 get_sha1_hex(sb->buf, osha1) || sb->buf[40] != ' ' ||3217 get_sha1_hex(sb->buf + 41, nsha1) || sb->buf[81] != ' ' ||3218 !(email_end = strchr(sb->buf + 82, '>')) ||3219 email_end[1] != ' ' ||3220 !(timestamp = strtoul(email_end + 2, &message, 10)) ||3221 !message || message[0] != ' ' ||3222 (message[1] != '+' && message[1] != '-') ||3223 !isdigit(message[2]) || !isdigit(message[3]) ||3224 !isdigit(message[4]) || !isdigit(message[5]))3225 return 0; /* corrupt? */3226 email_end[1] = '\0';3227 tz = strtol(message + 1, NULL, 10);3228 if (message[6] != '\t')3229 message += 6;3230 else3231 message += 7;3232 return fn(osha1, nsha1, sb->buf + 82, timestamp, tz, message, cb_data);3233}32343235static char *find_beginning_of_line(char *bob, char *scan)3236{3237 while (bob < scan && *(--scan) != '\n')3238 ; /* keep scanning backwards */3239 /*3240 * Return either beginning of the buffer, or LF at the end of3241 * the previous line.3242 */3243 return scan;3244}32453246int for_each_reflog_ent_reverse(const char *refname, each_reflog_ent_fn fn, void *cb_data)3247{3248 struct strbuf sb = STRBUF_INIT;3249 FILE *logfp;3250 long pos;3251 int ret = 0, at_tail = 1;32523253 logfp = fopen(git_path("logs/%s", refname), "r");3254 if (!logfp)3255 return -1;32563257 /* Jump to the end */3258 if (fseek(logfp, 0, SEEK_END) < 0)3259 return error("cannot seek back reflog for %s: %s",3260 refname, strerror(errno));3261 pos = ftell(logfp);3262 while (!ret && 0 < pos) {3263 int cnt;3264 size_t nread;3265 char buf[BUFSIZ];3266 char *endp, *scanp;32673268 /* Fill next block from the end */3269 cnt = (sizeof(buf) < pos) ? sizeof(buf) : pos;3270 if (fseek(logfp, pos - cnt, SEEK_SET))3271 return error("cannot seek back reflog for %s: %s",3272 refname, strerror(errno));3273 nread = fread(buf, cnt, 1, logfp);3274 if (nread != 1)3275 return error("cannot read %d bytes from reflog for %s: %s",3276 cnt, refname, strerror(errno));3277 pos -= cnt;32783279 scanp = endp = buf + cnt;3280 if (at_tail && scanp[-1] == '\n')3281 /* Looking at the final LF at the end of the file */3282 scanp--;3283 at_tail = 0;32843285 while (buf < scanp) {3286 /*3287 * terminating LF of the previous line, or the beginning3288 * of the buffer.3289 */3290 char *bp;32913292 bp = find_beginning_of_line(buf, scanp);32933294 if (*bp != '\n') {3295 strbuf_splice(&sb, 0, 0, buf, endp - buf);3296 if (pos)3297 break; /* need to fill another block */3298 scanp = buf - 1; /* leave loop */3299 } else {3300 /*3301 * (bp + 1) thru endp is the beginning of the3302 * current line we have in sb3303 */3304 strbuf_splice(&sb, 0, 0, bp + 1, endp - (bp + 1));3305 scanp = bp;3306 endp = bp + 1;3307 }3308 ret = show_one_reflog_ent(&sb, fn, cb_data);3309 strbuf_reset(&sb);3310 if (ret)3311 break;3312 }33133314 }3315 if (!ret && sb.len)3316 ret = show_one_reflog_ent(&sb, fn, cb_data);33173318 fclose(logfp);3319 strbuf_release(&sb);3320 return ret;3321}33223323int for_each_reflog_ent(const char *refname, each_reflog_ent_fn fn, void *cb_data)3324{3325 FILE *logfp;3326 struct strbuf sb = STRBUF_INIT;3327 int ret = 0;33283329 logfp = fopen(git_path("logs/%s", refname), "r");3330 if (!logfp)3331 return -1;33323333 while (!ret && !strbuf_getwholeline(&sb, logfp, '\n'))3334 ret = show_one_reflog_ent(&sb, fn, cb_data);3335 fclose(logfp);3336 strbuf_release(&sb);3337 return ret;3338}3339/*3340 * Call fn for each reflog in the namespace indicated by name. name3341 * must be empty or end with '/'. Name will be used as a scratch3342 * space, but its contents will be restored before return.3343 */3344static int do_for_each_reflog(struct strbuf *name, each_ref_fn fn, void *cb_data)3345{3346 DIR *d = opendir(git_path("logs/%s", name->buf));3347 int retval = 0;3348 struct dirent *de;3349 int oldlen = name->len;33503351 if (!d)3352 return name->len ? errno : 0;33533354 while ((de = readdir(d)) != NULL) {3355 struct stat st;33563357 if (de->d_name[0] == '.')3358 continue;3359 if (ends_with(de->d_name, ".lock"))3360 continue;3361 strbuf_addstr(name, de->d_name);3362 if (stat(git_path("logs/%s", name->buf), &st) < 0) {3363 ; /* silently ignore */3364 } else {3365 if (S_ISDIR(st.st_mode)) {3366 strbuf_addch(name, '/');3367 retval = do_for_each_reflog(name, fn, cb_data);3368 } else {3369 unsigned char sha1[20];3370 if (read_ref_full(name->buf, sha1, 0, NULL))3371 retval = error("bad ref for %s", name->buf);3372 else3373 retval = fn(name->buf, sha1, 0, cb_data);3374 }3375 if (retval)3376 break;3377 }3378 strbuf_setlen(name, oldlen);3379 }3380 closedir(d);3381 return retval;3382}33833384int for_each_reflog(each_ref_fn fn, void *cb_data)3385{3386 int retval;3387 struct strbuf name;3388 strbuf_init(&name, PATH_MAX);3389 retval = do_for_each_reflog(&name, fn, cb_data);3390 strbuf_release(&name);3391 return retval;3392}33933394/**3395 * Information needed for a single ref update. Set new_sha1 to the3396 * new value or to zero to delete the ref. To check the old value3397 * while locking the ref, set have_old to 1 and set old_sha1 to the3398 * value or to zero to ensure the ref does not exist before update.3399 */3400struct ref_update {3401 unsigned char new_sha1[20];3402 unsigned char old_sha1[20];3403 int flags; /* REF_NODEREF? */3404 int have_old; /* 1 if old_sha1 is valid, 0 otherwise */3405 struct ref_lock *lock;3406 int type;3407 const char refname[FLEX_ARRAY];3408};34093410/*3411 * Transaction states.3412 * OPEN: The transaction is in a valid state and can accept new updates.3413 * An OPEN transaction can be committed.3414 * CLOSED: A closed transaction is no longer active and no other operations3415 * than free can be used on it in this state.3416 * A transaction can either become closed by successfully committing3417 * an active transaction or if there is a failure while building3418 * the transaction thus rendering it failed/inactive.3419 */3420enum ref_transaction_state {3421 REF_TRANSACTION_OPEN = 0,3422 REF_TRANSACTION_CLOSED = 13423};34243425/*3426 * Data structure for holding a reference transaction, which can3427 * consist of checks and updates to multiple references, carried out3428 * as atomically as possible. This structure is opaque to callers.3429 */3430struct ref_transaction {3431 struct ref_update **updates;3432 size_t alloc;3433 size_t nr;3434 enum ref_transaction_state state;3435};34363437struct ref_transaction *ref_transaction_begin(struct strbuf *err)3438{3439 return xcalloc(1, sizeof(struct ref_transaction));3440}34413442void ref_transaction_free(struct ref_transaction *transaction)3443{3444 int i;34453446 if (!transaction)3447 return;34483449 for (i = 0; i < transaction->nr; i++)3450 free(transaction->updates[i]);34513452 free(transaction->updates);3453 free(transaction);3454}34553456static struct ref_update *add_update(struct ref_transaction *transaction,3457 const char *refname)3458{3459 size_t len = strlen(refname);3460 struct ref_update *update = xcalloc(1, sizeof(*update) + len + 1);34613462 strcpy((char *)update->refname, refname);3463 ALLOC_GROW(transaction->updates, transaction->nr + 1, transaction->alloc);3464 transaction->updates[transaction->nr++] = update;3465 return update;3466}34673468int ref_transaction_update(struct ref_transaction *transaction,3469 const char *refname,3470 const unsigned char *new_sha1,3471 const unsigned char *old_sha1,3472 int flags, int have_old,3473 struct strbuf *err)3474{3475 struct ref_update *update;34763477 if (transaction->state != REF_TRANSACTION_OPEN)3478 die("BUG: update called for transaction that is not open");34793480 if (have_old && !old_sha1)3481 die("BUG: have_old is true but old_sha1 is NULL");34823483 update = add_update(transaction, refname);3484 hashcpy(update->new_sha1, new_sha1);3485 update->flags = flags;3486 update->have_old = have_old;3487 if (have_old)3488 hashcpy(update->old_sha1, old_sha1);3489 return 0;3490}34913492int ref_transaction_create(struct ref_transaction *transaction,3493 const char *refname,3494 const unsigned char *new_sha1,3495 int flags,3496 struct strbuf *err)3497{3498 struct ref_update *update;34993500 if (transaction->state != REF_TRANSACTION_OPEN)3501 die("BUG: create called for transaction that is not open");35023503 if (!new_sha1 || is_null_sha1(new_sha1))3504 die("BUG: create ref with null new_sha1");35053506 update = add_update(transaction, refname);35073508 hashcpy(update->new_sha1, new_sha1);3509 hashclr(update->old_sha1);3510 update->flags = flags;3511 update->have_old = 1;3512 return 0;3513}35143515int ref_transaction_delete(struct ref_transaction *transaction,3516 const char *refname,3517 const unsigned char *old_sha1,3518 int flags, int have_old,3519 struct strbuf *err)3520{3521 struct ref_update *update;35223523 if (transaction->state != REF_TRANSACTION_OPEN)3524 die("BUG: delete called for transaction that is not open");35253526 if (have_old && !old_sha1)3527 die("BUG: have_old is true but old_sha1 is NULL");35283529 update = add_update(transaction, refname);3530 update->flags = flags;3531 update->have_old = have_old;3532 if (have_old) {3533 assert(!is_null_sha1(old_sha1));3534 hashcpy(update->old_sha1, old_sha1);3535 }3536 return 0;3537}35383539int update_ref(const char *action, const char *refname,3540 const unsigned char *sha1, const unsigned char *oldval,3541 int flags, enum action_on_err onerr)3542{3543 struct ref_transaction *t;3544 struct strbuf err = STRBUF_INIT;35453546 t = ref_transaction_begin(&err);3547 if (!t ||3548 ref_transaction_update(t, refname, sha1, oldval, flags,3549 !!oldval, &err) ||3550 ref_transaction_commit(t, action, &err)) {3551 const char *str = "update_ref failed for ref '%s': %s";35523553 ref_transaction_free(t);3554 switch (onerr) {3555 case UPDATE_REFS_MSG_ON_ERR:3556 error(str, refname, err.buf);3557 break;3558 case UPDATE_REFS_DIE_ON_ERR:3559 die(str, refname, err.buf);3560 break;3561 case UPDATE_REFS_QUIET_ON_ERR:3562 break;3563 }3564 strbuf_release(&err);3565 return 1;3566 }3567 strbuf_release(&err);3568 ref_transaction_free(t);3569 return 0;3570}35713572static int ref_update_compare(const void *r1, const void *r2)3573{3574 const struct ref_update * const *u1 = r1;3575 const struct ref_update * const *u2 = r2;3576 return strcmp((*u1)->refname, (*u2)->refname);3577}35783579static int ref_update_reject_duplicates(struct ref_update **updates, int n,3580 struct strbuf *err)3581{3582 int i;3583 for (i = 1; i < n; i++)3584 if (!strcmp(updates[i - 1]->refname, updates[i]->refname)) {3585 const char *str =3586 "Multiple updates for ref '%s' not allowed.";3587 if (err)3588 strbuf_addf(err, str, updates[i]->refname);35893590 return 1;3591 }3592 return 0;3593}35943595int ref_transaction_commit(struct ref_transaction *transaction,3596 const char *msg, struct strbuf *err)3597{3598 int ret = 0, delnum = 0, i;3599 const char **delnames;3600 int n = transaction->nr;3601 struct ref_update **updates = transaction->updates;36023603 if (transaction->state != REF_TRANSACTION_OPEN)3604 die("BUG: commit called for transaction that is not open");36053606 if (!n) {3607 transaction->state = REF_TRANSACTION_CLOSED;3608 return 0;3609 }36103611 /* Allocate work space */3612 delnames = xmalloc(sizeof(*delnames) * n);36133614 /* Copy, sort, and reject duplicate refs */3615 qsort(updates, n, sizeof(*updates), ref_update_compare);3616 ret = ref_update_reject_duplicates(updates, n, err);3617 if (ret)3618 goto cleanup;36193620 /* Acquire all locks while verifying old values */3621 for (i = 0; i < n; i++) {3622 struct ref_update *update = updates[i];36233624 update->lock = lock_any_ref_for_update(update->refname,3625 (update->have_old ?3626 update->old_sha1 :3627 NULL),3628 update->flags,3629 &update->type);3630 if (!update->lock) {3631 if (err)3632 strbuf_addf(err, "Cannot lock the ref '%s'.",3633 update->refname);3634 ret = 1;3635 goto cleanup;3636 }3637 }36383639 /* Perform updates first so live commits remain referenced */3640 for (i = 0; i < n; i++) {3641 struct ref_update *update = updates[i];36423643 if (!is_null_sha1(update->new_sha1)) {3644 ret = write_ref_sha1(update->lock, update->new_sha1,3645 msg);3646 update->lock = NULL; /* freed by write_ref_sha1 */3647 if (ret) {3648 if (err)3649 strbuf_addf(err, "Cannot update the ref '%s'.",3650 update->refname);3651 goto cleanup;3652 }3653 }3654 }36553656 /* Perform deletes now that updates are safely completed */3657 for (i = 0; i < n; i++) {3658 struct ref_update *update = updates[i];36593660 if (update->lock) {3661 ret |= delete_ref_loose(update->lock, update->type);3662 if (!(update->flags & REF_ISPRUNING))3663 delnames[delnum++] = update->lock->ref_name;3664 }3665 }36663667 ret |= repack_without_refs(delnames, delnum, err);3668 for (i = 0; i < delnum; i++)3669 unlink_or_warn(git_path("logs/%s", delnames[i]));3670 clear_loose_ref_cache(&ref_cache);36713672cleanup:3673 transaction->state = REF_TRANSACTION_CLOSED;36743675 for (i = 0; i < n; i++)3676 if (updates[i]->lock)3677 unlock_ref(updates[i]->lock);3678 free(delnames);3679 return ret;3680}36813682char *shorten_unambiguous_ref(const char *refname, int strict)3683{3684 int i;3685 static char **scanf_fmts;3686 static int nr_rules;3687 char *short_name;36883689 if (!nr_rules) {3690 /*3691 * Pre-generate scanf formats from ref_rev_parse_rules[].3692 * Generate a format suitable for scanf from a3693 * ref_rev_parse_rules rule by interpolating "%s" at the3694 * location of the "%.*s".3695 */3696 size_t total_len = 0;3697 size_t offset = 0;36983699 /* the rule list is NULL terminated, count them first */3700 for (nr_rules = 0; ref_rev_parse_rules[nr_rules]; nr_rules++)3701 /* -2 for strlen("%.*s") - strlen("%s"); +1 for NUL */3702 total_len += strlen(ref_rev_parse_rules[nr_rules]) - 2 + 1;37033704 scanf_fmts = xmalloc(nr_rules * sizeof(char *) + total_len);37053706 offset = 0;3707 for (i = 0; i < nr_rules; i++) {3708 assert(offset < total_len);3709 scanf_fmts[i] = (char *)&scanf_fmts[nr_rules] + offset;3710 offset += snprintf(scanf_fmts[i], total_len - offset,3711 ref_rev_parse_rules[i], 2, "%s") + 1;3712 }3713 }37143715 /* bail out if there are no rules */3716 if (!nr_rules)3717 return xstrdup(refname);37183719 /* buffer for scanf result, at most refname must fit */3720 short_name = xstrdup(refname);37213722 /* skip first rule, it will always match */3723 for (i = nr_rules - 1; i > 0 ; --i) {3724 int j;3725 int rules_to_fail = i;3726 int short_name_len;37273728 if (1 != sscanf(refname, scanf_fmts[i], short_name))3729 continue;37303731 short_name_len = strlen(short_name);37323733 /*3734 * in strict mode, all (except the matched one) rules3735 * must fail to resolve to a valid non-ambiguous ref3736 */3737 if (strict)3738 rules_to_fail = nr_rules;37393740 /*3741 * check if the short name resolves to a valid ref,3742 * but use only rules prior to the matched one3743 */3744 for (j = 0; j < rules_to_fail; j++) {3745 const char *rule = ref_rev_parse_rules[j];3746 char refname[PATH_MAX];37473748 /* skip matched rule */3749 if (i == j)3750 continue;37513752 /*3753 * the short name is ambiguous, if it resolves3754 * (with this previous rule) to a valid ref3755 * read_ref() returns 0 on success3756 */3757 mksnpath(refname, sizeof(refname),3758 rule, short_name_len, short_name);3759 if (ref_exists(refname))3760 break;3761 }37623763 /*3764 * short name is non-ambiguous if all previous rules3765 * haven't resolved to a valid ref3766 */3767 if (j == rules_to_fail)3768 return short_name;3769 }37703771 free(short_name);3772 return xstrdup(refname);3773}37743775static struct string_list *hide_refs;37763777int parse_hide_refs_config(const char *var, const char *value, const char *section)3778{3779 if (!strcmp("transfer.hiderefs", var) ||3780 /* NEEDSWORK: use parse_config_key() once both are merged */3781 (starts_with(var, section) && var[strlen(section)] == '.' &&3782 !strcmp(var + strlen(section), ".hiderefs"))) {3783 char *ref;3784 int len;37853786 if (!value)3787 return config_error_nonbool(var);3788 ref = xstrdup(value);3789 len = strlen(ref);3790 while (len && ref[len - 1] == '/')3791 ref[--len] = '\0';3792 if (!hide_refs) {3793 hide_refs = xcalloc(1, sizeof(*hide_refs));3794 hide_refs->strdup_strings = 1;3795 }3796 string_list_append(hide_refs, ref);3797 }3798 return 0;3799}38003801int ref_is_hidden(const char *refname)3802{3803 struct string_list_item *item;38043805 if (!hide_refs)3806 return 0;3807 for_each_string_list_item(item, hide_refs) {3808 int len;3809 if (!starts_with(refname, item->string))3810 continue;3811 len = strlen(item->string);3812 if (!refname[len] || refname[len] == '/')3813 return 1;3814 }3815 return 0;3816}