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 * Make sure "ref" is something reasonable to have under ".git/refs/"; 10 * We do not like it if: 11 * 12 * - any path component of it begins with ".", or 13 * - it has double dots "..", or 14 * - it has ASCII control character, "~", "^", ":" or SP, anywhere, or 15 * - it ends with a "/". 16 * - it ends with ".lock" 17 * - it contains a "\" (backslash) 18 */ 19 20/* Return true iff ch is not allowed in reference names. */ 21staticinlineintbad_ref_char(int ch) 22{ 23if(((unsigned) ch) <=' '|| ch ==0x7f|| 24 ch =='~'|| ch =='^'|| ch ==':'|| ch =='\\') 25return1; 26/* 2.13 Pattern Matching Notation */ 27if(ch =='*'|| ch =='?'|| ch =='[')/* Unsupported */ 28return1; 29return0; 30} 31 32/* 33 * Try to read one refname component from the front of refname. Return 34 * the length of the component found, or -1 if the component is not 35 * legal. 36 */ 37static intcheck_refname_component(const char*refname,int flags) 38{ 39const char*cp; 40char last ='\0'; 41 42for(cp = refname; ; cp++) { 43char ch = *cp; 44if(ch =='\0'|| ch =='/') 45break; 46if(bad_ref_char(ch)) 47return-1;/* Illegal character in refname. */ 48if(last =='.'&& ch =='.') 49return-1;/* Refname contains "..". */ 50if(last =='@'&& ch =='{') 51return-1;/* Refname contains "@{". */ 52 last = ch; 53} 54if(cp == refname) 55return0;/* Component has zero length. */ 56if(refname[0] =='.') { 57if(!(flags & REFNAME_DOT_COMPONENT)) 58return-1;/* Component starts with '.'. */ 59/* 60 * Even if leading dots are allowed, don't allow "." 61 * as a component (".." is prevented by a rule above). 62 */ 63if(refname[1] =='\0') 64return-1;/* Component equals ".". */ 65} 66if(cp - refname >=5&& !memcmp(cp -5,".lock",5)) 67return-1;/* Refname ends with ".lock". */ 68return cp - refname; 69} 70 71intcheck_refname_format(const char*refname,int flags) 72{ 73int component_len, component_count =0; 74 75while(1) { 76/* We are at the start of a path component. */ 77 component_len =check_refname_component(refname, flags); 78if(component_len <=0) { 79if((flags & REFNAME_REFSPEC_PATTERN) && 80 refname[0] =='*'&& 81(refname[1] =='\0'|| refname[1] =='/')) { 82/* Accept one wildcard as a full refname component. */ 83 flags &= ~REFNAME_REFSPEC_PATTERN; 84 component_len =1; 85}else{ 86return-1; 87} 88} 89 component_count++; 90if(refname[component_len] =='\0') 91break; 92/* Skip to next component. */ 93 refname += component_len +1; 94} 95 96if(refname[component_len -1] =='.') 97return-1;/* Refname ends with '.'. */ 98if(!(flags & REFNAME_ALLOW_ONELEVEL) && component_count <2) 99return-1;/* Refname has only one component. */ 100return0; 101} 102 103struct ref_entry; 104 105/* 106 * Information used (along with the information in ref_entry) to 107 * describe a single cached reference. This data structure only 108 * occurs embedded in a union in struct ref_entry, and only when 109 * (ref_entry->flag & REF_DIR) is zero. 110 */ 111struct ref_value { 112/* 113 * The name of the object to which this reference resolves 114 * (which may be a tag object). If REF_ISBROKEN, this is 115 * null. If REF_ISSYMREF, then this is the name of the object 116 * referred to by the last reference in the symlink chain. 117 */ 118unsigned char sha1[20]; 119 120/* 121 * If REF_KNOWS_PEELED, then this field holds the peeled value 122 * of this reference, or null if the reference is known not to 123 * be peelable. See the documentation for peel_ref() for an 124 * exact definition of "peelable". 125 */ 126unsigned char peeled[20]; 127}; 128 129struct ref_cache; 130 131/* 132 * Information used (along with the information in ref_entry) to 133 * describe a level in the hierarchy of references. This data 134 * structure only occurs embedded in a union in struct ref_entry, and 135 * only when (ref_entry.flag & REF_DIR) is set. In that case, 136 * (ref_entry.flag & REF_INCOMPLETE) determines whether the references 137 * in the directory have already been read: 138 * 139 * (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose 140 * or packed references, already read. 141 * 142 * (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose 143 * references that hasn't been read yet (nor has any of its 144 * subdirectories). 145 * 146 * Entries within a directory are stored within a growable array of 147 * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i < 148 * sorted are sorted by their component name in strcmp() order and the 149 * remaining entries are unsorted. 150 * 151 * Loose references are read lazily, one directory at a time. When a 152 * directory of loose references is read, then all of the references 153 * in that directory are stored, and REF_INCOMPLETE stubs are created 154 * for any subdirectories, but the subdirectories themselves are not 155 * read. The reading is triggered by get_ref_dir(). 156 */ 157struct ref_dir { 158int nr, alloc; 159 160/* 161 * Entries with index 0 <= i < sorted are sorted by name. New 162 * entries are appended to the list unsorted, and are sorted 163 * only when required; thus we avoid the need to sort the list 164 * after the addition of every reference. 165 */ 166int sorted; 167 168/* A pointer to the ref_cache that contains this ref_dir. */ 169struct ref_cache *ref_cache; 170 171struct ref_entry **entries; 172}; 173 174/* 175 * Bit values for ref_entry::flag. REF_ISSYMREF=0x01, 176 * REF_ISPACKED=0x02, and REF_ISBROKEN=0x04 are public values; see 177 * refs.h. 178 */ 179 180/* 181 * The field ref_entry->u.value.peeled of this value entry contains 182 * the correct peeled value for the reference, which might be 183 * null_sha1 if the reference is not a tag or if it is broken. 184 */ 185#define REF_KNOWS_PEELED 0x08 186 187/* ref_entry represents a directory of references */ 188#define REF_DIR 0x10 189 190/* 191 * Entry has not yet been read from disk (used only for REF_DIR 192 * entries representing loose references) 193 */ 194#define REF_INCOMPLETE 0x20 195 196/* 197 * A ref_entry represents either a reference or a "subdirectory" of 198 * references. 199 * 200 * Each directory in the reference namespace is represented by a 201 * ref_entry with (flags & REF_DIR) set and containing a subdir member 202 * that holds the entries in that directory that have been read so 203 * far. If (flags & REF_INCOMPLETE) is set, then the directory and 204 * its subdirectories haven't been read yet. REF_INCOMPLETE is only 205 * used for loose reference directories. 206 * 207 * References are represented by a ref_entry with (flags & REF_DIR) 208 * unset and a value member that describes the reference's value. The 209 * flag member is at the ref_entry level, but it is also needed to 210 * interpret the contents of the value field (in other words, a 211 * ref_value object is not very much use without the enclosing 212 * ref_entry). 213 * 214 * Reference names cannot end with slash and directories' names are 215 * always stored with a trailing slash (except for the top-level 216 * directory, which is always denoted by ""). This has two nice 217 * consequences: (1) when the entries in each subdir are sorted 218 * lexicographically by name (as they usually are), the references in 219 * a whole tree can be generated in lexicographic order by traversing 220 * the tree in left-to-right, depth-first order; (2) the names of 221 * references and subdirectories cannot conflict, and therefore the 222 * presence of an empty subdirectory does not block the creation of a 223 * similarly-named reference. (The fact that reference names with the 224 * same leading components can conflict *with each other* is a 225 * separate issue that is regulated by is_refname_available().) 226 * 227 * Please note that the name field contains the fully-qualified 228 * reference (or subdirectory) name. Space could be saved by only 229 * storing the relative names. But that would require the full names 230 * to be generated on the fly when iterating in do_for_each_ref(), and 231 * would break callback functions, who have always been able to assume 232 * that the name strings that they are passed will not be freed during 233 * the iteration. 234 */ 235struct ref_entry { 236unsigned char flag;/* ISSYMREF? ISPACKED? */ 237union{ 238struct ref_value value;/* if not (flags&REF_DIR) */ 239struct ref_dir subdir;/* if (flags&REF_DIR) */ 240} u; 241/* 242 * The full name of the reference (e.g., "refs/heads/master") 243 * or the full name of the directory with a trailing slash 244 * (e.g., "refs/heads/"): 245 */ 246char name[FLEX_ARRAY]; 247}; 248 249static voidread_loose_refs(const char*dirname,struct ref_dir *dir); 250 251static struct ref_dir *get_ref_dir(struct ref_entry *entry) 252{ 253struct ref_dir *dir; 254assert(entry->flag & REF_DIR); 255 dir = &entry->u.subdir; 256if(entry->flag & REF_INCOMPLETE) { 257read_loose_refs(entry->name, dir); 258 entry->flag &= ~REF_INCOMPLETE; 259} 260return dir; 261} 262 263static struct ref_entry *create_ref_entry(const char*refname, 264const unsigned char*sha1,int flag, 265int check_name) 266{ 267int len; 268struct ref_entry *ref; 269 270if(check_name && 271check_refname_format(refname, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT)) 272die("Reference has invalid format: '%s'", refname); 273 len =strlen(refname) +1; 274 ref =xmalloc(sizeof(struct ref_entry) + len); 275hashcpy(ref->u.value.sha1, sha1); 276hashclr(ref->u.value.peeled); 277memcpy(ref->name, refname, len); 278 ref->flag = flag; 279return ref; 280} 281 282static voidclear_ref_dir(struct ref_dir *dir); 283 284static voidfree_ref_entry(struct ref_entry *entry) 285{ 286if(entry->flag & REF_DIR) { 287/* 288 * Do not use get_ref_dir() here, as that might 289 * trigger the reading of loose refs. 290 */ 291clear_ref_dir(&entry->u.subdir); 292} 293free(entry); 294} 295 296/* 297 * Add a ref_entry to the end of dir (unsorted). Entry is always 298 * stored directly in dir; no recursion into subdirectories is 299 * done. 300 */ 301static voidadd_entry_to_dir(struct ref_dir *dir,struct ref_entry *entry) 302{ 303ALLOC_GROW(dir->entries, dir->nr +1, dir->alloc); 304 dir->entries[dir->nr++] = entry; 305/* optimize for the case that entries are added in order */ 306if(dir->nr ==1|| 307(dir->nr == dir->sorted +1&& 308strcmp(dir->entries[dir->nr -2]->name, 309 dir->entries[dir->nr -1]->name) <0)) 310 dir->sorted = dir->nr; 311} 312 313/* 314 * Clear and free all entries in dir, recursively. 315 */ 316static voidclear_ref_dir(struct ref_dir *dir) 317{ 318int i; 319for(i =0; i < dir->nr; i++) 320free_ref_entry(dir->entries[i]); 321free(dir->entries); 322 dir->sorted = dir->nr = dir->alloc =0; 323 dir->entries = NULL; 324} 325 326/* 327 * Create a struct ref_entry object for the specified dirname. 328 * dirname is the name of the directory with a trailing slash (e.g., 329 * "refs/heads/") or "" for the top-level directory. 330 */ 331static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache, 332const char*dirname,size_t len, 333int incomplete) 334{ 335struct ref_entry *direntry; 336 direntry =xcalloc(1,sizeof(struct ref_entry) + len +1); 337memcpy(direntry->name, dirname, len); 338 direntry->name[len] ='\0'; 339 direntry->u.subdir.ref_cache = ref_cache; 340 direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE :0); 341return direntry; 342} 343 344static intref_entry_cmp(const void*a,const void*b) 345{ 346struct ref_entry *one = *(struct ref_entry **)a; 347struct ref_entry *two = *(struct ref_entry **)b; 348returnstrcmp(one->name, two->name); 349} 350 351static voidsort_ref_dir(struct ref_dir *dir); 352 353struct string_slice { 354size_t len; 355const char*str; 356}; 357 358static intref_entry_cmp_sslice(const void*key_,const void*ent_) 359{ 360const struct string_slice *key = key_; 361const struct ref_entry *ent = *(const struct ref_entry *const*)ent_; 362int cmp =strncmp(key->str, ent->name, key->len); 363if(cmp) 364return cmp; 365return'\0'- (unsigned char)ent->name[key->len]; 366} 367 368/* 369 * Return the index of the entry with the given refname from the 370 * ref_dir (non-recursively), sorting dir if necessary. Return -1 if 371 * no such entry is found. dir must already be complete. 372 */ 373static intsearch_ref_dir(struct ref_dir *dir,const char*refname,size_t len) 374{ 375struct ref_entry **r; 376struct string_slice key; 377 378if(refname == NULL || !dir->nr) 379return-1; 380 381sort_ref_dir(dir); 382 key.len = len; 383 key.str = refname; 384 r =bsearch(&key, dir->entries, dir->nr,sizeof(*dir->entries), 385 ref_entry_cmp_sslice); 386 387if(r == NULL) 388return-1; 389 390return r - dir->entries; 391} 392 393/* 394 * Search for a directory entry directly within dir (without 395 * recursing). Sort dir if necessary. subdirname must be a directory 396 * name (i.e., end in '/'). If mkdir is set, then create the 397 * directory if it is missing; otherwise, return NULL if the desired 398 * directory cannot be found. dir must already be complete. 399 */ 400static struct ref_dir *search_for_subdir(struct ref_dir *dir, 401const char*subdirname,size_t len, 402int mkdir) 403{ 404int entry_index =search_ref_dir(dir, subdirname, len); 405struct ref_entry *entry; 406if(entry_index == -1) { 407if(!mkdir) 408return NULL; 409/* 410 * Since dir is complete, the absence of a subdir 411 * means that the subdir really doesn't exist; 412 * therefore, create an empty record for it but mark 413 * the record complete. 414 */ 415 entry =create_dir_entry(dir->ref_cache, subdirname, len,0); 416add_entry_to_dir(dir, entry); 417}else{ 418 entry = dir->entries[entry_index]; 419} 420returnget_ref_dir(entry); 421} 422 423/* 424 * If refname is a reference name, find the ref_dir within the dir 425 * tree that should hold refname. If refname is a directory name 426 * (i.e., ends in '/'), then return that ref_dir itself. dir must 427 * represent the top-level directory and must already be complete. 428 * Sort ref_dirs and recurse into subdirectories as necessary. If 429 * mkdir is set, then create any missing directories; otherwise, 430 * return NULL if the desired directory cannot be found. 431 */ 432static struct ref_dir *find_containing_dir(struct ref_dir *dir, 433const char*refname,int mkdir) 434{ 435const char*slash; 436for(slash =strchr(refname,'/'); slash; slash =strchr(slash +1,'/')) { 437size_t dirnamelen = slash - refname +1; 438struct ref_dir *subdir; 439 subdir =search_for_subdir(dir, refname, dirnamelen, mkdir); 440if(!subdir) { 441 dir = NULL; 442break; 443} 444 dir = subdir; 445} 446 447return dir; 448} 449 450/* 451 * Find the value entry with the given name in dir, sorting ref_dirs 452 * and recursing into subdirectories as necessary. If the name is not 453 * found or it corresponds to a directory entry, return NULL. 454 */ 455static struct ref_entry *find_ref(struct ref_dir *dir,const char*refname) 456{ 457int entry_index; 458struct ref_entry *entry; 459 dir =find_containing_dir(dir, refname,0); 460if(!dir) 461return NULL; 462 entry_index =search_ref_dir(dir, refname,strlen(refname)); 463if(entry_index == -1) 464return NULL; 465 entry = dir->entries[entry_index]; 466return(entry->flag & REF_DIR) ? NULL : entry; 467} 468 469/* 470 * Remove the entry with the given name from dir, recursing into 471 * subdirectories as necessary. If refname is the name of a directory 472 * (i.e., ends with '/'), then remove the directory and its contents. 473 * If the removal was successful, return the number of entries 474 * remaining in the directory entry that contained the deleted entry. 475 * If the name was not found, return -1. Please note that this 476 * function only deletes the entry from the cache; it does not delete 477 * it from the filesystem or ensure that other cache entries (which 478 * might be symbolic references to the removed entry) are updated. 479 * Nor does it remove any containing dir entries that might be made 480 * empty by the removal. dir must represent the top-level directory 481 * and must already be complete. 482 */ 483static intremove_entry(struct ref_dir *dir,const char*refname) 484{ 485int refname_len =strlen(refname); 486int entry_index; 487struct ref_entry *entry; 488int is_dir = refname[refname_len -1] =='/'; 489if(is_dir) { 490/* 491 * refname represents a reference directory. Remove 492 * the trailing slash; otherwise we will get the 493 * directory *representing* refname rather than the 494 * one *containing* it. 495 */ 496char*dirname =xmemdupz(refname, refname_len -1); 497 dir =find_containing_dir(dir, dirname,0); 498free(dirname); 499}else{ 500 dir =find_containing_dir(dir, refname,0); 501} 502if(!dir) 503return-1; 504 entry_index =search_ref_dir(dir, refname, refname_len); 505if(entry_index == -1) 506return-1; 507 entry = dir->entries[entry_index]; 508 509memmove(&dir->entries[entry_index], 510&dir->entries[entry_index +1], 511(dir->nr - entry_index -1) *sizeof(*dir->entries) 512); 513 dir->nr--; 514if(dir->sorted > entry_index) 515 dir->sorted--; 516free_ref_entry(entry); 517return dir->nr; 518} 519 520/* 521 * Add a ref_entry to the ref_dir (unsorted), recursing into 522 * subdirectories as necessary. dir must represent the top-level 523 * directory. Return 0 on success. 524 */ 525static intadd_ref(struct ref_dir *dir,struct ref_entry *ref) 526{ 527 dir =find_containing_dir(dir, ref->name,1); 528if(!dir) 529return-1; 530add_entry_to_dir(dir, ref); 531return0; 532} 533 534/* 535 * Emit a warning and return true iff ref1 and ref2 have the same name 536 * and the same sha1. Die if they have the same name but different 537 * sha1s. 538 */ 539static intis_dup_ref(const struct ref_entry *ref1,const struct ref_entry *ref2) 540{ 541if(strcmp(ref1->name, ref2->name)) 542return0; 543 544/* Duplicate name; make sure that they don't conflict: */ 545 546if((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR)) 547/* This is impossible by construction */ 548die("Reference directory conflict:%s", ref1->name); 549 550if(hashcmp(ref1->u.value.sha1, ref2->u.value.sha1)) 551die("Duplicated ref, and SHA1s don't match:%s", ref1->name); 552 553warning("Duplicated ref:%s", ref1->name); 554return1; 555} 556 557/* 558 * Sort the entries in dir non-recursively (if they are not already 559 * sorted) and remove any duplicate entries. 560 */ 561static voidsort_ref_dir(struct ref_dir *dir) 562{ 563int i, j; 564struct ref_entry *last = NULL; 565 566/* 567 * This check also prevents passing a zero-length array to qsort(), 568 * which is a problem on some platforms. 569 */ 570if(dir->sorted == dir->nr) 571return; 572 573qsort(dir->entries, dir->nr,sizeof(*dir->entries), ref_entry_cmp); 574 575/* Remove any duplicates: */ 576for(i =0, j =0; j < dir->nr; j++) { 577struct ref_entry *entry = dir->entries[j]; 578if(last &&is_dup_ref(last, entry)) 579free_ref_entry(entry); 580else 581 last = dir->entries[i++] = entry; 582} 583 dir->sorted = dir->nr = i; 584} 585 586/* Include broken references in a do_for_each_ref*() iteration: */ 587#define DO_FOR_EACH_INCLUDE_BROKEN 0x01 588 589/* 590 * Return true iff the reference described by entry can be resolved to 591 * an object in the database. Emit a warning if the referred-to 592 * object does not exist. 593 */ 594static intref_resolves_to_object(struct ref_entry *entry) 595{ 596if(entry->flag & REF_ISBROKEN) 597return0; 598if(!has_sha1_file(entry->u.value.sha1)) { 599error("%sdoes not point to a valid object!", entry->name); 600return0; 601} 602return1; 603} 604 605/* 606 * current_ref is a performance hack: when iterating over references 607 * using the for_each_ref*() functions, current_ref is set to the 608 * current reference's entry before calling the callback function. If 609 * the callback function calls peel_ref(), then peel_ref() first 610 * checks whether the reference to be peeled is the current reference 611 * (it usually is) and if so, returns that reference's peeled version 612 * if it is available. This avoids a refname lookup in a common case. 613 */ 614static struct ref_entry *current_ref; 615 616typedefinteach_ref_entry_fn(struct ref_entry *entry,void*cb_data); 617 618struct ref_entry_cb { 619const char*base; 620int trim; 621int flags; 622 each_ref_fn *fn; 623void*cb_data; 624}; 625 626/* 627 * Handle one reference in a do_for_each_ref*()-style iteration, 628 * calling an each_ref_fn for each entry. 629 */ 630static intdo_one_ref(struct ref_entry *entry,void*cb_data) 631{ 632struct ref_entry_cb *data = cb_data; 633struct ref_entry *old_current_ref; 634int retval; 635 636if(prefixcmp(entry->name, data->base)) 637return0; 638 639if(!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 640!ref_resolves_to_object(entry)) 641return0; 642 643/* Store the old value, in case this is a recursive call: */ 644 old_current_ref = current_ref; 645 current_ref = entry; 646 retval = data->fn(entry->name + data->trim, entry->u.value.sha1, 647 entry->flag, data->cb_data); 648 current_ref = old_current_ref; 649return retval; 650} 651 652/* 653 * Call fn for each reference in dir that has index in the range 654 * offset <= index < dir->nr. Recurse into subdirectories that are in 655 * that index range, sorting them before iterating. This function 656 * does not sort dir itself; it should be sorted beforehand. fn is 657 * called for all references, including broken ones. 658 */ 659static intdo_for_each_entry_in_dir(struct ref_dir *dir,int offset, 660 each_ref_entry_fn fn,void*cb_data) 661{ 662int i; 663assert(dir->sorted == dir->nr); 664for(i = offset; i < dir->nr; i++) { 665struct ref_entry *entry = dir->entries[i]; 666int retval; 667if(entry->flag & REF_DIR) { 668struct ref_dir *subdir =get_ref_dir(entry); 669sort_ref_dir(subdir); 670 retval =do_for_each_entry_in_dir(subdir,0, fn, cb_data); 671}else{ 672 retval =fn(entry, cb_data); 673} 674if(retval) 675return retval; 676} 677return0; 678} 679 680/* 681 * Call fn for each reference in the union of dir1 and dir2, in order 682 * by refname. Recurse into subdirectories. If a value entry appears 683 * in both dir1 and dir2, then only process the version that is in 684 * dir2. The input dirs must already be sorted, but subdirs will be 685 * sorted as needed. fn is called for all references, including 686 * broken ones. 687 */ 688static intdo_for_each_entry_in_dirs(struct ref_dir *dir1, 689struct ref_dir *dir2, 690 each_ref_entry_fn fn,void*cb_data) 691{ 692int retval; 693int i1 =0, i2 =0; 694 695assert(dir1->sorted == dir1->nr); 696assert(dir2->sorted == dir2->nr); 697while(1) { 698struct ref_entry *e1, *e2; 699int cmp; 700if(i1 == dir1->nr) { 701returndo_for_each_entry_in_dir(dir2, i2, fn, cb_data); 702} 703if(i2 == dir2->nr) { 704returndo_for_each_entry_in_dir(dir1, i1, fn, cb_data); 705} 706 e1 = dir1->entries[i1]; 707 e2 = dir2->entries[i2]; 708 cmp =strcmp(e1->name, e2->name); 709if(cmp ==0) { 710if((e1->flag & REF_DIR) && (e2->flag & REF_DIR)) { 711/* Both are directories; descend them in parallel. */ 712struct ref_dir *subdir1 =get_ref_dir(e1); 713struct ref_dir *subdir2 =get_ref_dir(e2); 714sort_ref_dir(subdir1); 715sort_ref_dir(subdir2); 716 retval =do_for_each_entry_in_dirs( 717 subdir1, subdir2, fn, cb_data); 718 i1++; 719 i2++; 720}else if(!(e1->flag & REF_DIR) && !(e2->flag & REF_DIR)) { 721/* Both are references; ignore the one from dir1. */ 722 retval =fn(e2, cb_data); 723 i1++; 724 i2++; 725}else{ 726die("conflict between reference and directory:%s", 727 e1->name); 728} 729}else{ 730struct ref_entry *e; 731if(cmp <0) { 732 e = e1; 733 i1++; 734}else{ 735 e = e2; 736 i2++; 737} 738if(e->flag & REF_DIR) { 739struct ref_dir *subdir =get_ref_dir(e); 740sort_ref_dir(subdir); 741 retval =do_for_each_entry_in_dir( 742 subdir,0, fn, cb_data); 743}else{ 744 retval =fn(e, cb_data); 745} 746} 747if(retval) 748return retval; 749} 750} 751 752/* 753 * Load all of the refs from the dir into our in-memory cache. The hard work 754 * of loading loose refs is done by get_ref_dir(), so we just need to recurse 755 * through all of the sub-directories. We do not even need to care about 756 * sorting, as traversal order does not matter to us. 757 */ 758static voidprime_ref_dir(struct ref_dir *dir) 759{ 760int i; 761for(i =0; i < dir->nr; i++) { 762struct ref_entry *entry = dir->entries[i]; 763if(entry->flag & REF_DIR) 764prime_ref_dir(get_ref_dir(entry)); 765} 766} 767/* 768 * Return true iff refname1 and refname2 conflict with each other. 769 * Two reference names conflict if one of them exactly matches the 770 * leading components of the other; e.g., "foo/bar" conflicts with 771 * both "foo" and with "foo/bar/baz" but not with "foo/bar" or 772 * "foo/barbados". 773 */ 774static intnames_conflict(const char*refname1,const char*refname2) 775{ 776for(; *refname1 && *refname1 == *refname2; refname1++, refname2++) 777; 778return(*refname1 =='\0'&& *refname2 =='/') 779|| (*refname1 =='/'&& *refname2 =='\0'); 780} 781 782struct name_conflict_cb { 783const char*refname; 784const char*oldrefname; 785const char*conflicting_refname; 786}; 787 788static intname_conflict_fn(struct ref_entry *entry,void*cb_data) 789{ 790struct name_conflict_cb *data = (struct name_conflict_cb *)cb_data; 791if(data->oldrefname && !strcmp(data->oldrefname, entry->name)) 792return0; 793if(names_conflict(data->refname, entry->name)) { 794 data->conflicting_refname = entry->name; 795return1; 796} 797return0; 798} 799 800/* 801 * Return true iff a reference named refname could be created without 802 * conflicting with the name of an existing reference in dir. If 803 * oldrefname is non-NULL, ignore potential conflicts with oldrefname 804 * (e.g., because oldrefname is scheduled for deletion in the same 805 * operation). 806 */ 807static intis_refname_available(const char*refname,const char*oldrefname, 808struct ref_dir *dir) 809{ 810struct name_conflict_cb data; 811 data.refname = refname; 812 data.oldrefname = oldrefname; 813 data.conflicting_refname = NULL; 814 815sort_ref_dir(dir); 816if(do_for_each_entry_in_dir(dir,0, name_conflict_fn, &data)) { 817error("'%s' exists; cannot create '%s'", 818 data.conflicting_refname, refname); 819return0; 820} 821return1; 822} 823 824struct packed_ref_cache { 825struct ref_entry *root; 826 827/* 828 * Count of references to the data structure in this instance, 829 * including the pointer from ref_cache::packed if any. The 830 * data will not be freed as long as the reference count is 831 * nonzero. 832 */ 833unsigned int referrers; 834 835/* 836 * Iff the packed-refs file associated with this instance is 837 * currently locked for writing, this points at the associated 838 * lock (which is owned by somebody else). The referrer count 839 * is also incremented when the file is locked and decremented 840 * when it is unlocked. 841 */ 842struct lock_file *lock; 843 844/* The metadata from when this packed-refs cache was read */ 845struct stat_validity validity; 846}; 847 848/* 849 * Future: need to be in "struct repository" 850 * when doing a full libification. 851 */ 852static struct ref_cache { 853struct ref_cache *next; 854struct ref_entry *loose; 855struct packed_ref_cache *packed; 856/* 857 * The submodule name, or "" for the main repo. We allocate 858 * length 1 rather than FLEX_ARRAY so that the main ref_cache 859 * is initialized correctly. 860 */ 861char name[1]; 862} ref_cache, *submodule_ref_caches; 863 864/* Lock used for the main packed-refs file: */ 865static struct lock_file packlock; 866 867/* 868 * Increment the reference count of *packed_refs. 869 */ 870static voidacquire_packed_ref_cache(struct packed_ref_cache *packed_refs) 871{ 872 packed_refs->referrers++; 873} 874 875/* 876 * Decrease the reference count of *packed_refs. If it goes to zero, 877 * free *packed_refs and return true; otherwise return false. 878 */ 879static intrelease_packed_ref_cache(struct packed_ref_cache *packed_refs) 880{ 881if(!--packed_refs->referrers) { 882free_ref_entry(packed_refs->root); 883stat_validity_clear(&packed_refs->validity); 884free(packed_refs); 885return1; 886}else{ 887return0; 888} 889} 890 891static voidclear_packed_ref_cache(struct ref_cache *refs) 892{ 893if(refs->packed) { 894struct packed_ref_cache *packed_refs = refs->packed; 895 896if(packed_refs->lock) 897die("internal error: packed-ref cache cleared while locked"); 898 refs->packed = NULL; 899release_packed_ref_cache(packed_refs); 900} 901} 902 903static voidclear_loose_ref_cache(struct ref_cache *refs) 904{ 905if(refs->loose) { 906free_ref_entry(refs->loose); 907 refs->loose = NULL; 908} 909} 910 911static struct ref_cache *create_ref_cache(const char*submodule) 912{ 913int len; 914struct ref_cache *refs; 915if(!submodule) 916 submodule =""; 917 len =strlen(submodule) +1; 918 refs =xcalloc(1,sizeof(struct ref_cache) + len); 919memcpy(refs->name, submodule, len); 920return refs; 921} 922 923/* 924 * Return a pointer to a ref_cache for the specified submodule. For 925 * the main repository, use submodule==NULL. The returned structure 926 * will be allocated and initialized but not necessarily populated; it 927 * should not be freed. 928 */ 929static struct ref_cache *get_ref_cache(const char*submodule) 930{ 931struct ref_cache *refs; 932 933if(!submodule || !*submodule) 934return&ref_cache; 935 936for(refs = submodule_ref_caches; refs; refs = refs->next) 937if(!strcmp(submodule, refs->name)) 938return refs; 939 940 refs =create_ref_cache(submodule); 941 refs->next = submodule_ref_caches; 942 submodule_ref_caches = refs; 943return refs; 944} 945 946voidinvalidate_ref_cache(const char*submodule) 947{ 948struct ref_cache *refs =get_ref_cache(submodule); 949clear_packed_ref_cache(refs); 950clear_loose_ref_cache(refs); 951} 952 953/* The length of a peeled reference line in packed-refs, including EOL: */ 954#define PEELED_LINE_LENGTH 42 955 956/* 957 * The packed-refs header line that we write out. Perhaps other 958 * traits will be added later. The trailing space is required. 959 */ 960static const char PACKED_REFS_HEADER[] = 961"# pack-refs with: peeled fully-peeled\n"; 962 963/* 964 * Parse one line from a packed-refs file. Write the SHA1 to sha1. 965 * Return a pointer to the refname within the line (null-terminated), 966 * or NULL if there was a problem. 967 */ 968static const char*parse_ref_line(char*line,unsigned char*sha1) 969{ 970/* 971 * 42: the answer to everything. 972 * 973 * In this case, it happens to be the answer to 974 * 40 (length of sha1 hex representation) 975 * +1 (space in between hex and name) 976 * +1 (newline at the end of the line) 977 */ 978int len =strlen(line) -42; 979 980if(len <=0) 981return NULL; 982if(get_sha1_hex(line, sha1) <0) 983return NULL; 984if(!isspace(line[40])) 985return NULL; 986 line +=41; 987if(isspace(*line)) 988return NULL; 989if(line[len] !='\n') 990return NULL; 991 line[len] =0; 992 993return line; 994} 995 996/* 997 * Read f, which is a packed-refs file, into dir. 998 * 999 * A comment line of the form "# pack-refs with: " may contain zero or1000 * more traits. We interpret the traits as follows:1001 *1002 * No traits:1003 *1004 * Probably no references are peeled. But if the file contains a1005 * peeled value for a reference, we will use it.1006 *1007 * peeled:1008 *1009 * References under "refs/tags/", if they *can* be peeled, *are*1010 * peeled in this file. References outside of "refs/tags/" are1011 * probably not peeled even if they could have been, but if we find1012 * a peeled value for such a reference we will use it.1013 *1014 * fully-peeled:1015 *1016 * All references in the file that can be peeled are peeled.1017 * Inversely (and this is more important), any references in the1018 * file for which no peeled value is recorded is not peelable. This1019 * trait should typically be written alongside "peeled" for1020 * compatibility with older clients, but we do not require it1021 * (i.e., "peeled" is a no-op if "fully-peeled" is set).1022 */1023static voidread_packed_refs(FILE*f,struct ref_dir *dir)1024{1025struct ref_entry *last = NULL;1026char refline[PATH_MAX];1027enum{ PEELED_NONE, PEELED_TAGS, PEELED_FULLY } peeled = PEELED_NONE;10281029while(fgets(refline,sizeof(refline), f)) {1030unsigned char sha1[20];1031const char*refname;1032static const char header[] ="# pack-refs with:";10331034if(!strncmp(refline, header,sizeof(header)-1)) {1035const char*traits = refline +sizeof(header) -1;1036if(strstr(traits," fully-peeled "))1037 peeled = PEELED_FULLY;1038else if(strstr(traits," peeled "))1039 peeled = PEELED_TAGS;1040/* perhaps other traits later as well */1041continue;1042}10431044 refname =parse_ref_line(refline, sha1);1045if(refname) {1046 last =create_ref_entry(refname, sha1, REF_ISPACKED,1);1047if(peeled == PEELED_FULLY ||1048(peeled == PEELED_TAGS && !prefixcmp(refname,"refs/tags/")))1049 last->flag |= REF_KNOWS_PEELED;1050add_ref(dir, last);1051continue;1052}1053if(last &&1054 refline[0] =='^'&&1055strlen(refline) == PEELED_LINE_LENGTH &&1056 refline[PEELED_LINE_LENGTH -1] =='\n'&&1057!get_sha1_hex(refline +1, sha1)) {1058hashcpy(last->u.value.peeled, sha1);1059/*1060 * Regardless of what the file header said,1061 * we definitely know the value of *this*1062 * reference:1063 */1064 last->flag |= REF_KNOWS_PEELED;1065}1066}1067}10681069/*1070 * Get the packed_ref_cache for the specified ref_cache, creating it1071 * if necessary.1072 */1073static struct packed_ref_cache *get_packed_ref_cache(struct ref_cache *refs)1074{1075const char*packed_refs_file;10761077if(*refs->name)1078 packed_refs_file =git_path_submodule(refs->name,"packed-refs");1079else1080 packed_refs_file =git_path("packed-refs");10811082if(refs->packed &&1083!stat_validity_check(&refs->packed->validity, packed_refs_file))1084clear_packed_ref_cache(refs);10851086if(!refs->packed) {1087FILE*f;10881089 refs->packed =xcalloc(1,sizeof(*refs->packed));1090acquire_packed_ref_cache(refs->packed);1091 refs->packed->root =create_dir_entry(refs,"",0,0);1092 f =fopen(packed_refs_file,"r");1093if(f) {1094stat_validity_update(&refs->packed->validity,fileno(f));1095read_packed_refs(f,get_ref_dir(refs->packed->root));1096fclose(f);1097}1098}1099return refs->packed;1100}11011102static struct ref_dir *get_packed_ref_dir(struct packed_ref_cache *packed_ref_cache)1103{1104returnget_ref_dir(packed_ref_cache->root);1105}11061107static struct ref_dir *get_packed_refs(struct ref_cache *refs)1108{1109returnget_packed_ref_dir(get_packed_ref_cache(refs));1110}11111112voidadd_packed_ref(const char*refname,const unsigned char*sha1)1113{1114struct packed_ref_cache *packed_ref_cache =1115get_packed_ref_cache(&ref_cache);11161117if(!packed_ref_cache->lock)1118die("internal error: packed refs not locked");1119add_ref(get_packed_ref_dir(packed_ref_cache),1120create_ref_entry(refname, sha1, REF_ISPACKED,1));1121}11221123/*1124 * Read the loose references from the namespace dirname into dir1125 * (without recursing). dirname must end with '/'. dir must be the1126 * directory entry corresponding to dirname.1127 */1128static voidread_loose_refs(const char*dirname,struct ref_dir *dir)1129{1130struct ref_cache *refs = dir->ref_cache;1131DIR*d;1132const char*path;1133struct dirent *de;1134int dirnamelen =strlen(dirname);1135struct strbuf refname;11361137if(*refs->name)1138 path =git_path_submodule(refs->name,"%s", dirname);1139else1140 path =git_path("%s", dirname);11411142 d =opendir(path);1143if(!d)1144return;11451146strbuf_init(&refname, dirnamelen +257);1147strbuf_add(&refname, dirname, dirnamelen);11481149while((de =readdir(d)) != NULL) {1150unsigned char sha1[20];1151struct stat st;1152int flag;1153const char*refdir;11541155if(de->d_name[0] =='.')1156continue;1157if(has_extension(de->d_name,".lock"))1158continue;1159strbuf_addstr(&refname, de->d_name);1160 refdir = *refs->name1161?git_path_submodule(refs->name,"%s", refname.buf)1162:git_path("%s", refname.buf);1163if(stat(refdir, &st) <0) {1164;/* silently ignore */1165}else if(S_ISDIR(st.st_mode)) {1166strbuf_addch(&refname,'/');1167add_entry_to_dir(dir,1168create_dir_entry(refs, refname.buf,1169 refname.len,1));1170}else{1171if(*refs->name) {1172hashclr(sha1);1173 flag =0;1174if(resolve_gitlink_ref(refs->name, refname.buf, sha1) <0) {1175hashclr(sha1);1176 flag |= REF_ISBROKEN;1177}1178}else if(read_ref_full(refname.buf, sha1,1, &flag)) {1179hashclr(sha1);1180 flag |= REF_ISBROKEN;1181}1182add_entry_to_dir(dir,1183create_ref_entry(refname.buf, sha1, flag,1));1184}1185strbuf_setlen(&refname, dirnamelen);1186}1187strbuf_release(&refname);1188closedir(d);1189}11901191static struct ref_dir *get_loose_refs(struct ref_cache *refs)1192{1193if(!refs->loose) {1194/*1195 * Mark the top-level directory complete because we1196 * are about to read the only subdirectory that can1197 * hold references:1198 */1199 refs->loose =create_dir_entry(refs,"",0,0);1200/*1201 * Create an incomplete entry for "refs/":1202 */1203add_entry_to_dir(get_ref_dir(refs->loose),1204create_dir_entry(refs,"refs/",5,1));1205}1206returnget_ref_dir(refs->loose);1207}12081209/* We allow "recursive" symbolic refs. Only within reason, though */1210#define MAXDEPTH 51211#define MAXREFLEN (1024)12121213/*1214 * Called by resolve_gitlink_ref_recursive() after it failed to read1215 * from the loose refs in ref_cache refs. Find <refname> in the1216 * packed-refs file for the submodule.1217 */1218static intresolve_gitlink_packed_ref(struct ref_cache *refs,1219const char*refname,unsigned char*sha1)1220{1221struct ref_entry *ref;1222struct ref_dir *dir =get_packed_refs(refs);12231224 ref =find_ref(dir, refname);1225if(ref == NULL)1226return-1;12271228memcpy(sha1, ref->u.value.sha1,20);1229return0;1230}12311232static intresolve_gitlink_ref_recursive(struct ref_cache *refs,1233const char*refname,unsigned char*sha1,1234int recursion)1235{1236int fd, len;1237char buffer[128], *p;1238char*path;12391240if(recursion > MAXDEPTH ||strlen(refname) > MAXREFLEN)1241return-1;1242 path = *refs->name1243?git_path_submodule(refs->name,"%s", refname)1244:git_path("%s", refname);1245 fd =open(path, O_RDONLY);1246if(fd <0)1247returnresolve_gitlink_packed_ref(refs, refname, sha1);12481249 len =read(fd, buffer,sizeof(buffer)-1);1250close(fd);1251if(len <0)1252return-1;1253while(len &&isspace(buffer[len-1]))1254 len--;1255 buffer[len] =0;12561257/* Was it a detached head or an old-fashioned symlink? */1258if(!get_sha1_hex(buffer, sha1))1259return0;12601261/* Symref? */1262if(strncmp(buffer,"ref:",4))1263return-1;1264 p = buffer +4;1265while(isspace(*p))1266 p++;12671268returnresolve_gitlink_ref_recursive(refs, p, sha1, recursion+1);1269}12701271intresolve_gitlink_ref(const char*path,const char*refname,unsigned char*sha1)1272{1273int len =strlen(path), retval;1274char*submodule;1275struct ref_cache *refs;12761277while(len && path[len-1] =='/')1278 len--;1279if(!len)1280return-1;1281 submodule =xstrndup(path, len);1282 refs =get_ref_cache(submodule);1283free(submodule);12841285 retval =resolve_gitlink_ref_recursive(refs, refname, sha1,0);1286return retval;1287}12881289/*1290 * Return the ref_entry for the given refname from the packed1291 * references. If it does not exist, return NULL.1292 */1293static struct ref_entry *get_packed_ref(const char*refname)1294{1295returnfind_ref(get_packed_refs(&ref_cache), refname);1296}12971298/*1299 * A loose ref file doesn't exist; check for a packed ref. The1300 * options are forwarded from resolve_safe_unsafe().1301 */1302static const char*handle_missing_loose_ref(const char*refname,1303unsigned char*sha1,1304int reading,1305int*flag)1306{1307struct ref_entry *entry;13081309/*1310 * The loose reference file does not exist; check for a packed1311 * reference.1312 */1313 entry =get_packed_ref(refname);1314if(entry) {1315hashcpy(sha1, entry->u.value.sha1);1316if(flag)1317*flag |= REF_ISPACKED;1318return refname;1319}1320/* The reference is not a packed reference, either. */1321if(reading) {1322return NULL;1323}else{1324hashclr(sha1);1325return refname;1326}1327}13281329const char*resolve_ref_unsafe(const char*refname,unsigned char*sha1,int reading,int*flag)1330{1331int depth = MAXDEPTH;1332 ssize_t len;1333char buffer[256];1334static char refname_buffer[256];13351336if(flag)1337*flag =0;13381339if(check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))1340return NULL;13411342for(;;) {1343char path[PATH_MAX];1344struct stat st;1345char*buf;1346int fd;13471348if(--depth <0)1349return NULL;13501351git_snpath(path,sizeof(path),"%s", refname);13521353/*1354 * We might have to loop back here to avoid a race1355 * condition: first we lstat() the file, then we try1356 * to read it as a link or as a file. But if somebody1357 * changes the type of the file (file <-> directory1358 * <-> symlink) between the lstat() and reading, then1359 * we don't want to report that as an error but rather1360 * try again starting with the lstat().1361 */1362 stat_ref:1363if(lstat(path, &st) <0) {1364if(errno == ENOENT)1365returnhandle_missing_loose_ref(refname, sha1,1366 reading, flag);1367else1368return NULL;1369}13701371/* Follow "normalized" - ie "refs/.." symlinks by hand */1372if(S_ISLNK(st.st_mode)) {1373 len =readlink(path, buffer,sizeof(buffer)-1);1374if(len <0) {1375if(errno == ENOENT || errno == EINVAL)1376/* inconsistent with lstat; retry */1377goto stat_ref;1378else1379return NULL;1380}1381 buffer[len] =0;1382if(!prefixcmp(buffer,"refs/") &&1383!check_refname_format(buffer,0)) {1384strcpy(refname_buffer, buffer);1385 refname = refname_buffer;1386if(flag)1387*flag |= REF_ISSYMREF;1388continue;1389}1390}13911392/* Is it a directory? */1393if(S_ISDIR(st.st_mode)) {1394 errno = EISDIR;1395return NULL;1396}13971398/*1399 * Anything else, just open it and try to use it as1400 * a ref1401 */1402 fd =open(path, O_RDONLY);1403if(fd <0) {1404if(errno == ENOENT)1405/* inconsistent with lstat; retry */1406goto stat_ref;1407else1408return NULL;1409}1410 len =read_in_full(fd, buffer,sizeof(buffer)-1);1411close(fd);1412if(len <0)1413return NULL;1414while(len &&isspace(buffer[len-1]))1415 len--;1416 buffer[len] ='\0';14171418/*1419 * Is it a symbolic ref?1420 */1421if(prefixcmp(buffer,"ref:")) {1422/*1423 * Please note that FETCH_HEAD has a second1424 * line containing other data.1425 */1426if(get_sha1_hex(buffer, sha1) ||1427(buffer[40] !='\0'&& !isspace(buffer[40]))) {1428if(flag)1429*flag |= REF_ISBROKEN;1430return NULL;1431}1432return refname;1433}1434if(flag)1435*flag |= REF_ISSYMREF;1436 buf = buffer +4;1437while(isspace(*buf))1438 buf++;1439if(check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {1440if(flag)1441*flag |= REF_ISBROKEN;1442return NULL;1443}1444 refname =strcpy(refname_buffer, buf);1445}1446}14471448char*resolve_refdup(const char*ref,unsigned char*sha1,int reading,int*flag)1449{1450const char*ret =resolve_ref_unsafe(ref, sha1, reading, flag);1451return ret ?xstrdup(ret) : NULL;1452}14531454/* The argument to filter_refs */1455struct ref_filter {1456const char*pattern;1457 each_ref_fn *fn;1458void*cb_data;1459};14601461intread_ref_full(const char*refname,unsigned char*sha1,int reading,int*flags)1462{1463if(resolve_ref_unsafe(refname, sha1, reading, flags))1464return0;1465return-1;1466}14671468intread_ref(const char*refname,unsigned char*sha1)1469{1470returnread_ref_full(refname, sha1,1, NULL);1471}14721473intref_exists(const char*refname)1474{1475unsigned char sha1[20];1476return!!resolve_ref_unsafe(refname, sha1,1, NULL);1477}14781479static intfilter_refs(const char*refname,const unsigned char*sha1,int flags,1480void*data)1481{1482struct ref_filter *filter = (struct ref_filter *)data;1483if(fnmatch(filter->pattern, refname,0))1484return0;1485return filter->fn(refname, sha1, flags, filter->cb_data);1486}14871488enum peel_status {1489/* object was peeled successfully: */1490 PEEL_PEELED =0,14911492/*1493 * object cannot be peeled because the named object (or an1494 * object referred to by a tag in the peel chain), does not1495 * exist.1496 */1497 PEEL_INVALID = -1,14981499/* object cannot be peeled because it is not a tag: */1500 PEEL_NON_TAG = -2,15011502/* ref_entry contains no peeled value because it is a symref: */1503 PEEL_IS_SYMREF = -3,15041505/*1506 * ref_entry cannot be peeled because it is broken (i.e., the1507 * symbolic reference cannot even be resolved to an object1508 * name):1509 */1510 PEEL_BROKEN = -41511};15121513/*1514 * Peel the named object; i.e., if the object is a tag, resolve the1515 * tag recursively until a non-tag is found. If successful, store the1516 * result to sha1 and return PEEL_PEELED. If the object is not a tag1517 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,1518 * and leave sha1 unchanged.1519 */1520static enum peel_status peel_object(const unsigned char*name,unsigned char*sha1)1521{1522struct object *o =lookup_unknown_object(name);15231524if(o->type == OBJ_NONE) {1525int type =sha1_object_info(name, NULL);1526if(type <0)1527return PEEL_INVALID;1528 o->type = type;1529}15301531if(o->type != OBJ_TAG)1532return PEEL_NON_TAG;15331534 o =deref_tag_noverify(o);1535if(!o)1536return PEEL_INVALID;15371538hashcpy(sha1, o->sha1);1539return PEEL_PEELED;1540}15411542/*1543 * Peel the entry (if possible) and return its new peel_status. If1544 * repeel is true, re-peel the entry even if there is an old peeled1545 * value that is already stored in it.1546 *1547 * It is OK to call this function with a packed reference entry that1548 * might be stale and might even refer to an object that has since1549 * been garbage-collected. In such a case, if the entry has1550 * REF_KNOWS_PEELED then leave the status unchanged and return1551 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.1552 */1553static enum peel_status peel_entry(struct ref_entry *entry,int repeel)1554{1555enum peel_status status;15561557if(entry->flag & REF_KNOWS_PEELED) {1558if(repeel) {1559 entry->flag &= ~REF_KNOWS_PEELED;1560hashclr(entry->u.value.peeled);1561}else{1562returnis_null_sha1(entry->u.value.peeled) ?1563 PEEL_NON_TAG : PEEL_PEELED;1564}1565}1566if(entry->flag & REF_ISBROKEN)1567return PEEL_BROKEN;1568if(entry->flag & REF_ISSYMREF)1569return PEEL_IS_SYMREF;15701571 status =peel_object(entry->u.value.sha1, entry->u.value.peeled);1572if(status == PEEL_PEELED || status == PEEL_NON_TAG)1573 entry->flag |= REF_KNOWS_PEELED;1574return status;1575}15761577intpeel_ref(const char*refname,unsigned char*sha1)1578{1579int flag;1580unsigned char base[20];15811582if(current_ref && (current_ref->name == refname1583|| !strcmp(current_ref->name, refname))) {1584if(peel_entry(current_ref,0))1585return-1;1586hashcpy(sha1, current_ref->u.value.peeled);1587return0;1588}15891590if(read_ref_full(refname, base,1, &flag))1591return-1;15921593/*1594 * If the reference is packed, read its ref_entry from the1595 * cache in the hope that we already know its peeled value.1596 * We only try this optimization on packed references because1597 * (a) forcing the filling of the loose reference cache could1598 * be expensive and (b) loose references anyway usually do not1599 * have REF_KNOWS_PEELED.1600 */1601if(flag & REF_ISPACKED) {1602struct ref_entry *r =get_packed_ref(refname);1603if(r) {1604if(peel_entry(r,0))1605return-1;1606hashcpy(sha1, r->u.value.peeled);1607return0;1608}1609}16101611returnpeel_object(base, sha1);1612}16131614struct warn_if_dangling_data {1615FILE*fp;1616const char*refname;1617const char*msg_fmt;1618};16191620static intwarn_if_dangling_symref(const char*refname,const unsigned char*sha1,1621int flags,void*cb_data)1622{1623struct warn_if_dangling_data *d = cb_data;1624const char*resolves_to;1625unsigned char junk[20];16261627if(!(flags & REF_ISSYMREF))1628return0;16291630 resolves_to =resolve_ref_unsafe(refname, junk,0, NULL);1631if(!resolves_to ||strcmp(resolves_to, d->refname))1632return0;16331634fprintf(d->fp, d->msg_fmt, refname);1635fputc('\n', d->fp);1636return0;1637}16381639voidwarn_dangling_symref(FILE*fp,const char*msg_fmt,const char*refname)1640{1641struct warn_if_dangling_data data;16421643 data.fp = fp;1644 data.refname = refname;1645 data.msg_fmt = msg_fmt;1646for_each_rawref(warn_if_dangling_symref, &data);1647}16481649/*1650 * Call fn for each reference in the specified ref_cache, omitting1651 * references not in the containing_dir of base. fn is called for all1652 * references, including broken ones. If fn ever returns a non-zero1653 * value, stop the iteration and return that value; otherwise, return1654 * 0.1655 */1656static intdo_for_each_entry(struct ref_cache *refs,const char*base,1657 each_ref_entry_fn fn,void*cb_data)1658{1659struct packed_ref_cache *packed_ref_cache;1660struct ref_dir *loose_dir;1661struct ref_dir *packed_dir;1662int retval =0;16631664/*1665 * We must make sure that all loose refs are read before accessing the1666 * packed-refs file; this avoids a race condition in which loose refs1667 * are migrated to the packed-refs file by a simultaneous process, but1668 * our in-memory view is from before the migration. get_packed_ref_cache()1669 * takes care of making sure our view is up to date with what is on1670 * disk.1671 */1672 loose_dir =get_loose_refs(refs);1673if(base && *base) {1674 loose_dir =find_containing_dir(loose_dir, base,0);1675}1676if(loose_dir)1677prime_ref_dir(loose_dir);16781679 packed_ref_cache =get_packed_ref_cache(refs);1680acquire_packed_ref_cache(packed_ref_cache);1681 packed_dir =get_packed_ref_dir(packed_ref_cache);1682if(base && *base) {1683 packed_dir =find_containing_dir(packed_dir, base,0);1684}16851686if(packed_dir && loose_dir) {1687sort_ref_dir(packed_dir);1688sort_ref_dir(loose_dir);1689 retval =do_for_each_entry_in_dirs(1690 packed_dir, loose_dir, fn, cb_data);1691}else if(packed_dir) {1692sort_ref_dir(packed_dir);1693 retval =do_for_each_entry_in_dir(1694 packed_dir,0, fn, cb_data);1695}else if(loose_dir) {1696sort_ref_dir(loose_dir);1697 retval =do_for_each_entry_in_dir(1698 loose_dir,0, fn, cb_data);1699}17001701release_packed_ref_cache(packed_ref_cache);1702return retval;1703}17041705/*1706 * Call fn for each reference in the specified ref_cache for which the1707 * refname begins with base. If trim is non-zero, then trim that many1708 * characters off the beginning of each refname before passing the1709 * refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include1710 * broken references in the iteration. If fn ever returns a non-zero1711 * value, stop the iteration and return that value; otherwise, return1712 * 0.1713 */1714static intdo_for_each_ref(struct ref_cache *refs,const char*base,1715 each_ref_fn fn,int trim,int flags,void*cb_data)1716{1717struct ref_entry_cb data;1718 data.base = base;1719 data.trim = trim;1720 data.flags = flags;1721 data.fn = fn;1722 data.cb_data = cb_data;17231724returndo_for_each_entry(refs, base, do_one_ref, &data);1725}17261727static intdo_head_ref(const char*submodule, each_ref_fn fn,void*cb_data)1728{1729unsigned char sha1[20];1730int flag;17311732if(submodule) {1733if(resolve_gitlink_ref(submodule,"HEAD", sha1) ==0)1734returnfn("HEAD", sha1,0, cb_data);17351736return0;1737}17381739if(!read_ref_full("HEAD", sha1,1, &flag))1740returnfn("HEAD", sha1, flag, cb_data);17411742return0;1743}17441745inthead_ref(each_ref_fn fn,void*cb_data)1746{1747returndo_head_ref(NULL, fn, cb_data);1748}17491750inthead_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1751{1752returndo_head_ref(submodule, fn, cb_data);1753}17541755intfor_each_ref(each_ref_fn fn,void*cb_data)1756{1757returndo_for_each_ref(&ref_cache,"", fn,0,0, cb_data);1758}17591760intfor_each_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1761{1762returndo_for_each_ref(get_ref_cache(submodule),"", fn,0,0, cb_data);1763}17641765intfor_each_ref_in(const char*prefix, each_ref_fn fn,void*cb_data)1766{1767returndo_for_each_ref(&ref_cache, prefix, fn,strlen(prefix),0, cb_data);1768}17691770intfor_each_ref_in_submodule(const char*submodule,const char*prefix,1771 each_ref_fn fn,void*cb_data)1772{1773returndo_for_each_ref(get_ref_cache(submodule), prefix, fn,strlen(prefix),0, cb_data);1774}17751776intfor_each_tag_ref(each_ref_fn fn,void*cb_data)1777{1778returnfor_each_ref_in("refs/tags/", fn, cb_data);1779}17801781intfor_each_tag_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1782{1783returnfor_each_ref_in_submodule(submodule,"refs/tags/", fn, cb_data);1784}17851786intfor_each_branch_ref(each_ref_fn fn,void*cb_data)1787{1788returnfor_each_ref_in("refs/heads/", fn, cb_data);1789}17901791intfor_each_branch_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1792{1793returnfor_each_ref_in_submodule(submodule,"refs/heads/", fn, cb_data);1794}17951796intfor_each_remote_ref(each_ref_fn fn,void*cb_data)1797{1798returnfor_each_ref_in("refs/remotes/", fn, cb_data);1799}18001801intfor_each_remote_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1802{1803returnfor_each_ref_in_submodule(submodule,"refs/remotes/", fn, cb_data);1804}18051806intfor_each_replace_ref(each_ref_fn fn,void*cb_data)1807{1808returndo_for_each_ref(&ref_cache,"refs/replace/", fn,13,0, cb_data);1809}18101811inthead_ref_namespaced(each_ref_fn fn,void*cb_data)1812{1813struct strbuf buf = STRBUF_INIT;1814int ret =0;1815unsigned char sha1[20];1816int flag;18171818strbuf_addf(&buf,"%sHEAD",get_git_namespace());1819if(!read_ref_full(buf.buf, sha1,1, &flag))1820 ret =fn(buf.buf, sha1, flag, cb_data);1821strbuf_release(&buf);18221823return ret;1824}18251826intfor_each_namespaced_ref(each_ref_fn fn,void*cb_data)1827{1828struct strbuf buf = STRBUF_INIT;1829int ret;1830strbuf_addf(&buf,"%srefs/",get_git_namespace());1831 ret =do_for_each_ref(&ref_cache, buf.buf, fn,0,0, cb_data);1832strbuf_release(&buf);1833return ret;1834}18351836intfor_each_glob_ref_in(each_ref_fn fn,const char*pattern,1837const char*prefix,void*cb_data)1838{1839struct strbuf real_pattern = STRBUF_INIT;1840struct ref_filter filter;1841int ret;18421843if(!prefix &&prefixcmp(pattern,"refs/"))1844strbuf_addstr(&real_pattern,"refs/");1845else if(prefix)1846strbuf_addstr(&real_pattern, prefix);1847strbuf_addstr(&real_pattern, pattern);18481849if(!has_glob_specials(pattern)) {1850/* Append implied '/' '*' if not present. */1851if(real_pattern.buf[real_pattern.len -1] !='/')1852strbuf_addch(&real_pattern,'/');1853/* No need to check for '*', there is none. */1854strbuf_addch(&real_pattern,'*');1855}18561857 filter.pattern = real_pattern.buf;1858 filter.fn = fn;1859 filter.cb_data = cb_data;1860 ret =for_each_ref(filter_refs, &filter);18611862strbuf_release(&real_pattern);1863return ret;1864}18651866intfor_each_glob_ref(each_ref_fn fn,const char*pattern,void*cb_data)1867{1868returnfor_each_glob_ref_in(fn, pattern, NULL, cb_data);1869}18701871intfor_each_rawref(each_ref_fn fn,void*cb_data)1872{1873returndo_for_each_ref(&ref_cache,"", fn,0,1874 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);1875}18761877const char*prettify_refname(const char*name)1878{1879return name + (1880!prefixcmp(name,"refs/heads/") ?11:1881!prefixcmp(name,"refs/tags/") ?10:1882!prefixcmp(name,"refs/remotes/") ?13:18830);1884}18851886const char*ref_rev_parse_rules[] = {1887"%.*s",1888"refs/%.*s",1889"refs/tags/%.*s",1890"refs/heads/%.*s",1891"refs/remotes/%.*s",1892"refs/remotes/%.*s/HEAD",1893 NULL1894};18951896intrefname_match(const char*abbrev_name,const char*full_name,const char**rules)1897{1898const char**p;1899const int abbrev_name_len =strlen(abbrev_name);19001901for(p = rules; *p; p++) {1902if(!strcmp(full_name,mkpath(*p, abbrev_name_len, abbrev_name))) {1903return1;1904}1905}19061907return0;1908}19091910static struct ref_lock *verify_lock(struct ref_lock *lock,1911const unsigned char*old_sha1,int mustexist)1912{1913if(read_ref_full(lock->ref_name, lock->old_sha1, mustexist, NULL)) {1914error("Can't verify ref%s", lock->ref_name);1915unlock_ref(lock);1916return NULL;1917}1918if(hashcmp(lock->old_sha1, old_sha1)) {1919error("Ref%sis at%sbut expected%s", lock->ref_name,1920sha1_to_hex(lock->old_sha1),sha1_to_hex(old_sha1));1921unlock_ref(lock);1922return NULL;1923}1924return lock;1925}19261927static intremove_empty_directories(const char*file)1928{1929/* we want to create a file but there is a directory there;1930 * if that is an empty directory (or a directory that contains1931 * only empty directories), remove them.1932 */1933struct strbuf path;1934int result;19351936strbuf_init(&path,20);1937strbuf_addstr(&path, file);19381939 result =remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);19401941strbuf_release(&path);19421943return result;1944}19451946/*1947 * *string and *len will only be substituted, and *string returned (for1948 * later free()ing) if the string passed in is a magic short-hand form1949 * to name a branch.1950 */1951static char*substitute_branch_name(const char**string,int*len)1952{1953struct strbuf buf = STRBUF_INIT;1954int ret =interpret_branch_name(*string, &buf);19551956if(ret == *len) {1957size_t size;1958*string =strbuf_detach(&buf, &size);1959*len = size;1960return(char*)*string;1961}19621963return NULL;1964}19651966intdwim_ref(const char*str,int len,unsigned char*sha1,char**ref)1967{1968char*last_branch =substitute_branch_name(&str, &len);1969const char**p, *r;1970int refs_found =0;19711972*ref = NULL;1973for(p = ref_rev_parse_rules; *p; p++) {1974char fullref[PATH_MAX];1975unsigned char sha1_from_ref[20];1976unsigned char*this_result;1977int flag;19781979 this_result = refs_found ? sha1_from_ref : sha1;1980mksnpath(fullref,sizeof(fullref), *p, len, str);1981 r =resolve_ref_unsafe(fullref, this_result,1, &flag);1982if(r) {1983if(!refs_found++)1984*ref =xstrdup(r);1985if(!warn_ambiguous_refs)1986break;1987}else if((flag & REF_ISSYMREF) &&strcmp(fullref,"HEAD")) {1988warning("ignoring dangling symref%s.", fullref);1989}else if((flag & REF_ISBROKEN) &&strchr(fullref,'/')) {1990warning("ignoring broken ref%s.", fullref);1991}1992}1993free(last_branch);1994return refs_found;1995}19961997intdwim_log(const char*str,int len,unsigned char*sha1,char**log)1998{1999char*last_branch =substitute_branch_name(&str, &len);2000const char**p;2001int logs_found =0;20022003*log = NULL;2004for(p = ref_rev_parse_rules; *p; p++) {2005struct stat st;2006unsigned char hash[20];2007char path[PATH_MAX];2008const char*ref, *it;20092010mksnpath(path,sizeof(path), *p, len, str);2011 ref =resolve_ref_unsafe(path, hash,1, NULL);2012if(!ref)2013continue;2014if(!stat(git_path("logs/%s", path), &st) &&2015S_ISREG(st.st_mode))2016 it = path;2017else if(strcmp(ref, path) &&2018!stat(git_path("logs/%s", ref), &st) &&2019S_ISREG(st.st_mode))2020 it = ref;2021else2022continue;2023if(!logs_found++) {2024*log =xstrdup(it);2025hashcpy(sha1, hash);2026}2027if(!warn_ambiguous_refs)2028break;2029}2030free(last_branch);2031return logs_found;2032}20332034static struct ref_lock *lock_ref_sha1_basic(const char*refname,2035const unsigned char*old_sha1,2036int flags,int*type_p)2037{2038char*ref_file;2039const char*orig_refname = refname;2040struct ref_lock *lock;2041int last_errno =0;2042int type, lflags;2043int mustexist = (old_sha1 && !is_null_sha1(old_sha1));2044int missing =0;20452046 lock =xcalloc(1,sizeof(struct ref_lock));2047 lock->lock_fd = -1;20482049 refname =resolve_ref_unsafe(refname, lock->old_sha1, mustexist, &type);2050if(!refname && errno == EISDIR) {2051/* we are trying to lock foo but we used to2052 * have foo/bar which now does not exist;2053 * it is normal for the empty directory 'foo'2054 * to remain.2055 */2056 ref_file =git_path("%s", orig_refname);2057if(remove_empty_directories(ref_file)) {2058 last_errno = errno;2059error("there are still refs under '%s'", orig_refname);2060goto error_return;2061}2062 refname =resolve_ref_unsafe(orig_refname, lock->old_sha1, mustexist, &type);2063}2064if(type_p)2065*type_p = type;2066if(!refname) {2067 last_errno = errno;2068error("unable to resolve reference%s:%s",2069 orig_refname,strerror(errno));2070goto error_return;2071}2072 missing =is_null_sha1(lock->old_sha1);2073/* When the ref did not exist and we are creating it,2074 * make sure there is no existing ref that is packed2075 * whose name begins with our refname, nor a ref whose2076 * name is a proper prefix of our refname.2077 */2078if(missing &&2079!is_refname_available(refname, NULL,get_packed_refs(&ref_cache))) {2080 last_errno = ENOTDIR;2081goto error_return;2082}20832084 lock->lk =xcalloc(1,sizeof(struct lock_file));20852086 lflags = LOCK_DIE_ON_ERROR;2087if(flags & REF_NODEREF) {2088 refname = orig_refname;2089 lflags |= LOCK_NODEREF;2090}2091 lock->ref_name =xstrdup(refname);2092 lock->orig_ref_name =xstrdup(orig_refname);2093 ref_file =git_path("%s", refname);2094if(missing)2095 lock->force_write =1;2096if((flags & REF_NODEREF) && (type & REF_ISSYMREF))2097 lock->force_write =1;20982099if(safe_create_leading_directories(ref_file)) {2100 last_errno = errno;2101error("unable to create directory for%s", ref_file);2102goto error_return;2103}21042105 lock->lock_fd =hold_lock_file_for_update(lock->lk, ref_file, lflags);2106return old_sha1 ?verify_lock(lock, old_sha1, mustexist) : lock;21072108 error_return:2109unlock_ref(lock);2110 errno = last_errno;2111return NULL;2112}21132114struct ref_lock *lock_ref_sha1(const char*refname,const unsigned char*old_sha1)2115{2116char refpath[PATH_MAX];2117if(check_refname_format(refname,0))2118return NULL;2119strcpy(refpath,mkpath("refs/%s", refname));2120returnlock_ref_sha1_basic(refpath, old_sha1,0, NULL);2121}21222123struct ref_lock *lock_any_ref_for_update(const char*refname,2124const unsigned char*old_sha1,2125int flags,int*type_p)2126{2127if(check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))2128return NULL;2129returnlock_ref_sha1_basic(refname, old_sha1, flags, type_p);2130}21312132/*2133 * Write an entry to the packed-refs file for the specified refname.2134 * If peeled is non-NULL, write it as the entry's peeled value.2135 */2136static voidwrite_packed_entry(int fd,char*refname,unsigned char*sha1,2137unsigned char*peeled)2138{2139char line[PATH_MAX +100];2140int len;21412142 len =snprintf(line,sizeof(line),"%s %s\n",2143sha1_to_hex(sha1), refname);2144/* this should not happen but just being defensive */2145if(len >sizeof(line))2146die("too long a refname '%s'", refname);2147write_or_die(fd, line, len);21482149if(peeled) {2150if(snprintf(line,sizeof(line),"^%s\n",2151sha1_to_hex(peeled)) != PEELED_LINE_LENGTH)2152die("internal error");2153write_or_die(fd, line, PEELED_LINE_LENGTH);2154}2155}21562157/*2158 * An each_ref_entry_fn that writes the entry to a packed-refs file.2159 */2160static intwrite_packed_entry_fn(struct ref_entry *entry,void*cb_data)2161{2162int*fd = cb_data;2163enum peel_status peel_status =peel_entry(entry,0);21642165if(peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2166error("internal error:%sis not a valid packed reference!",2167 entry->name);2168write_packed_entry(*fd, entry->name, entry->u.value.sha1,2169 peel_status == PEEL_PEELED ?2170 entry->u.value.peeled : NULL);2171return0;2172}21732174intlock_packed_refs(int flags)2175{2176struct packed_ref_cache *packed_ref_cache;21772178if(hold_lock_file_for_update(&packlock,git_path("packed-refs"), flags) <0)2179return-1;2180/*2181 * Get the current packed-refs while holding the lock. If the2182 * packed-refs file has been modified since we last read it,2183 * this will automatically invalidate the cache and re-read2184 * the packed-refs file.2185 */2186 packed_ref_cache =get_packed_ref_cache(&ref_cache);2187 packed_ref_cache->lock = &packlock;2188/* Increment the reference count to prevent it from being freed: */2189acquire_packed_ref_cache(packed_ref_cache);2190return0;2191}21922193intcommit_packed_refs(void)2194{2195struct packed_ref_cache *packed_ref_cache =2196get_packed_ref_cache(&ref_cache);2197int error =0;21982199if(!packed_ref_cache->lock)2200die("internal error: packed-refs not locked");2201write_or_die(packed_ref_cache->lock->fd,2202 PACKED_REFS_HEADER,strlen(PACKED_REFS_HEADER));22032204do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),22050, write_packed_entry_fn,2206&packed_ref_cache->lock->fd);2207if(commit_lock_file(packed_ref_cache->lock))2208 error = -1;2209 packed_ref_cache->lock = NULL;2210release_packed_ref_cache(packed_ref_cache);2211return error;2212}22132214voidrollback_packed_refs(void)2215{2216struct packed_ref_cache *packed_ref_cache =2217get_packed_ref_cache(&ref_cache);22182219if(!packed_ref_cache->lock)2220die("internal error: packed-refs not locked");2221rollback_lock_file(packed_ref_cache->lock);2222 packed_ref_cache->lock = NULL;2223release_packed_ref_cache(packed_ref_cache);2224clear_packed_ref_cache(&ref_cache);2225}22262227struct ref_to_prune {2228struct ref_to_prune *next;2229unsigned char sha1[20];2230char name[FLEX_ARRAY];2231};22322233struct pack_refs_cb_data {2234unsigned int flags;2235struct ref_dir *packed_refs;2236struct ref_to_prune *ref_to_prune;2237};22382239/*2240 * An each_ref_entry_fn that is run over loose references only. If2241 * the loose reference can be packed, add an entry in the packed ref2242 * cache. If the reference should be pruned, also add it to2243 * ref_to_prune in the pack_refs_cb_data.2244 */2245static intpack_if_possible_fn(struct ref_entry *entry,void*cb_data)2246{2247struct pack_refs_cb_data *cb = cb_data;2248enum peel_status peel_status;2249struct ref_entry *packed_entry;2250int is_tag_ref = !prefixcmp(entry->name,"refs/tags/");22512252/* ALWAYS pack tags */2253if(!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)2254return0;22552256/* Do not pack symbolic or broken refs: */2257if((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))2258return0;22592260/* Add a packed ref cache entry equivalent to the loose entry. */2261 peel_status =peel_entry(entry,1);2262if(peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2263die("internal error peeling reference%s(%s)",2264 entry->name,sha1_to_hex(entry->u.value.sha1));2265 packed_entry =find_ref(cb->packed_refs, entry->name);2266if(packed_entry) {2267/* Overwrite existing packed entry with info from loose entry */2268 packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;2269hashcpy(packed_entry->u.value.sha1, entry->u.value.sha1);2270}else{2271 packed_entry =create_ref_entry(entry->name, entry->u.value.sha1,2272 REF_ISPACKED | REF_KNOWS_PEELED,0);2273add_ref(cb->packed_refs, packed_entry);2274}2275hashcpy(packed_entry->u.value.peeled, entry->u.value.peeled);22762277/* Schedule the loose reference for pruning if requested. */2278if((cb->flags & PACK_REFS_PRUNE)) {2279int namelen =strlen(entry->name) +1;2280struct ref_to_prune *n =xcalloc(1,sizeof(*n) + namelen);2281hashcpy(n->sha1, entry->u.value.sha1);2282strcpy(n->name, entry->name);2283 n->next = cb->ref_to_prune;2284 cb->ref_to_prune = n;2285}2286return0;2287}22882289/*2290 * Remove empty parents, but spare refs/ and immediate subdirs.2291 * Note: munges *name.2292 */2293static voidtry_remove_empty_parents(char*name)2294{2295char*p, *q;2296int i;2297 p = name;2298for(i =0; i <2; i++) {/* refs/{heads,tags,...}/ */2299while(*p && *p !='/')2300 p++;2301/* tolerate duplicate slashes; see check_refname_format() */2302while(*p =='/')2303 p++;2304}2305for(q = p; *q; q++)2306;2307while(1) {2308while(q > p && *q !='/')2309 q--;2310while(q > p && *(q-1) =='/')2311 q--;2312if(q == p)2313break;2314*q ='\0';2315if(rmdir(git_path("%s", name)))2316break;2317}2318}23192320/* make sure nobody touched the ref, and unlink */2321static voidprune_ref(struct ref_to_prune *r)2322{2323struct ref_lock *lock =lock_ref_sha1(r->name +5, r->sha1);23242325if(lock) {2326unlink_or_warn(git_path("%s", r->name));2327unlock_ref(lock);2328try_remove_empty_parents(r->name);2329}2330}23312332static voidprune_refs(struct ref_to_prune *r)2333{2334while(r) {2335prune_ref(r);2336 r = r->next;2337}2338}23392340intpack_refs(unsigned int flags)2341{2342struct pack_refs_cb_data cbdata;23432344memset(&cbdata,0,sizeof(cbdata));2345 cbdata.flags = flags;23462347lock_packed_refs(LOCK_DIE_ON_ERROR);2348 cbdata.packed_refs =get_packed_refs(&ref_cache);23492350do_for_each_entry_in_dir(get_loose_refs(&ref_cache),0,2351 pack_if_possible_fn, &cbdata);23522353if(commit_packed_refs())2354die_errno("unable to overwrite old ref-pack file");23552356prune_refs(cbdata.ref_to_prune);2357return0;2358}23592360/*2361 * If entry is no longer needed in packed-refs, add it to the string2362 * list pointed to by cb_data. Reasons for deleting entries:2363 *2364 * - Entry is broken.2365 * - Entry is overridden by a loose ref.2366 * - Entry does not point at a valid object.2367 *2368 * In the first and third cases, also emit an error message because these2369 * are indications of repository corruption.2370 */2371static intcurate_packed_ref_fn(struct ref_entry *entry,void*cb_data)2372{2373struct string_list *refs_to_delete = cb_data;23742375if(entry->flag & REF_ISBROKEN) {2376/* This shouldn't happen to packed refs. */2377error("%sis broken!", entry->name);2378string_list_append(refs_to_delete, entry->name);2379return0;2380}2381if(!has_sha1_file(entry->u.value.sha1)) {2382unsigned char sha1[20];2383int flags;23842385if(read_ref_full(entry->name, sha1,0, &flags))2386/* We should at least have found the packed ref. */2387die("Internal error");2388if((flags & REF_ISSYMREF) || !(flags & REF_ISPACKED)) {2389/*2390 * This packed reference is overridden by a2391 * loose reference, so it is OK that its value2392 * is no longer valid; for example, it might2393 * refer to an object that has been garbage2394 * collected. For this purpose we don't even2395 * care whether the loose reference itself is2396 * invalid, broken, symbolic, etc. Silently2397 * remove the packed reference.2398 */2399string_list_append(refs_to_delete, entry->name);2400return0;2401}2402/*2403 * There is no overriding loose reference, so the fact2404 * that this reference doesn't refer to a valid object2405 * indicates some kind of repository corruption.2406 * Report the problem, then omit the reference from2407 * the output.2408 */2409error("%sdoes not point to a valid object!", entry->name);2410string_list_append(refs_to_delete, entry->name);2411return0;2412}24132414return0;2415}24162417static intrepack_without_refs(const char**refnames,int n)2418{2419struct ref_dir *packed;2420struct string_list refs_to_delete = STRING_LIST_INIT_DUP;2421struct string_list_item *ref_to_delete;2422int i, removed =0;24232424/* Look for a packed ref */2425for(i =0; i < n; i++)2426if(get_packed_ref(refnames[i]))2427break;24282429/* Avoid locking if we have nothing to do */2430if(i == n)2431return0;/* no refname exists in packed refs */24322433if(lock_packed_refs(0)) {2434unable_to_lock_error(git_path("packed-refs"), errno);2435returnerror("cannot delete '%s' from packed refs", refnames[i]);2436}2437 packed =get_packed_refs(&ref_cache);24382439/* Remove refnames from the cache */2440for(i =0; i < n; i++)2441if(remove_entry(packed, refnames[i]) != -1)2442 removed =1;2443if(!removed) {2444/*2445 * All packed entries disappeared while we were2446 * acquiring the lock.2447 */2448rollback_packed_refs();2449return0;2450}24512452/* Remove any other accumulated cruft */2453do_for_each_entry_in_dir(packed,0, curate_packed_ref_fn, &refs_to_delete);2454for_each_string_list_item(ref_to_delete, &refs_to_delete) {2455if(remove_entry(packed, ref_to_delete->string) == -1)2456die("internal error");2457}24582459/* Write what remains */2460returncommit_packed_refs();2461}24622463static intrepack_without_ref(const char*refname)2464{2465returnrepack_without_refs(&refname,1);2466}24672468static intdelete_ref_loose(struct ref_lock *lock,int flag)2469{2470if(!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {2471/* loose */2472int err, i =strlen(lock->lk->filename) -5;/* .lock */24732474 lock->lk->filename[i] =0;2475 err =unlink_or_warn(lock->lk->filename);2476 lock->lk->filename[i] ='.';2477if(err && errno != ENOENT)2478return1;2479}2480return0;2481}24822483intdelete_ref(const char*refname,const unsigned char*sha1,int delopt)2484{2485struct ref_lock *lock;2486int ret =0, flag =0;24872488 lock =lock_ref_sha1_basic(refname, sha1, delopt, &flag);2489if(!lock)2490return1;2491 ret |=delete_ref_loose(lock, flag);24922493/* removing the loose one could have resurrected an earlier2494 * packed one. Also, if it was not loose we need to repack2495 * without it.2496 */2497 ret |=repack_without_ref(lock->ref_name);24982499unlink_or_warn(git_path("logs/%s", lock->ref_name));2500clear_loose_ref_cache(&ref_cache);2501unlock_ref(lock);2502return ret;2503}25042505/*2506 * People using contrib's git-new-workdir have .git/logs/refs ->2507 * /some/other/path/.git/logs/refs, and that may live on another device.2508 *2509 * IOW, to avoid cross device rename errors, the temporary renamed log must2510 * live into logs/refs.2511 */2512#define TMP_RENAMED_LOG"logs/refs/.tmp-renamed-log"25132514intrename_ref(const char*oldrefname,const char*newrefname,const char*logmsg)2515{2516unsigned char sha1[20], orig_sha1[20];2517int flag =0, logmoved =0;2518struct ref_lock *lock;2519struct stat loginfo;2520int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);2521const char*symref = NULL;25222523if(log &&S_ISLNK(loginfo.st_mode))2524returnerror("reflog for%sis a symlink", oldrefname);25252526 symref =resolve_ref_unsafe(oldrefname, orig_sha1,1, &flag);2527if(flag & REF_ISSYMREF)2528returnerror("refname%sis a symbolic ref, renaming it is not supported",2529 oldrefname);2530if(!symref)2531returnerror("refname%snot found", oldrefname);25322533if(!is_refname_available(newrefname, oldrefname,get_packed_refs(&ref_cache)))2534return1;25352536if(!is_refname_available(newrefname, oldrefname,get_loose_refs(&ref_cache)))2537return1;25382539if(log &&rename(git_path("logs/%s", oldrefname),git_path(TMP_RENAMED_LOG)))2540returnerror("unable to move logfile logs/%sto "TMP_RENAMED_LOG":%s",2541 oldrefname,strerror(errno));25422543if(delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {2544error("unable to delete old%s", oldrefname);2545goto rollback;2546}25472548if(!read_ref_full(newrefname, sha1,1, &flag) &&2549delete_ref(newrefname, sha1, REF_NODEREF)) {2550if(errno==EISDIR) {2551if(remove_empty_directories(git_path("%s", newrefname))) {2552error("Directory not empty:%s", newrefname);2553goto rollback;2554}2555}else{2556error("unable to delete existing%s", newrefname);2557goto rollback;2558}2559}25602561if(log &&safe_create_leading_directories(git_path("logs/%s", newrefname))) {2562error("unable to create directory for%s", newrefname);2563goto rollback;2564}25652566 retry:2567if(log &&rename(git_path(TMP_RENAMED_LOG),git_path("logs/%s", newrefname))) {2568if(errno==EISDIR || errno==ENOTDIR) {2569/*2570 * rename(a, b) when b is an existing2571 * directory ought to result in ISDIR, but2572 * Solaris 5.8 gives ENOTDIR. Sheesh.2573 */2574if(remove_empty_directories(git_path("logs/%s", newrefname))) {2575error("Directory not empty: logs/%s", newrefname);2576goto rollback;2577}2578goto retry;2579}else{2580error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s:%s",2581 newrefname,strerror(errno));2582goto rollback;2583}2584}2585 logmoved = log;25862587 lock =lock_ref_sha1_basic(newrefname, NULL,0, NULL);2588if(!lock) {2589error("unable to lock%sfor update", newrefname);2590goto rollback;2591}2592 lock->force_write =1;2593hashcpy(lock->old_sha1, orig_sha1);2594if(write_ref_sha1(lock, orig_sha1, logmsg)) {2595error("unable to write current sha1 into%s", newrefname);2596goto rollback;2597}25982599return0;26002601 rollback:2602 lock =lock_ref_sha1_basic(oldrefname, NULL,0, NULL);2603if(!lock) {2604error("unable to lock%sfor rollback", oldrefname);2605goto rollbacklog;2606}26072608 lock->force_write =1;2609 flag = log_all_ref_updates;2610 log_all_ref_updates =0;2611if(write_ref_sha1(lock, orig_sha1, NULL))2612error("unable to write current sha1 into%s", oldrefname);2613 log_all_ref_updates = flag;26142615 rollbacklog:2616if(logmoved &&rename(git_path("logs/%s", newrefname),git_path("logs/%s", oldrefname)))2617error("unable to restore logfile%sfrom%s:%s",2618 oldrefname, newrefname,strerror(errno));2619if(!logmoved && log &&2620rename(git_path(TMP_RENAMED_LOG),git_path("logs/%s", oldrefname)))2621error("unable to restore logfile%sfrom "TMP_RENAMED_LOG":%s",2622 oldrefname,strerror(errno));26232624return1;2625}26262627intclose_ref(struct ref_lock *lock)2628{2629if(close_lock_file(lock->lk))2630return-1;2631 lock->lock_fd = -1;2632return0;2633}26342635intcommit_ref(struct ref_lock *lock)2636{2637if(commit_lock_file(lock->lk))2638return-1;2639 lock->lock_fd = -1;2640return0;2641}26422643voidunlock_ref(struct ref_lock *lock)2644{2645/* Do not free lock->lk -- atexit() still looks at them */2646if(lock->lk)2647rollback_lock_file(lock->lk);2648free(lock->ref_name);2649free(lock->orig_ref_name);2650free(lock);2651}26522653/*2654 * copy the reflog message msg to buf, which has been allocated sufficiently2655 * large, while cleaning up the whitespaces. Especially, convert LF to space,2656 * because reflog file is one line per entry.2657 */2658static intcopy_msg(char*buf,const char*msg)2659{2660char*cp = buf;2661char c;2662int wasspace =1;26632664*cp++ ='\t';2665while((c = *msg++)) {2666if(wasspace &&isspace(c))2667continue;2668 wasspace =isspace(c);2669if(wasspace)2670 c =' ';2671*cp++ = c;2672}2673while(buf < cp &&isspace(cp[-1]))2674 cp--;2675*cp++ ='\n';2676return cp - buf;2677}26782679intlog_ref_setup(const char*refname,char*logfile,int bufsize)2680{2681int logfd, oflags = O_APPEND | O_WRONLY;26822683git_snpath(logfile, bufsize,"logs/%s", refname);2684if(log_all_ref_updates &&2685(!prefixcmp(refname,"refs/heads/") ||2686!prefixcmp(refname,"refs/remotes/") ||2687!prefixcmp(refname,"refs/notes/") ||2688!strcmp(refname,"HEAD"))) {2689if(safe_create_leading_directories(logfile) <0)2690returnerror("unable to create directory for%s",2691 logfile);2692 oflags |= O_CREAT;2693}26942695 logfd =open(logfile, oflags,0666);2696if(logfd <0) {2697if(!(oflags & O_CREAT) && errno == ENOENT)2698return0;26992700if((oflags & O_CREAT) && errno == EISDIR) {2701if(remove_empty_directories(logfile)) {2702returnerror("There are still logs under '%s'",2703 logfile);2704}2705 logfd =open(logfile, oflags,0666);2706}27072708if(logfd <0)2709returnerror("Unable to append to%s:%s",2710 logfile,strerror(errno));2711}27122713adjust_shared_perm(logfile);2714close(logfd);2715return0;2716}27172718static intlog_ref_write(const char*refname,const unsigned char*old_sha1,2719const unsigned char*new_sha1,const char*msg)2720{2721int logfd, result, written, oflags = O_APPEND | O_WRONLY;2722unsigned maxlen, len;2723int msglen;2724char log_file[PATH_MAX];2725char*logrec;2726const char*committer;27272728if(log_all_ref_updates <0)2729 log_all_ref_updates = !is_bare_repository();27302731 result =log_ref_setup(refname, log_file,sizeof(log_file));2732if(result)2733return result;27342735 logfd =open(log_file, oflags);2736if(logfd <0)2737return0;2738 msglen = msg ?strlen(msg) :0;2739 committer =git_committer_info(0);2740 maxlen =strlen(committer) + msglen +100;2741 logrec =xmalloc(maxlen);2742 len =sprintf(logrec,"%s %s %s\n",2743sha1_to_hex(old_sha1),2744sha1_to_hex(new_sha1),2745 committer);2746if(msglen)2747 len +=copy_msg(logrec + len -1, msg) -1;2748 written = len <= maxlen ?write_in_full(logfd, logrec, len) : -1;2749free(logrec);2750if(close(logfd) !=0|| written != len)2751returnerror("Unable to append to%s", log_file);2752return0;2753}27542755static intis_branch(const char*refname)2756{2757return!strcmp(refname,"HEAD") || !prefixcmp(refname,"refs/heads/");2758}27592760intwrite_ref_sha1(struct ref_lock *lock,2761const unsigned char*sha1,const char*logmsg)2762{2763static char term ='\n';2764struct object *o;27652766if(!lock)2767return-1;2768if(!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {2769unlock_ref(lock);2770return0;2771}2772 o =parse_object(sha1);2773if(!o) {2774error("Trying to write ref%swith nonexistent object%s",2775 lock->ref_name,sha1_to_hex(sha1));2776unlock_ref(lock);2777return-1;2778}2779if(o->type != OBJ_COMMIT &&is_branch(lock->ref_name)) {2780error("Trying to write non-commit object%sto branch%s",2781sha1_to_hex(sha1), lock->ref_name);2782unlock_ref(lock);2783return-1;2784}2785if(write_in_full(lock->lock_fd,sha1_to_hex(sha1),40) !=40||2786write_in_full(lock->lock_fd, &term,1) !=12787||close_ref(lock) <0) {2788error("Couldn't write%s", lock->lk->filename);2789unlock_ref(lock);2790return-1;2791}2792clear_loose_ref_cache(&ref_cache);2793if(log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) <0||2794(strcmp(lock->ref_name, lock->orig_ref_name) &&2795log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) <0)) {2796unlock_ref(lock);2797return-1;2798}2799if(strcmp(lock->orig_ref_name,"HEAD") !=0) {2800/*2801 * Special hack: If a branch is updated directly and HEAD2802 * points to it (may happen on the remote side of a push2803 * for example) then logically the HEAD reflog should be2804 * updated too.2805 * A generic solution implies reverse symref information,2806 * but finding all symrefs pointing to the given branch2807 * would be rather costly for this rare event (the direct2808 * update of a branch) to be worth it. So let's cheat and2809 * check with HEAD only which should cover 99% of all usage2810 * scenarios (even 100% of the default ones).2811 */2812unsigned char head_sha1[20];2813int head_flag;2814const char*head_ref;2815 head_ref =resolve_ref_unsafe("HEAD", head_sha1,1, &head_flag);2816if(head_ref && (head_flag & REF_ISSYMREF) &&2817!strcmp(head_ref, lock->ref_name))2818log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);2819}2820if(commit_ref(lock)) {2821error("Couldn't set%s", lock->ref_name);2822unlock_ref(lock);2823return-1;2824}2825unlock_ref(lock);2826return0;2827}28282829intcreate_symref(const char*ref_target,const char*refs_heads_master,2830const char*logmsg)2831{2832const char*lockpath;2833char ref[1000];2834int fd, len, written;2835char*git_HEAD =git_pathdup("%s", ref_target);2836unsigned char old_sha1[20], new_sha1[20];28372838if(logmsg &&read_ref(ref_target, old_sha1))2839hashclr(old_sha1);28402841if(safe_create_leading_directories(git_HEAD) <0)2842returnerror("unable to create directory for%s", git_HEAD);28432844#ifndef NO_SYMLINK_HEAD2845if(prefer_symlink_refs) {2846unlink(git_HEAD);2847if(!symlink(refs_heads_master, git_HEAD))2848goto done;2849fprintf(stderr,"no symlink - falling back to symbolic ref\n");2850}2851#endif28522853 len =snprintf(ref,sizeof(ref),"ref:%s\n", refs_heads_master);2854if(sizeof(ref) <= len) {2855error("refname too long:%s", refs_heads_master);2856goto error_free_return;2857}2858 lockpath =mkpath("%s.lock", git_HEAD);2859 fd =open(lockpath, O_CREAT | O_EXCL | O_WRONLY,0666);2860if(fd <0) {2861error("Unable to open%sfor writing", lockpath);2862goto error_free_return;2863}2864 written =write_in_full(fd, ref, len);2865if(close(fd) !=0|| written != len) {2866error("Unable to write to%s", lockpath);2867goto error_unlink_return;2868}2869if(rename(lockpath, git_HEAD) <0) {2870error("Unable to create%s", git_HEAD);2871goto error_unlink_return;2872}2873if(adjust_shared_perm(git_HEAD)) {2874error("Unable to fix permissions on%s", lockpath);2875 error_unlink_return:2876unlink_or_warn(lockpath);2877 error_free_return:2878free(git_HEAD);2879return-1;2880}28812882#ifndef NO_SYMLINK_HEAD2883 done:2884#endif2885if(logmsg && !read_ref(refs_heads_master, new_sha1))2886log_ref_write(ref_target, old_sha1, new_sha1, logmsg);28872888free(git_HEAD);2889return0;2890}28912892static char*ref_msg(const char*line,const char*endp)2893{2894const char*ep;2895 line +=82;2896 ep =memchr(line,'\n', endp - line);2897if(!ep)2898 ep = endp;2899returnxmemdupz(line, ep - line);2900}29012902intread_ref_at(const char*refname,unsigned long at_time,int cnt,2903unsigned char*sha1,char**msg,2904unsigned long*cutoff_time,int*cutoff_tz,int*cutoff_cnt)2905{2906const char*logfile, *logdata, *logend, *rec, *lastgt, *lastrec;2907char*tz_c;2908int logfd, tz, reccnt =0;2909struct stat st;2910unsigned long date;2911unsigned char logged_sha1[20];2912void*log_mapped;2913size_t mapsz;29142915 logfile =git_path("logs/%s", refname);2916 logfd =open(logfile, O_RDONLY,0);2917if(logfd <0)2918die_errno("Unable to read log '%s'", logfile);2919fstat(logfd, &st);2920if(!st.st_size)2921die("Log%sis empty.", logfile);2922 mapsz =xsize_t(st.st_size);2923 log_mapped =xmmap(NULL, mapsz, PROT_READ, MAP_PRIVATE, logfd,0);2924 logdata = log_mapped;2925close(logfd);29262927 lastrec = NULL;2928 rec = logend = logdata + st.st_size;2929while(logdata < rec) {2930 reccnt++;2931if(logdata < rec && *(rec-1) =='\n')2932 rec--;2933 lastgt = NULL;2934while(logdata < rec && *(rec-1) !='\n') {2935 rec--;2936if(*rec =='>')2937 lastgt = rec;2938}2939if(!lastgt)2940die("Log%sis corrupt.", logfile);2941 date =strtoul(lastgt +1, &tz_c,10);2942if(date <= at_time || cnt ==0) {2943 tz =strtoul(tz_c, NULL,10);2944if(msg)2945*msg =ref_msg(rec, logend);2946if(cutoff_time)2947*cutoff_time = date;2948if(cutoff_tz)2949*cutoff_tz = tz;2950if(cutoff_cnt)2951*cutoff_cnt = reccnt -1;2952if(lastrec) {2953if(get_sha1_hex(lastrec, logged_sha1))2954die("Log%sis corrupt.", logfile);2955if(get_sha1_hex(rec +41, sha1))2956die("Log%sis corrupt.", logfile);2957if(hashcmp(logged_sha1, sha1)) {2958warning("Log%shas gap after%s.",2959 logfile,show_date(date, tz, DATE_RFC2822));2960}2961}2962else if(date == at_time) {2963if(get_sha1_hex(rec +41, sha1))2964die("Log%sis corrupt.", logfile);2965}2966else{2967if(get_sha1_hex(rec +41, logged_sha1))2968die("Log%sis corrupt.", logfile);2969if(hashcmp(logged_sha1, sha1)) {2970warning("Log%sunexpectedly ended on%s.",2971 logfile,show_date(date, tz, DATE_RFC2822));2972}2973}2974munmap(log_mapped, mapsz);2975return0;2976}2977 lastrec = rec;2978if(cnt >0)2979 cnt--;2980}29812982 rec = logdata;2983while(rec < logend && *rec !='>'&& *rec !='\n')2984 rec++;2985if(rec == logend || *rec =='\n')2986die("Log%sis corrupt.", logfile);2987 date =strtoul(rec +1, &tz_c,10);2988 tz =strtoul(tz_c, NULL,10);2989if(get_sha1_hex(logdata, sha1))2990die("Log%sis corrupt.", logfile);2991if(is_null_sha1(sha1)) {2992if(get_sha1_hex(logdata +41, sha1))2993die("Log%sis corrupt.", logfile);2994}2995if(msg)2996*msg =ref_msg(logdata, logend);2997munmap(log_mapped, mapsz);29982999if(cutoff_time)3000*cutoff_time = date;3001if(cutoff_tz)3002*cutoff_tz = tz;3003if(cutoff_cnt)3004*cutoff_cnt = reccnt;3005return1;3006}30073008static intshow_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn,void*cb_data)3009{3010unsigned char osha1[20], nsha1[20];3011char*email_end, *message;3012unsigned long timestamp;3013int tz;30143015/* old SP new SP name <email> SP time TAB msg LF */3016if(sb->len <83|| sb->buf[sb->len -1] !='\n'||3017get_sha1_hex(sb->buf, osha1) || sb->buf[40] !=' '||3018get_sha1_hex(sb->buf +41, nsha1) || sb->buf[81] !=' '||3019!(email_end =strchr(sb->buf +82,'>')) ||3020 email_end[1] !=' '||3021!(timestamp =strtoul(email_end +2, &message,10)) ||3022!message || message[0] !=' '||3023(message[1] !='+'&& message[1] !='-') ||3024!isdigit(message[2]) || !isdigit(message[3]) ||3025!isdigit(message[4]) || !isdigit(message[5]))3026return0;/* corrupt? */3027 email_end[1] ='\0';3028 tz =strtol(message +1, NULL,10);3029if(message[6] !='\t')3030 message +=6;3031else3032 message +=7;3033returnfn(osha1, nsha1, sb->buf +82, timestamp, tz, message, cb_data);3034}30353036static char*find_beginning_of_line(char*bob,char*scan)3037{3038while(bob < scan && *(--scan) !='\n')3039;/* keep scanning backwards */3040/*3041 * Return either beginning of the buffer, or LF at the end of3042 * the previous line.3043 */3044return scan;3045}30463047intfor_each_reflog_ent_reverse(const char*refname, each_reflog_ent_fn fn,void*cb_data)3048{3049struct strbuf sb = STRBUF_INIT;3050FILE*logfp;3051long pos;3052int ret =0, at_tail =1;30533054 logfp =fopen(git_path("logs/%s", refname),"r");3055if(!logfp)3056return-1;30573058/* Jump to the end */3059if(fseek(logfp,0, SEEK_END) <0)3060returnerror("cannot seek back reflog for%s:%s",3061 refname,strerror(errno));3062 pos =ftell(logfp);3063while(!ret &&0< pos) {3064int cnt;3065size_t nread;3066char buf[BUFSIZ];3067char*endp, *scanp;30683069/* Fill next block from the end */3070 cnt = (sizeof(buf) < pos) ?sizeof(buf) : pos;3071if(fseek(logfp, pos - cnt, SEEK_SET))3072returnerror("cannot seek back reflog for%s:%s",3073 refname,strerror(errno));3074 nread =fread(buf, cnt,1, logfp);3075if(nread !=1)3076returnerror("cannot read%dbytes from reflog for%s:%s",3077 cnt, refname,strerror(errno));3078 pos -= cnt;30793080 scanp = endp = buf + cnt;3081if(at_tail && scanp[-1] =='\n')3082/* Looking at the final LF at the end of the file */3083 scanp--;3084 at_tail =0;30853086while(buf < scanp) {3087/*3088 * terminating LF of the previous line, or the beginning3089 * of the buffer.3090 */3091char*bp;30923093 bp =find_beginning_of_line(buf, scanp);30943095if(*bp !='\n') {3096strbuf_splice(&sb,0,0, buf, endp - buf);3097if(pos)3098break;/* need to fill another block */3099 scanp = buf -1;/* leave loop */3100}else{3101/*3102 * (bp + 1) thru endp is the beginning of the3103 * current line we have in sb3104 */3105strbuf_splice(&sb,0,0, bp +1, endp - (bp +1));3106 scanp = bp;3107 endp = bp +1;3108}3109 ret =show_one_reflog_ent(&sb, fn, cb_data);3110strbuf_reset(&sb);3111if(ret)3112break;3113}31143115}3116if(!ret && sb.len)3117 ret =show_one_reflog_ent(&sb, fn, cb_data);31183119fclose(logfp);3120strbuf_release(&sb);3121return ret;3122}31233124intfor_each_reflog_ent(const char*refname, each_reflog_ent_fn fn,void*cb_data)3125{3126FILE*logfp;3127struct strbuf sb = STRBUF_INIT;3128int ret =0;31293130 logfp =fopen(git_path("logs/%s", refname),"r");3131if(!logfp)3132return-1;31333134while(!ret && !strbuf_getwholeline(&sb, logfp,'\n'))3135 ret =show_one_reflog_ent(&sb, fn, cb_data);3136fclose(logfp);3137strbuf_release(&sb);3138return ret;3139}3140/*3141 * Call fn for each reflog in the namespace indicated by name. name3142 * must be empty or end with '/'. Name will be used as a scratch3143 * space, but its contents will be restored before return.3144 */3145static intdo_for_each_reflog(struct strbuf *name, each_ref_fn fn,void*cb_data)3146{3147DIR*d =opendir(git_path("logs/%s", name->buf));3148int retval =0;3149struct dirent *de;3150int oldlen = name->len;31513152if(!d)3153return name->len ? errno :0;31543155while((de =readdir(d)) != NULL) {3156struct stat st;31573158if(de->d_name[0] =='.')3159continue;3160if(has_extension(de->d_name,".lock"))3161continue;3162strbuf_addstr(name, de->d_name);3163if(stat(git_path("logs/%s", name->buf), &st) <0) {3164;/* silently ignore */3165}else{3166if(S_ISDIR(st.st_mode)) {3167strbuf_addch(name,'/');3168 retval =do_for_each_reflog(name, fn, cb_data);3169}else{3170unsigned char sha1[20];3171if(read_ref_full(name->buf, sha1,0, NULL))3172 retval =error("bad ref for%s", name->buf);3173else3174 retval =fn(name->buf, sha1,0, cb_data);3175}3176if(retval)3177break;3178}3179strbuf_setlen(name, oldlen);3180}3181closedir(d);3182return retval;3183}31843185intfor_each_reflog(each_ref_fn fn,void*cb_data)3186{3187int retval;3188struct strbuf name;3189strbuf_init(&name, PATH_MAX);3190 retval =do_for_each_reflog(&name, fn, cb_data);3191strbuf_release(&name);3192return retval;3193}31943195static struct ref_lock *update_ref_lock(const char*refname,3196const unsigned char*oldval,3197int flags,int*type_p,3198enum action_on_err onerr)3199{3200struct ref_lock *lock;3201 lock =lock_any_ref_for_update(refname, oldval, flags, type_p);3202if(!lock) {3203const char*str ="Cannot lock the ref '%s'.";3204switch(onerr) {3205case MSG_ON_ERR:error(str, refname);break;3206case DIE_ON_ERR:die(str, refname);break;3207case QUIET_ON_ERR:break;3208}3209}3210return lock;3211}32123213static intupdate_ref_write(const char*action,const char*refname,3214const unsigned char*sha1,struct ref_lock *lock,3215enum action_on_err onerr)3216{3217if(write_ref_sha1(lock, sha1, action) <0) {3218const char*str ="Cannot update the ref '%s'.";3219switch(onerr) {3220case MSG_ON_ERR:error(str, refname);break;3221case DIE_ON_ERR:die(str, refname);break;3222case QUIET_ON_ERR:break;3223}3224return1;3225}3226return0;3227}32283229intupdate_ref(const char*action,const char*refname,3230const unsigned char*sha1,const unsigned char*oldval,3231int flags,enum action_on_err onerr)3232{3233struct ref_lock *lock;3234 lock =update_ref_lock(refname, oldval, flags,0, onerr);3235if(!lock)3236return1;3237returnupdate_ref_write(action, refname, sha1, lock, onerr);3238}32393240static intref_update_compare(const void*r1,const void*r2)3241{3242const struct ref_update *const*u1 = r1;3243const struct ref_update *const*u2 = r2;3244returnstrcmp((*u1)->ref_name, (*u2)->ref_name);3245}32463247static intref_update_reject_duplicates(struct ref_update **updates,int n,3248enum action_on_err onerr)3249{3250int i;3251for(i =1; i < n; i++)3252if(!strcmp(updates[i -1]->ref_name, updates[i]->ref_name)) {3253const char*str =3254"Multiple updates for ref '%s' not allowed.";3255switch(onerr) {3256case MSG_ON_ERR:3257error(str, updates[i]->ref_name);break;3258case DIE_ON_ERR:3259die(str, updates[i]->ref_name);break;3260case QUIET_ON_ERR:3261break;3262}3263return1;3264}3265return0;3266}32673268intupdate_refs(const char*action,const struct ref_update **updates_orig,3269int n,enum action_on_err onerr)3270{3271int ret =0, delnum =0, i;3272struct ref_update **updates;3273int*types;3274struct ref_lock **locks;3275const char**delnames;32763277if(!updates_orig || !n)3278return0;32793280/* Allocate work space */3281 updates =xmalloc(sizeof(*updates) * n);3282 types =xmalloc(sizeof(*types) * n);3283 locks =xcalloc(n,sizeof(*locks));3284 delnames =xmalloc(sizeof(*delnames) * n);32853286/* Copy, sort, and reject duplicate refs */3287memcpy(updates, updates_orig,sizeof(*updates) * n);3288qsort(updates, n,sizeof(*updates), ref_update_compare);3289 ret =ref_update_reject_duplicates(updates, n, onerr);3290if(ret)3291goto cleanup;32923293/* Acquire all locks while verifying old values */3294for(i =0; i < n; i++) {3295 locks[i] =update_ref_lock(updates[i]->ref_name,3296(updates[i]->have_old ?3297 updates[i]->old_sha1 : NULL),3298 updates[i]->flags,3299&types[i], onerr);3300if(!locks[i]) {3301 ret =1;3302goto cleanup;3303}3304}33053306/* Perform updates first so live commits remain referenced */3307for(i =0; i < n; i++)3308if(!is_null_sha1(updates[i]->new_sha1)) {3309 ret =update_ref_write(action,3310 updates[i]->ref_name,3311 updates[i]->new_sha1,3312 locks[i], onerr);3313 locks[i] = NULL;/* freed by update_ref_write */3314if(ret)3315goto cleanup;3316}33173318/* Perform deletes now that updates are safely completed */3319for(i =0; i < n; i++)3320if(locks[i]) {3321 delnames[delnum++] = locks[i]->ref_name;3322 ret |=delete_ref_loose(locks[i], types[i]);3323}3324 ret |=repack_without_refs(delnames, delnum);3325for(i =0; i < delnum; i++)3326unlink_or_warn(git_path("logs/%s", delnames[i]));3327clear_loose_ref_cache(&ref_cache);33283329cleanup:3330for(i =0; i < n; i++)3331if(locks[i])3332unlock_ref(locks[i]);3333free(updates);3334free(types);3335free(locks);3336free(delnames);3337return ret;3338}33393340/*3341 * generate a format suitable for scanf from a ref_rev_parse_rules3342 * rule, that is replace the "%.*s" spec with a "%s" spec3343 */3344static voidgen_scanf_fmt(char*scanf_fmt,const char*rule)3345{3346char*spec;33473348 spec =strstr(rule,"%.*s");3349if(!spec ||strstr(spec +4,"%.*s"))3350die("invalid rule in ref_rev_parse_rules:%s", rule);33513352/* copy all until spec */3353strncpy(scanf_fmt, rule, spec - rule);3354 scanf_fmt[spec - rule] ='\0';3355/* copy new spec */3356strcat(scanf_fmt,"%s");3357/* copy remaining rule */3358strcat(scanf_fmt, spec +4);33593360return;3361}33623363char*shorten_unambiguous_ref(const char*refname,int strict)3364{3365int i;3366static char**scanf_fmts;3367static int nr_rules;3368char*short_name;33693370/* pre generate scanf formats from ref_rev_parse_rules[] */3371if(!nr_rules) {3372size_t total_len =0;33733374/* the rule list is NULL terminated, count them first */3375for(; ref_rev_parse_rules[nr_rules]; nr_rules++)3376/* no +1 because strlen("%s") < strlen("%.*s") */3377 total_len +=strlen(ref_rev_parse_rules[nr_rules]);33783379 scanf_fmts =xmalloc(nr_rules *sizeof(char*) + total_len);33803381 total_len =0;3382for(i =0; i < nr_rules; i++) {3383 scanf_fmts[i] = (char*)&scanf_fmts[nr_rules]3384+ total_len;3385gen_scanf_fmt(scanf_fmts[i], ref_rev_parse_rules[i]);3386 total_len +=strlen(ref_rev_parse_rules[i]);3387}3388}33893390/* bail out if there are no rules */3391if(!nr_rules)3392returnxstrdup(refname);33933394/* buffer for scanf result, at most refname must fit */3395 short_name =xstrdup(refname);33963397/* skip first rule, it will always match */3398for(i = nr_rules -1; i >0; --i) {3399int j;3400int rules_to_fail = i;3401int short_name_len;34023403if(1!=sscanf(refname, scanf_fmts[i], short_name))3404continue;34053406 short_name_len =strlen(short_name);34073408/*3409 * in strict mode, all (except the matched one) rules3410 * must fail to resolve to a valid non-ambiguous ref3411 */3412if(strict)3413 rules_to_fail = nr_rules;34143415/*3416 * check if the short name resolves to a valid ref,3417 * but use only rules prior to the matched one3418 */3419for(j =0; j < rules_to_fail; j++) {3420const char*rule = ref_rev_parse_rules[j];3421char refname[PATH_MAX];34223423/* skip matched rule */3424if(i == j)3425continue;34263427/*3428 * the short name is ambiguous, if it resolves3429 * (with this previous rule) to a valid ref3430 * read_ref() returns 0 on success3431 */3432mksnpath(refname,sizeof(refname),3433 rule, short_name_len, short_name);3434if(ref_exists(refname))3435break;3436}34373438/*3439 * short name is non-ambiguous if all previous rules3440 * haven't resolved to a valid ref3441 */3442if(j == rules_to_fail)3443return short_name;3444}34453446free(short_name);3447returnxstrdup(refname);3448}34493450static struct string_list *hide_refs;34513452intparse_hide_refs_config(const char*var,const char*value,const char*section)3453{3454if(!strcmp("transfer.hiderefs", var) ||3455/* NEEDSWORK: use parse_config_key() once both are merged */3456(!prefixcmp(var, section) && var[strlen(section)] =='.'&&3457!strcmp(var +strlen(section),".hiderefs"))) {3458char*ref;3459int len;34603461if(!value)3462returnconfig_error_nonbool(var);3463 ref =xstrdup(value);3464 len =strlen(ref);3465while(len && ref[len -1] =='/')3466 ref[--len] ='\0';3467if(!hide_refs) {3468 hide_refs =xcalloc(1,sizeof(*hide_refs));3469 hide_refs->strdup_strings =1;3470}3471string_list_append(hide_refs, ref);3472}3473return0;3474}34753476intref_is_hidden(const char*refname)3477{3478struct string_list_item *item;34793480if(!hide_refs)3481return0;3482for_each_string_list_item(item, hide_refs) {3483int len;3484if(prefixcmp(refname, item->string))3485continue;3486 len =strlen(item->string);3487if(!refname[len] || refname[len] =='/')3488return1;3489}3490return0;3491}