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 75if(!strcmp(refname,"@")) 76/* Refname is a single character '@'. */ 77return-1; 78 79while(1) { 80/* We are at the start of a path component. */ 81 component_len =check_refname_component(refname, flags); 82if(component_len <=0) { 83if((flags & REFNAME_REFSPEC_PATTERN) && 84 refname[0] =='*'&& 85(refname[1] =='\0'|| refname[1] =='/')) { 86/* Accept one wildcard as a full refname component. */ 87 flags &= ~REFNAME_REFSPEC_PATTERN; 88 component_len =1; 89}else{ 90return-1; 91} 92} 93 component_count++; 94if(refname[component_len] =='\0') 95break; 96/* Skip to next component. */ 97 refname += component_len +1; 98} 99 100if(refname[component_len -1] =='.') 101return-1;/* Refname ends with '.'. */ 102if(!(flags & REFNAME_ALLOW_ONELEVEL) && component_count <2) 103return-1;/* Refname has only one component. */ 104return0; 105} 106 107struct ref_entry; 108 109/* 110 * Information used (along with the information in ref_entry) to 111 * describe a single cached reference. This data structure only 112 * occurs embedded in a union in struct ref_entry, and only when 113 * (ref_entry->flag & REF_DIR) is zero. 114 */ 115struct ref_value { 116/* 117 * The name of the object to which this reference resolves 118 * (which may be a tag object). If REF_ISBROKEN, this is 119 * null. If REF_ISSYMREF, then this is the name of the object 120 * referred to by the last reference in the symlink chain. 121 */ 122unsigned char sha1[20]; 123 124/* 125 * If REF_KNOWS_PEELED, then this field holds the peeled value 126 * of this reference, or null if the reference is known not to 127 * be peelable. See the documentation for peel_ref() for an 128 * exact definition of "peelable". 129 */ 130unsigned char peeled[20]; 131}; 132 133struct ref_cache; 134 135/* 136 * Information used (along with the information in ref_entry) to 137 * describe a level in the hierarchy of references. This data 138 * structure only occurs embedded in a union in struct ref_entry, and 139 * only when (ref_entry.flag & REF_DIR) is set. In that case, 140 * (ref_entry.flag & REF_INCOMPLETE) determines whether the references 141 * in the directory have already been read: 142 * 143 * (ref_entry.flag & REF_INCOMPLETE) unset -- a directory of loose 144 * or packed references, already read. 145 * 146 * (ref_entry.flag & REF_INCOMPLETE) set -- a directory of loose 147 * references that hasn't been read yet (nor has any of its 148 * subdirectories). 149 * 150 * Entries within a directory are stored within a growable array of 151 * pointers to ref_entries (entries, nr, alloc). Entries 0 <= i < 152 * sorted are sorted by their component name in strcmp() order and the 153 * remaining entries are unsorted. 154 * 155 * Loose references are read lazily, one directory at a time. When a 156 * directory of loose references is read, then all of the references 157 * in that directory are stored, and REF_INCOMPLETE stubs are created 158 * for any subdirectories, but the subdirectories themselves are not 159 * read. The reading is triggered by get_ref_dir(). 160 */ 161struct ref_dir { 162int nr, alloc; 163 164/* 165 * Entries with index 0 <= i < sorted are sorted by name. New 166 * entries are appended to the list unsorted, and are sorted 167 * only when required; thus we avoid the need to sort the list 168 * after the addition of every reference. 169 */ 170int sorted; 171 172/* A pointer to the ref_cache that contains this ref_dir. */ 173struct ref_cache *ref_cache; 174 175struct ref_entry **entries; 176}; 177 178/* 179 * Bit values for ref_entry::flag. REF_ISSYMREF=0x01, 180 * REF_ISPACKED=0x02, and REF_ISBROKEN=0x04 are public values; see 181 * refs.h. 182 */ 183 184/* 185 * The field ref_entry->u.value.peeled of this value entry contains 186 * the correct peeled value for the reference, which might be 187 * null_sha1 if the reference is not a tag or if it is broken. 188 */ 189#define REF_KNOWS_PEELED 0x08 190 191/* ref_entry represents a directory of references */ 192#define REF_DIR 0x10 193 194/* 195 * Entry has not yet been read from disk (used only for REF_DIR 196 * entries representing loose references) 197 */ 198#define REF_INCOMPLETE 0x20 199 200/* 201 * A ref_entry represents either a reference or a "subdirectory" of 202 * references. 203 * 204 * Each directory in the reference namespace is represented by a 205 * ref_entry with (flags & REF_DIR) set and containing a subdir member 206 * that holds the entries in that directory that have been read so 207 * far. If (flags & REF_INCOMPLETE) is set, then the directory and 208 * its subdirectories haven't been read yet. REF_INCOMPLETE is only 209 * used for loose reference directories. 210 * 211 * References are represented by a ref_entry with (flags & REF_DIR) 212 * unset and a value member that describes the reference's value. The 213 * flag member is at the ref_entry level, but it is also needed to 214 * interpret the contents of the value field (in other words, a 215 * ref_value object is not very much use without the enclosing 216 * ref_entry). 217 * 218 * Reference names cannot end with slash and directories' names are 219 * always stored with a trailing slash (except for the top-level 220 * directory, which is always denoted by ""). This has two nice 221 * consequences: (1) when the entries in each subdir are sorted 222 * lexicographically by name (as they usually are), the references in 223 * a whole tree can be generated in lexicographic order by traversing 224 * the tree in left-to-right, depth-first order; (2) the names of 225 * references and subdirectories cannot conflict, and therefore the 226 * presence of an empty subdirectory does not block the creation of a 227 * similarly-named reference. (The fact that reference names with the 228 * same leading components can conflict *with each other* is a 229 * separate issue that is regulated by is_refname_available().) 230 * 231 * Please note that the name field contains the fully-qualified 232 * reference (or subdirectory) name. Space could be saved by only 233 * storing the relative names. But that would require the full names 234 * to be generated on the fly when iterating in do_for_each_ref(), and 235 * would break callback functions, who have always been able to assume 236 * that the name strings that they are passed will not be freed during 237 * the iteration. 238 */ 239struct ref_entry { 240unsigned char flag;/* ISSYMREF? ISPACKED? */ 241union{ 242struct ref_value value;/* if not (flags&REF_DIR) */ 243struct ref_dir subdir;/* if (flags&REF_DIR) */ 244} u; 245/* 246 * The full name of the reference (e.g., "refs/heads/master") 247 * or the full name of the directory with a trailing slash 248 * (e.g., "refs/heads/"): 249 */ 250char name[FLEX_ARRAY]; 251}; 252 253static voidread_loose_refs(const char*dirname,struct ref_dir *dir); 254 255static struct ref_dir *get_ref_dir(struct ref_entry *entry) 256{ 257struct ref_dir *dir; 258assert(entry->flag & REF_DIR); 259 dir = &entry->u.subdir; 260if(entry->flag & REF_INCOMPLETE) { 261read_loose_refs(entry->name, dir); 262 entry->flag &= ~REF_INCOMPLETE; 263} 264return dir; 265} 266 267static struct ref_entry *create_ref_entry(const char*refname, 268const unsigned char*sha1,int flag, 269int check_name) 270{ 271int len; 272struct ref_entry *ref; 273 274if(check_name && 275check_refname_format(refname, REFNAME_ALLOW_ONELEVEL|REFNAME_DOT_COMPONENT)) 276die("Reference has invalid format: '%s'", refname); 277 len =strlen(refname) +1; 278 ref =xmalloc(sizeof(struct ref_entry) + len); 279hashcpy(ref->u.value.sha1, sha1); 280hashclr(ref->u.value.peeled); 281memcpy(ref->name, refname, len); 282 ref->flag = flag; 283return ref; 284} 285 286static voidclear_ref_dir(struct ref_dir *dir); 287 288static voidfree_ref_entry(struct ref_entry *entry) 289{ 290if(entry->flag & REF_DIR) { 291/* 292 * Do not use get_ref_dir() here, as that might 293 * trigger the reading of loose refs. 294 */ 295clear_ref_dir(&entry->u.subdir); 296} 297free(entry); 298} 299 300/* 301 * Add a ref_entry to the end of dir (unsorted). Entry is always 302 * stored directly in dir; no recursion into subdirectories is 303 * done. 304 */ 305static voidadd_entry_to_dir(struct ref_dir *dir,struct ref_entry *entry) 306{ 307ALLOC_GROW(dir->entries, dir->nr +1, dir->alloc); 308 dir->entries[dir->nr++] = entry; 309/* optimize for the case that entries are added in order */ 310if(dir->nr ==1|| 311(dir->nr == dir->sorted +1&& 312strcmp(dir->entries[dir->nr -2]->name, 313 dir->entries[dir->nr -1]->name) <0)) 314 dir->sorted = dir->nr; 315} 316 317/* 318 * Clear and free all entries in dir, recursively. 319 */ 320static voidclear_ref_dir(struct ref_dir *dir) 321{ 322int i; 323for(i =0; i < dir->nr; i++) 324free_ref_entry(dir->entries[i]); 325free(dir->entries); 326 dir->sorted = dir->nr = dir->alloc =0; 327 dir->entries = NULL; 328} 329 330/* 331 * Create a struct ref_entry object for the specified dirname. 332 * dirname is the name of the directory with a trailing slash (e.g., 333 * "refs/heads/") or "" for the top-level directory. 334 */ 335static struct ref_entry *create_dir_entry(struct ref_cache *ref_cache, 336const char*dirname,size_t len, 337int incomplete) 338{ 339struct ref_entry *direntry; 340 direntry =xcalloc(1,sizeof(struct ref_entry) + len +1); 341memcpy(direntry->name, dirname, len); 342 direntry->name[len] ='\0'; 343 direntry->u.subdir.ref_cache = ref_cache; 344 direntry->flag = REF_DIR | (incomplete ? REF_INCOMPLETE :0); 345return direntry; 346} 347 348static intref_entry_cmp(const void*a,const void*b) 349{ 350struct ref_entry *one = *(struct ref_entry **)a; 351struct ref_entry *two = *(struct ref_entry **)b; 352returnstrcmp(one->name, two->name); 353} 354 355static voidsort_ref_dir(struct ref_dir *dir); 356 357struct string_slice { 358size_t len; 359const char*str; 360}; 361 362static intref_entry_cmp_sslice(const void*key_,const void*ent_) 363{ 364const struct string_slice *key = key_; 365const struct ref_entry *ent = *(const struct ref_entry *const*)ent_; 366int cmp =strncmp(key->str, ent->name, key->len); 367if(cmp) 368return cmp; 369return'\0'- (unsigned char)ent->name[key->len]; 370} 371 372/* 373 * Return the index of the entry with the given refname from the 374 * ref_dir (non-recursively), sorting dir if necessary. Return -1 if 375 * no such entry is found. dir must already be complete. 376 */ 377static intsearch_ref_dir(struct ref_dir *dir,const char*refname,size_t len) 378{ 379struct ref_entry **r; 380struct string_slice key; 381 382if(refname == NULL || !dir->nr) 383return-1; 384 385sort_ref_dir(dir); 386 key.len = len; 387 key.str = refname; 388 r =bsearch(&key, dir->entries, dir->nr,sizeof(*dir->entries), 389 ref_entry_cmp_sslice); 390 391if(r == NULL) 392return-1; 393 394return r - dir->entries; 395} 396 397/* 398 * Search for a directory entry directly within dir (without 399 * recursing). Sort dir if necessary. subdirname must be a directory 400 * name (i.e., end in '/'). If mkdir is set, then create the 401 * directory if it is missing; otherwise, return NULL if the desired 402 * directory cannot be found. dir must already be complete. 403 */ 404static struct ref_dir *search_for_subdir(struct ref_dir *dir, 405const char*subdirname,size_t len, 406int mkdir) 407{ 408int entry_index =search_ref_dir(dir, subdirname, len); 409struct ref_entry *entry; 410if(entry_index == -1) { 411if(!mkdir) 412return NULL; 413/* 414 * Since dir is complete, the absence of a subdir 415 * means that the subdir really doesn't exist; 416 * therefore, create an empty record for it but mark 417 * the record complete. 418 */ 419 entry =create_dir_entry(dir->ref_cache, subdirname, len,0); 420add_entry_to_dir(dir, entry); 421}else{ 422 entry = dir->entries[entry_index]; 423} 424returnget_ref_dir(entry); 425} 426 427/* 428 * If refname is a reference name, find the ref_dir within the dir 429 * tree that should hold refname. If refname is a directory name 430 * (i.e., ends in '/'), then return that ref_dir itself. dir must 431 * represent the top-level directory and must already be complete. 432 * Sort ref_dirs and recurse into subdirectories as necessary. If 433 * mkdir is set, then create any missing directories; otherwise, 434 * return NULL if the desired directory cannot be found. 435 */ 436static struct ref_dir *find_containing_dir(struct ref_dir *dir, 437const char*refname,int mkdir) 438{ 439const char*slash; 440for(slash =strchr(refname,'/'); slash; slash =strchr(slash +1,'/')) { 441size_t dirnamelen = slash - refname +1; 442struct ref_dir *subdir; 443 subdir =search_for_subdir(dir, refname, dirnamelen, mkdir); 444if(!subdir) { 445 dir = NULL; 446break; 447} 448 dir = subdir; 449} 450 451return dir; 452} 453 454/* 455 * Find the value entry with the given name in dir, sorting ref_dirs 456 * and recursing into subdirectories as necessary. If the name is not 457 * found or it corresponds to a directory entry, return NULL. 458 */ 459static struct ref_entry *find_ref(struct ref_dir *dir,const char*refname) 460{ 461int entry_index; 462struct ref_entry *entry; 463 dir =find_containing_dir(dir, refname,0); 464if(!dir) 465return NULL; 466 entry_index =search_ref_dir(dir, refname,strlen(refname)); 467if(entry_index == -1) 468return NULL; 469 entry = dir->entries[entry_index]; 470return(entry->flag & REF_DIR) ? NULL : entry; 471} 472 473/* 474 * Remove the entry with the given name from dir, recursing into 475 * subdirectories as necessary. If refname is the name of a directory 476 * (i.e., ends with '/'), then remove the directory and its contents. 477 * If the removal was successful, return the number of entries 478 * remaining in the directory entry that contained the deleted entry. 479 * If the name was not found, return -1. Please note that this 480 * function only deletes the entry from the cache; it does not delete 481 * it from the filesystem or ensure that other cache entries (which 482 * might be symbolic references to the removed entry) are updated. 483 * Nor does it remove any containing dir entries that might be made 484 * empty by the removal. dir must represent the top-level directory 485 * and must already be complete. 486 */ 487static intremove_entry(struct ref_dir *dir,const char*refname) 488{ 489int refname_len =strlen(refname); 490int entry_index; 491struct ref_entry *entry; 492int is_dir = refname[refname_len -1] =='/'; 493if(is_dir) { 494/* 495 * refname represents a reference directory. Remove 496 * the trailing slash; otherwise we will get the 497 * directory *representing* refname rather than the 498 * one *containing* it. 499 */ 500char*dirname =xmemdupz(refname, refname_len -1); 501 dir =find_containing_dir(dir, dirname,0); 502free(dirname); 503}else{ 504 dir =find_containing_dir(dir, refname,0); 505} 506if(!dir) 507return-1; 508 entry_index =search_ref_dir(dir, refname, refname_len); 509if(entry_index == -1) 510return-1; 511 entry = dir->entries[entry_index]; 512 513memmove(&dir->entries[entry_index], 514&dir->entries[entry_index +1], 515(dir->nr - entry_index -1) *sizeof(*dir->entries) 516); 517 dir->nr--; 518if(dir->sorted > entry_index) 519 dir->sorted--; 520free_ref_entry(entry); 521return dir->nr; 522} 523 524/* 525 * Add a ref_entry to the ref_dir (unsorted), recursing into 526 * subdirectories as necessary. dir must represent the top-level 527 * directory. Return 0 on success. 528 */ 529static intadd_ref(struct ref_dir *dir,struct ref_entry *ref) 530{ 531 dir =find_containing_dir(dir, ref->name,1); 532if(!dir) 533return-1; 534add_entry_to_dir(dir, ref); 535return0; 536} 537 538/* 539 * Emit a warning and return true iff ref1 and ref2 have the same name 540 * and the same sha1. Die if they have the same name but different 541 * sha1s. 542 */ 543static intis_dup_ref(const struct ref_entry *ref1,const struct ref_entry *ref2) 544{ 545if(strcmp(ref1->name, ref2->name)) 546return0; 547 548/* Duplicate name; make sure that they don't conflict: */ 549 550if((ref1->flag & REF_DIR) || (ref2->flag & REF_DIR)) 551/* This is impossible by construction */ 552die("Reference directory conflict:%s", ref1->name); 553 554if(hashcmp(ref1->u.value.sha1, ref2->u.value.sha1)) 555die("Duplicated ref, and SHA1s don't match:%s", ref1->name); 556 557warning("Duplicated ref:%s", ref1->name); 558return1; 559} 560 561/* 562 * Sort the entries in dir non-recursively (if they are not already 563 * sorted) and remove any duplicate entries. 564 */ 565static voidsort_ref_dir(struct ref_dir *dir) 566{ 567int i, j; 568struct ref_entry *last = NULL; 569 570/* 571 * This check also prevents passing a zero-length array to qsort(), 572 * which is a problem on some platforms. 573 */ 574if(dir->sorted == dir->nr) 575return; 576 577qsort(dir->entries, dir->nr,sizeof(*dir->entries), ref_entry_cmp); 578 579/* Remove any duplicates: */ 580for(i =0, j =0; j < dir->nr; j++) { 581struct ref_entry *entry = dir->entries[j]; 582if(last &&is_dup_ref(last, entry)) 583free_ref_entry(entry); 584else 585 last = dir->entries[i++] = entry; 586} 587 dir->sorted = dir->nr = i; 588} 589 590/* Include broken references in a do_for_each_ref*() iteration: */ 591#define DO_FOR_EACH_INCLUDE_BROKEN 0x01 592 593/* 594 * Return true iff the reference described by entry can be resolved to 595 * an object in the database. Emit a warning if the referred-to 596 * object does not exist. 597 */ 598static intref_resolves_to_object(struct ref_entry *entry) 599{ 600if(entry->flag & REF_ISBROKEN) 601return0; 602if(!has_sha1_file(entry->u.value.sha1)) { 603error("%sdoes not point to a valid object!", entry->name); 604return0; 605} 606return1; 607} 608 609/* 610 * current_ref is a performance hack: when iterating over references 611 * using the for_each_ref*() functions, current_ref is set to the 612 * current reference's entry before calling the callback function. If 613 * the callback function calls peel_ref(), then peel_ref() first 614 * checks whether the reference to be peeled is the current reference 615 * (it usually is) and if so, returns that reference's peeled version 616 * if it is available. This avoids a refname lookup in a common case. 617 */ 618static struct ref_entry *current_ref; 619 620typedefinteach_ref_entry_fn(struct ref_entry *entry,void*cb_data); 621 622struct ref_entry_cb { 623const char*base; 624int trim; 625int flags; 626 each_ref_fn *fn; 627void*cb_data; 628}; 629 630/* 631 * Handle one reference in a do_for_each_ref*()-style iteration, 632 * calling an each_ref_fn for each entry. 633 */ 634static intdo_one_ref(struct ref_entry *entry,void*cb_data) 635{ 636struct ref_entry_cb *data = cb_data; 637int retval; 638if(prefixcmp(entry->name, data->base)) 639return0; 640 641if(!(data->flags & DO_FOR_EACH_INCLUDE_BROKEN) && 642!ref_resolves_to_object(entry)) 643return0; 644 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 = NULL; 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}12971298const char*resolve_ref_unsafe(const char*refname,unsigned char*sha1,int reading,int*flag)1299{1300int depth = MAXDEPTH;1301 ssize_t len;1302char buffer[256];1303static char refname_buffer[256];13041305if(flag)1306*flag =0;13071308if(check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))1309return NULL;13101311for(;;) {1312char path[PATH_MAX];1313struct stat st;1314char*buf;1315int fd;13161317if(--depth <0)1318return NULL;13191320git_snpath(path,sizeof(path),"%s", refname);13211322if(lstat(path, &st) <0) {1323struct ref_entry *entry;13241325if(errno != ENOENT)1326return NULL;1327/*1328 * The loose reference file does not exist;1329 * check for a packed reference.1330 */1331 entry =get_packed_ref(refname);1332if(entry) {1333hashcpy(sha1, entry->u.value.sha1);1334if(flag)1335*flag |= REF_ISPACKED;1336return refname;1337}1338/* The reference is not a packed reference, either. */1339if(reading) {1340return NULL;1341}else{1342hashclr(sha1);1343return refname;1344}1345}13461347/* Follow "normalized" - ie "refs/.." symlinks by hand */1348if(S_ISLNK(st.st_mode)) {1349 len =readlink(path, buffer,sizeof(buffer)-1);1350if(len <0)1351return NULL;1352 buffer[len] =0;1353if(!prefixcmp(buffer,"refs/") &&1354!check_refname_format(buffer,0)) {1355strcpy(refname_buffer, buffer);1356 refname = refname_buffer;1357if(flag)1358*flag |= REF_ISSYMREF;1359continue;1360}1361}13621363/* Is it a directory? */1364if(S_ISDIR(st.st_mode)) {1365 errno = EISDIR;1366return NULL;1367}13681369/*1370 * Anything else, just open it and try to use it as1371 * a ref1372 */1373 fd =open(path, O_RDONLY);1374if(fd <0)1375return NULL;1376 len =read_in_full(fd, buffer,sizeof(buffer)-1);1377close(fd);1378if(len <0)1379return NULL;1380while(len &&isspace(buffer[len-1]))1381 len--;1382 buffer[len] ='\0';13831384/*1385 * Is it a symbolic ref?1386 */1387if(prefixcmp(buffer,"ref:"))1388break;1389if(flag)1390*flag |= REF_ISSYMREF;1391 buf = buffer +4;1392while(isspace(*buf))1393 buf++;1394if(check_refname_format(buf, REFNAME_ALLOW_ONELEVEL)) {1395if(flag)1396*flag |= REF_ISBROKEN;1397return NULL;1398}1399 refname =strcpy(refname_buffer, buf);1400}1401/* Please note that FETCH_HEAD has a second line containing other data. */1402if(get_sha1_hex(buffer, sha1) || (buffer[40] !='\0'&& !isspace(buffer[40]))) {1403if(flag)1404*flag |= REF_ISBROKEN;1405return NULL;1406}1407return refname;1408}14091410char*resolve_refdup(const char*ref,unsigned char*sha1,int reading,int*flag)1411{1412const char*ret =resolve_ref_unsafe(ref, sha1, reading, flag);1413return ret ?xstrdup(ret) : NULL;1414}14151416/* The argument to filter_refs */1417struct ref_filter {1418const char*pattern;1419 each_ref_fn *fn;1420void*cb_data;1421};14221423intread_ref_full(const char*refname,unsigned char*sha1,int reading,int*flags)1424{1425if(resolve_ref_unsafe(refname, sha1, reading, flags))1426return0;1427return-1;1428}14291430intread_ref(const char*refname,unsigned char*sha1)1431{1432returnread_ref_full(refname, sha1,1, NULL);1433}14341435intref_exists(const char*refname)1436{1437unsigned char sha1[20];1438return!!resolve_ref_unsafe(refname, sha1,1, NULL);1439}14401441static intfilter_refs(const char*refname,const unsigned char*sha1,int flags,1442void*data)1443{1444struct ref_filter *filter = (struct ref_filter *)data;1445if(fnmatch(filter->pattern, refname,0))1446return0;1447return filter->fn(refname, sha1, flags, filter->cb_data);1448}14491450enum peel_status {1451/* object was peeled successfully: */1452 PEEL_PEELED =0,14531454/*1455 * object cannot be peeled because the named object (or an1456 * object referred to by a tag in the peel chain), does not1457 * exist.1458 */1459 PEEL_INVALID = -1,14601461/* object cannot be peeled because it is not a tag: */1462 PEEL_NON_TAG = -2,14631464/* ref_entry contains no peeled value because it is a symref: */1465 PEEL_IS_SYMREF = -3,14661467/*1468 * ref_entry cannot be peeled because it is broken (i.e., the1469 * symbolic reference cannot even be resolved to an object1470 * name):1471 */1472 PEEL_BROKEN = -41473};14741475/*1476 * Peel the named object; i.e., if the object is a tag, resolve the1477 * tag recursively until a non-tag is found. If successful, store the1478 * result to sha1 and return PEEL_PEELED. If the object is not a tag1479 * or is not valid, return PEEL_NON_TAG or PEEL_INVALID, respectively,1480 * and leave sha1 unchanged.1481 */1482static enum peel_status peel_object(const unsigned char*name,unsigned char*sha1)1483{1484struct object *o =lookup_unknown_object(name);14851486if(o->type == OBJ_NONE) {1487int type =sha1_object_info(name, NULL);1488if(type <0)1489return PEEL_INVALID;1490 o->type = type;1491}14921493if(o->type != OBJ_TAG)1494return PEEL_NON_TAG;14951496 o =deref_tag_noverify(o);1497if(!o)1498return PEEL_INVALID;14991500hashcpy(sha1, o->sha1);1501return PEEL_PEELED;1502}15031504/*1505 * Peel the entry (if possible) and return its new peel_status. If1506 * repeel is true, re-peel the entry even if there is an old peeled1507 * value that is already stored in it.1508 *1509 * It is OK to call this function with a packed reference entry that1510 * might be stale and might even refer to an object that has since1511 * been garbage-collected. In such a case, if the entry has1512 * REF_KNOWS_PEELED then leave the status unchanged and return1513 * PEEL_PEELED or PEEL_NON_TAG; otherwise, return PEEL_INVALID.1514 */1515static enum peel_status peel_entry(struct ref_entry *entry,int repeel)1516{1517enum peel_status status;15181519if(entry->flag & REF_KNOWS_PEELED) {1520if(repeel) {1521 entry->flag &= ~REF_KNOWS_PEELED;1522hashclr(entry->u.value.peeled);1523}else{1524returnis_null_sha1(entry->u.value.peeled) ?1525 PEEL_NON_TAG : PEEL_PEELED;1526}1527}1528if(entry->flag & REF_ISBROKEN)1529return PEEL_BROKEN;1530if(entry->flag & REF_ISSYMREF)1531return PEEL_IS_SYMREF;15321533 status =peel_object(entry->u.value.sha1, entry->u.value.peeled);1534if(status == PEEL_PEELED || status == PEEL_NON_TAG)1535 entry->flag |= REF_KNOWS_PEELED;1536return status;1537}15381539intpeel_ref(const char*refname,unsigned char*sha1)1540{1541int flag;1542unsigned char base[20];15431544if(current_ref && (current_ref->name == refname1545|| !strcmp(current_ref->name, refname))) {1546if(peel_entry(current_ref,0))1547return-1;1548hashcpy(sha1, current_ref->u.value.peeled);1549return0;1550}15511552if(read_ref_full(refname, base,1, &flag))1553return-1;15541555/*1556 * If the reference is packed, read its ref_entry from the1557 * cache in the hope that we already know its peeled value.1558 * We only try this optimization on packed references because1559 * (a) forcing the filling of the loose reference cache could1560 * be expensive and (b) loose references anyway usually do not1561 * have REF_KNOWS_PEELED.1562 */1563if(flag & REF_ISPACKED) {1564struct ref_entry *r =get_packed_ref(refname);1565if(r) {1566if(peel_entry(r,0))1567return-1;1568hashcpy(sha1, r->u.value.peeled);1569return0;1570}1571}15721573returnpeel_object(base, sha1);1574}15751576struct warn_if_dangling_data {1577FILE*fp;1578const char*refname;1579const char*msg_fmt;1580};15811582static intwarn_if_dangling_symref(const char*refname,const unsigned char*sha1,1583int flags,void*cb_data)1584{1585struct warn_if_dangling_data *d = cb_data;1586const char*resolves_to;1587unsigned char junk[20];15881589if(!(flags & REF_ISSYMREF))1590return0;15911592 resolves_to =resolve_ref_unsafe(refname, junk,0, NULL);1593if(!resolves_to ||strcmp(resolves_to, d->refname))1594return0;15951596fprintf(d->fp, d->msg_fmt, refname);1597fputc('\n', d->fp);1598return0;1599}16001601voidwarn_dangling_symref(FILE*fp,const char*msg_fmt,const char*refname)1602{1603struct warn_if_dangling_data data;16041605 data.fp = fp;1606 data.refname = refname;1607 data.msg_fmt = msg_fmt;1608for_each_rawref(warn_if_dangling_symref, &data);1609}16101611/*1612 * Call fn for each reference in the specified ref_cache, omitting1613 * references not in the containing_dir of base. fn is called for all1614 * references, including broken ones. If fn ever returns a non-zero1615 * value, stop the iteration and return that value; otherwise, return1616 * 0.1617 */1618static intdo_for_each_entry(struct ref_cache *refs,const char*base,1619 each_ref_entry_fn fn,void*cb_data)1620{1621struct packed_ref_cache *packed_ref_cache;1622struct ref_dir *loose_dir;1623struct ref_dir *packed_dir;1624int retval =0;16251626/*1627 * We must make sure that all loose refs are read before accessing the1628 * packed-refs file; this avoids a race condition in which loose refs1629 * are migrated to the packed-refs file by a simultaneous process, but1630 * our in-memory view is from before the migration. get_packed_ref_cache()1631 * takes care of making sure our view is up to date with what is on1632 * disk.1633 */1634 loose_dir =get_loose_refs(refs);1635if(base && *base) {1636 loose_dir =find_containing_dir(loose_dir, base,0);1637}1638if(loose_dir)1639prime_ref_dir(loose_dir);16401641 packed_ref_cache =get_packed_ref_cache(refs);1642acquire_packed_ref_cache(packed_ref_cache);1643 packed_dir =get_packed_ref_dir(packed_ref_cache);1644if(base && *base) {1645 packed_dir =find_containing_dir(packed_dir, base,0);1646}16471648if(packed_dir && loose_dir) {1649sort_ref_dir(packed_dir);1650sort_ref_dir(loose_dir);1651 retval =do_for_each_entry_in_dirs(1652 packed_dir, loose_dir, fn, cb_data);1653}else if(packed_dir) {1654sort_ref_dir(packed_dir);1655 retval =do_for_each_entry_in_dir(1656 packed_dir,0, fn, cb_data);1657}else if(loose_dir) {1658sort_ref_dir(loose_dir);1659 retval =do_for_each_entry_in_dir(1660 loose_dir,0, fn, cb_data);1661}16621663release_packed_ref_cache(packed_ref_cache);1664return retval;1665}16661667/*1668 * Call fn for each reference in the specified ref_cache for which the1669 * refname begins with base. If trim is non-zero, then trim that many1670 * characters off the beginning of each refname before passing the1671 * refname to fn. flags can be DO_FOR_EACH_INCLUDE_BROKEN to include1672 * broken references in the iteration. If fn ever returns a non-zero1673 * value, stop the iteration and return that value; otherwise, return1674 * 0.1675 */1676static intdo_for_each_ref(struct ref_cache *refs,const char*base,1677 each_ref_fn fn,int trim,int flags,void*cb_data)1678{1679struct ref_entry_cb data;1680 data.base = base;1681 data.trim = trim;1682 data.flags = flags;1683 data.fn = fn;1684 data.cb_data = cb_data;16851686returndo_for_each_entry(refs, base, do_one_ref, &data);1687}16881689static intdo_head_ref(const char*submodule, each_ref_fn fn,void*cb_data)1690{1691unsigned char sha1[20];1692int flag;16931694if(submodule) {1695if(resolve_gitlink_ref(submodule,"HEAD", sha1) ==0)1696returnfn("HEAD", sha1,0, cb_data);16971698return0;1699}17001701if(!read_ref_full("HEAD", sha1,1, &flag))1702returnfn("HEAD", sha1, flag, cb_data);17031704return0;1705}17061707inthead_ref(each_ref_fn fn,void*cb_data)1708{1709returndo_head_ref(NULL, fn, cb_data);1710}17111712inthead_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1713{1714returndo_head_ref(submodule, fn, cb_data);1715}17161717intfor_each_ref(each_ref_fn fn,void*cb_data)1718{1719returndo_for_each_ref(&ref_cache,"", fn,0,0, cb_data);1720}17211722intfor_each_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1723{1724returndo_for_each_ref(get_ref_cache(submodule),"", fn,0,0, cb_data);1725}17261727intfor_each_ref_in(const char*prefix, each_ref_fn fn,void*cb_data)1728{1729returndo_for_each_ref(&ref_cache, prefix, fn,strlen(prefix),0, cb_data);1730}17311732intfor_each_ref_in_submodule(const char*submodule,const char*prefix,1733 each_ref_fn fn,void*cb_data)1734{1735returndo_for_each_ref(get_ref_cache(submodule), prefix, fn,strlen(prefix),0, cb_data);1736}17371738intfor_each_tag_ref(each_ref_fn fn,void*cb_data)1739{1740returnfor_each_ref_in("refs/tags/", fn, cb_data);1741}17421743intfor_each_tag_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1744{1745returnfor_each_ref_in_submodule(submodule,"refs/tags/", fn, cb_data);1746}17471748intfor_each_branch_ref(each_ref_fn fn,void*cb_data)1749{1750returnfor_each_ref_in("refs/heads/", fn, cb_data);1751}17521753intfor_each_branch_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1754{1755returnfor_each_ref_in_submodule(submodule,"refs/heads/", fn, cb_data);1756}17571758intfor_each_remote_ref(each_ref_fn fn,void*cb_data)1759{1760returnfor_each_ref_in("refs/remotes/", fn, cb_data);1761}17621763intfor_each_remote_ref_submodule(const char*submodule, each_ref_fn fn,void*cb_data)1764{1765returnfor_each_ref_in_submodule(submodule,"refs/remotes/", fn, cb_data);1766}17671768intfor_each_replace_ref(each_ref_fn fn,void*cb_data)1769{1770returndo_for_each_ref(&ref_cache,"refs/replace/", fn,13,0, cb_data);1771}17721773inthead_ref_namespaced(each_ref_fn fn,void*cb_data)1774{1775struct strbuf buf = STRBUF_INIT;1776int ret =0;1777unsigned char sha1[20];1778int flag;17791780strbuf_addf(&buf,"%sHEAD",get_git_namespace());1781if(!read_ref_full(buf.buf, sha1,1, &flag))1782 ret =fn(buf.buf, sha1, flag, cb_data);1783strbuf_release(&buf);17841785return ret;1786}17871788intfor_each_namespaced_ref(each_ref_fn fn,void*cb_data)1789{1790struct strbuf buf = STRBUF_INIT;1791int ret;1792strbuf_addf(&buf,"%srefs/",get_git_namespace());1793 ret =do_for_each_ref(&ref_cache, buf.buf, fn,0,0, cb_data);1794strbuf_release(&buf);1795return ret;1796}17971798intfor_each_glob_ref_in(each_ref_fn fn,const char*pattern,1799const char*prefix,void*cb_data)1800{1801struct strbuf real_pattern = STRBUF_INIT;1802struct ref_filter filter;1803int ret;18041805if(!prefix &&prefixcmp(pattern,"refs/"))1806strbuf_addstr(&real_pattern,"refs/");1807else if(prefix)1808strbuf_addstr(&real_pattern, prefix);1809strbuf_addstr(&real_pattern, pattern);18101811if(!has_glob_specials(pattern)) {1812/* Append implied '/' '*' if not present. */1813if(real_pattern.buf[real_pattern.len -1] !='/')1814strbuf_addch(&real_pattern,'/');1815/* No need to check for '*', there is none. */1816strbuf_addch(&real_pattern,'*');1817}18181819 filter.pattern = real_pattern.buf;1820 filter.fn = fn;1821 filter.cb_data = cb_data;1822 ret =for_each_ref(filter_refs, &filter);18231824strbuf_release(&real_pattern);1825return ret;1826}18271828intfor_each_glob_ref(each_ref_fn fn,const char*pattern,void*cb_data)1829{1830returnfor_each_glob_ref_in(fn, pattern, NULL, cb_data);1831}18321833intfor_each_rawref(each_ref_fn fn,void*cb_data)1834{1835returndo_for_each_ref(&ref_cache,"", fn,0,1836 DO_FOR_EACH_INCLUDE_BROKEN, cb_data);1837}18381839const char*prettify_refname(const char*name)1840{1841return name + (1842!prefixcmp(name,"refs/heads/") ?11:1843!prefixcmp(name,"refs/tags/") ?10:1844!prefixcmp(name,"refs/remotes/") ?13:18450);1846}18471848const char*ref_rev_parse_rules[] = {1849"%.*s",1850"refs/%.*s",1851"refs/tags/%.*s",1852"refs/heads/%.*s",1853"refs/remotes/%.*s",1854"refs/remotes/%.*s/HEAD",1855 NULL1856};18571858intrefname_match(const char*abbrev_name,const char*full_name,const char**rules)1859{1860const char**p;1861const int abbrev_name_len =strlen(abbrev_name);18621863for(p = rules; *p; p++) {1864if(!strcmp(full_name,mkpath(*p, abbrev_name_len, abbrev_name))) {1865return1;1866}1867}18681869return0;1870}18711872static struct ref_lock *verify_lock(struct ref_lock *lock,1873const unsigned char*old_sha1,int mustexist)1874{1875if(read_ref_full(lock->ref_name, lock->old_sha1, mustexist, NULL)) {1876error("Can't verify ref%s", lock->ref_name);1877unlock_ref(lock);1878return NULL;1879}1880if(hashcmp(lock->old_sha1, old_sha1)) {1881error("Ref%sis at%sbut expected%s", lock->ref_name,1882sha1_to_hex(lock->old_sha1),sha1_to_hex(old_sha1));1883unlock_ref(lock);1884return NULL;1885}1886return lock;1887}18881889static intremove_empty_directories(const char*file)1890{1891/* we want to create a file but there is a directory there;1892 * if that is an empty directory (or a directory that contains1893 * only empty directories), remove them.1894 */1895struct strbuf path;1896int result;18971898strbuf_init(&path,20);1899strbuf_addstr(&path, file);19001901 result =remove_dir_recursively(&path, REMOVE_DIR_EMPTY_ONLY);19021903strbuf_release(&path);19041905return result;1906}19071908/*1909 * *string and *len will only be substituted, and *string returned (for1910 * later free()ing) if the string passed in is a magic short-hand form1911 * to name a branch.1912 */1913static char*substitute_branch_name(const char**string,int*len)1914{1915struct strbuf buf = STRBUF_INIT;1916int ret =interpret_branch_name(*string, &buf);19171918if(ret == *len) {1919size_t size;1920*string =strbuf_detach(&buf, &size);1921*len = size;1922return(char*)*string;1923}19241925return NULL;1926}19271928intdwim_ref(const char*str,int len,unsigned char*sha1,char**ref)1929{1930char*last_branch =substitute_branch_name(&str, &len);1931const char**p, *r;1932int refs_found =0;19331934*ref = NULL;1935for(p = ref_rev_parse_rules; *p; p++) {1936char fullref[PATH_MAX];1937unsigned char sha1_from_ref[20];1938unsigned char*this_result;1939int flag;19401941 this_result = refs_found ? sha1_from_ref : sha1;1942mksnpath(fullref,sizeof(fullref), *p, len, str);1943 r =resolve_ref_unsafe(fullref, this_result,1, &flag);1944if(r) {1945if(!refs_found++)1946*ref =xstrdup(r);1947if(!warn_ambiguous_refs)1948break;1949}else if((flag & REF_ISSYMREF) &&strcmp(fullref,"HEAD")) {1950warning("ignoring dangling symref%s.", fullref);1951}else if((flag & REF_ISBROKEN) &&strchr(fullref,'/')) {1952warning("ignoring broken ref%s.", fullref);1953}1954}1955free(last_branch);1956return refs_found;1957}19581959intdwim_log(const char*str,int len,unsigned char*sha1,char**log)1960{1961char*last_branch =substitute_branch_name(&str, &len);1962const char**p;1963int logs_found =0;19641965*log = NULL;1966for(p = ref_rev_parse_rules; *p; p++) {1967struct stat st;1968unsigned char hash[20];1969char path[PATH_MAX];1970const char*ref, *it;19711972mksnpath(path,sizeof(path), *p, len, str);1973 ref =resolve_ref_unsafe(path, hash,1, NULL);1974if(!ref)1975continue;1976if(!stat(git_path("logs/%s", path), &st) &&1977S_ISREG(st.st_mode))1978 it = path;1979else if(strcmp(ref, path) &&1980!stat(git_path("logs/%s", ref), &st) &&1981S_ISREG(st.st_mode))1982 it = ref;1983else1984continue;1985if(!logs_found++) {1986*log =xstrdup(it);1987hashcpy(sha1, hash);1988}1989if(!warn_ambiguous_refs)1990break;1991}1992free(last_branch);1993return logs_found;1994}19951996static struct ref_lock *lock_ref_sha1_basic(const char*refname,1997const unsigned char*old_sha1,1998int flags,int*type_p)1999{2000char*ref_file;2001const char*orig_refname = refname;2002struct ref_lock *lock;2003int last_errno =0;2004int type, lflags;2005int mustexist = (old_sha1 && !is_null_sha1(old_sha1));2006int missing =0;20072008 lock =xcalloc(1,sizeof(struct ref_lock));2009 lock->lock_fd = -1;20102011 refname =resolve_ref_unsafe(refname, lock->old_sha1, mustexist, &type);2012if(!refname && errno == EISDIR) {2013/* we are trying to lock foo but we used to2014 * have foo/bar which now does not exist;2015 * it is normal for the empty directory 'foo'2016 * to remain.2017 */2018 ref_file =git_path("%s", orig_refname);2019if(remove_empty_directories(ref_file)) {2020 last_errno = errno;2021error("there are still refs under '%s'", orig_refname);2022goto error_return;2023}2024 refname =resolve_ref_unsafe(orig_refname, lock->old_sha1, mustexist, &type);2025}2026if(type_p)2027*type_p = type;2028if(!refname) {2029 last_errno = errno;2030error("unable to resolve reference%s:%s",2031 orig_refname,strerror(errno));2032goto error_return;2033}2034 missing =is_null_sha1(lock->old_sha1);2035/* When the ref did not exist and we are creating it,2036 * make sure there is no existing ref that is packed2037 * whose name begins with our refname, nor a ref whose2038 * name is a proper prefix of our refname.2039 */2040if(missing &&2041!is_refname_available(refname, NULL,get_packed_refs(&ref_cache))) {2042 last_errno = ENOTDIR;2043goto error_return;2044}20452046 lock->lk =xcalloc(1,sizeof(struct lock_file));20472048 lflags = LOCK_DIE_ON_ERROR;2049if(flags & REF_NODEREF) {2050 refname = orig_refname;2051 lflags |= LOCK_NODEREF;2052}2053 lock->ref_name =xstrdup(refname);2054 lock->orig_ref_name =xstrdup(orig_refname);2055 ref_file =git_path("%s", refname);2056if(missing)2057 lock->force_write =1;2058if((flags & REF_NODEREF) && (type & REF_ISSYMREF))2059 lock->force_write =1;20602061if(safe_create_leading_directories(ref_file)) {2062 last_errno = errno;2063error("unable to create directory for%s", ref_file);2064goto error_return;2065}20662067 lock->lock_fd =hold_lock_file_for_update(lock->lk, ref_file, lflags);2068return old_sha1 ?verify_lock(lock, old_sha1, mustexist) : lock;20692070 error_return:2071unlock_ref(lock);2072 errno = last_errno;2073return NULL;2074}20752076struct ref_lock *lock_ref_sha1(const char*refname,const unsigned char*old_sha1)2077{2078char refpath[PATH_MAX];2079if(check_refname_format(refname,0))2080return NULL;2081strcpy(refpath,mkpath("refs/%s", refname));2082returnlock_ref_sha1_basic(refpath, old_sha1,0, NULL);2083}20842085struct ref_lock *lock_any_ref_for_update(const char*refname,2086const unsigned char*old_sha1,int flags)2087{2088if(check_refname_format(refname, REFNAME_ALLOW_ONELEVEL))2089return NULL;2090returnlock_ref_sha1_basic(refname, old_sha1, flags, NULL);2091}20922093/*2094 * Write an entry to the packed-refs file for the specified refname.2095 * If peeled is non-NULL, write it as the entry's peeled value.2096 */2097static voidwrite_packed_entry(int fd,char*refname,unsigned char*sha1,2098unsigned char*peeled)2099{2100char line[PATH_MAX +100];2101int len;21022103 len =snprintf(line,sizeof(line),"%s %s\n",2104sha1_to_hex(sha1), refname);2105/* this should not happen but just being defensive */2106if(len >sizeof(line))2107die("too long a refname '%s'", refname);2108write_or_die(fd, line, len);21092110if(peeled) {2111if(snprintf(line,sizeof(line),"^%s\n",2112sha1_to_hex(peeled)) != PEELED_LINE_LENGTH)2113die("internal error");2114write_or_die(fd, line, PEELED_LINE_LENGTH);2115}2116}21172118/*2119 * An each_ref_entry_fn that writes the entry to a packed-refs file.2120 */2121static intwrite_packed_entry_fn(struct ref_entry *entry,void*cb_data)2122{2123int*fd = cb_data;2124enum peel_status peel_status =peel_entry(entry,0);21252126if(peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2127error("internal error:%sis not a valid packed reference!",2128 entry->name);2129write_packed_entry(*fd, entry->name, entry->u.value.sha1,2130 peel_status == PEEL_PEELED ?2131 entry->u.value.peeled : NULL);2132return0;2133}21342135intlock_packed_refs(int flags)2136{2137struct packed_ref_cache *packed_ref_cache;21382139/* Discard the old cache because it might be invalid: */2140clear_packed_ref_cache(&ref_cache);2141if(hold_lock_file_for_update(&packlock,git_path("packed-refs"), flags) <0)2142return-1;2143/* Read the current packed-refs while holding the lock: */2144 packed_ref_cache =get_packed_ref_cache(&ref_cache);2145 packed_ref_cache->lock = &packlock;2146/* Increment the reference count to prevent it from being freed: */2147acquire_packed_ref_cache(packed_ref_cache);2148return0;2149}21502151intcommit_packed_refs(void)2152{2153struct packed_ref_cache *packed_ref_cache =2154get_packed_ref_cache(&ref_cache);2155int error =0;21562157if(!packed_ref_cache->lock)2158die("internal error: packed-refs not locked");2159write_or_die(packed_ref_cache->lock->fd,2160 PACKED_REFS_HEADER,strlen(PACKED_REFS_HEADER));21612162do_for_each_entry_in_dir(get_packed_ref_dir(packed_ref_cache),21630, write_packed_entry_fn,2164&packed_ref_cache->lock->fd);2165if(commit_lock_file(packed_ref_cache->lock))2166 error = -1;2167 packed_ref_cache->lock = NULL;2168release_packed_ref_cache(packed_ref_cache);2169return error;2170}21712172voidrollback_packed_refs(void)2173{2174struct packed_ref_cache *packed_ref_cache =2175get_packed_ref_cache(&ref_cache);21762177if(!packed_ref_cache->lock)2178die("internal error: packed-refs not locked");2179rollback_lock_file(packed_ref_cache->lock);2180 packed_ref_cache->lock = NULL;2181release_packed_ref_cache(packed_ref_cache);2182clear_packed_ref_cache(&ref_cache);2183}21842185struct ref_to_prune {2186struct ref_to_prune *next;2187unsigned char sha1[20];2188char name[FLEX_ARRAY];2189};21902191struct pack_refs_cb_data {2192unsigned int flags;2193struct ref_dir *packed_refs;2194struct ref_to_prune *ref_to_prune;2195};21962197/*2198 * An each_ref_entry_fn that is run over loose references only. If2199 * the loose reference can be packed, add an entry in the packed ref2200 * cache. If the reference should be pruned, also add it to2201 * ref_to_prune in the pack_refs_cb_data.2202 */2203static intpack_if_possible_fn(struct ref_entry *entry,void*cb_data)2204{2205struct pack_refs_cb_data *cb = cb_data;2206enum peel_status peel_status;2207struct ref_entry *packed_entry;2208int is_tag_ref = !prefixcmp(entry->name,"refs/tags/");22092210/* ALWAYS pack tags */2211if(!(cb->flags & PACK_REFS_ALL) && !is_tag_ref)2212return0;22132214/* Do not pack symbolic or broken refs: */2215if((entry->flag & REF_ISSYMREF) || !ref_resolves_to_object(entry))2216return0;22172218/* Add a packed ref cache entry equivalent to the loose entry. */2219 peel_status =peel_entry(entry,1);2220if(peel_status != PEEL_PEELED && peel_status != PEEL_NON_TAG)2221die("internal error peeling reference%s(%s)",2222 entry->name,sha1_to_hex(entry->u.value.sha1));2223 packed_entry =find_ref(cb->packed_refs, entry->name);2224if(packed_entry) {2225/* Overwrite existing packed entry with info from loose entry */2226 packed_entry->flag = REF_ISPACKED | REF_KNOWS_PEELED;2227hashcpy(packed_entry->u.value.sha1, entry->u.value.sha1);2228}else{2229 packed_entry =create_ref_entry(entry->name, entry->u.value.sha1,2230 REF_ISPACKED | REF_KNOWS_PEELED,0);2231add_ref(cb->packed_refs, packed_entry);2232}2233hashcpy(packed_entry->u.value.peeled, entry->u.value.peeled);22342235/* Schedule the loose reference for pruning if requested. */2236if((cb->flags & PACK_REFS_PRUNE)) {2237int namelen =strlen(entry->name) +1;2238struct ref_to_prune *n =xcalloc(1,sizeof(*n) + namelen);2239hashcpy(n->sha1, entry->u.value.sha1);2240strcpy(n->name, entry->name);2241 n->next = cb->ref_to_prune;2242 cb->ref_to_prune = n;2243}2244return0;2245}22462247/*2248 * Remove empty parents, but spare refs/ and immediate subdirs.2249 * Note: munges *name.2250 */2251static voidtry_remove_empty_parents(char*name)2252{2253char*p, *q;2254int i;2255 p = name;2256for(i =0; i <2; i++) {/* refs/{heads,tags,...}/ */2257while(*p && *p !='/')2258 p++;2259/* tolerate duplicate slashes; see check_refname_format() */2260while(*p =='/')2261 p++;2262}2263for(q = p; *q; q++)2264;2265while(1) {2266while(q > p && *q !='/')2267 q--;2268while(q > p && *(q-1) =='/')2269 q--;2270if(q == p)2271break;2272*q ='\0';2273if(rmdir(git_path("%s", name)))2274break;2275}2276}22772278/* make sure nobody touched the ref, and unlink */2279static voidprune_ref(struct ref_to_prune *r)2280{2281struct ref_lock *lock =lock_ref_sha1(r->name +5, r->sha1);22822283if(lock) {2284unlink_or_warn(git_path("%s", r->name));2285unlock_ref(lock);2286try_remove_empty_parents(r->name);2287}2288}22892290static voidprune_refs(struct ref_to_prune *r)2291{2292while(r) {2293prune_ref(r);2294 r = r->next;2295}2296}22972298intpack_refs(unsigned int flags)2299{2300struct pack_refs_cb_data cbdata;23012302memset(&cbdata,0,sizeof(cbdata));2303 cbdata.flags = flags;23042305lock_packed_refs(LOCK_DIE_ON_ERROR);2306 cbdata.packed_refs =get_packed_refs(&ref_cache);23072308do_for_each_entry_in_dir(get_loose_refs(&ref_cache),0,2309 pack_if_possible_fn, &cbdata);23102311if(commit_packed_refs())2312die_errno("unable to overwrite old ref-pack file");23132314prune_refs(cbdata.ref_to_prune);2315return0;2316}23172318/*2319 * If entry is no longer needed in packed-refs, add it to the string2320 * list pointed to by cb_data. Reasons for deleting entries:2321 *2322 * - Entry is broken.2323 * - Entry is overridden by a loose ref.2324 * - Entry does not point at a valid object.2325 *2326 * In the first and third cases, also emit an error message because these2327 * are indications of repository corruption.2328 */2329static intcurate_packed_ref_fn(struct ref_entry *entry,void*cb_data)2330{2331struct string_list *refs_to_delete = cb_data;23322333if(entry->flag & REF_ISBROKEN) {2334/* This shouldn't happen to packed refs. */2335error("%sis broken!", entry->name);2336string_list_append(refs_to_delete, entry->name);2337return0;2338}2339if(!has_sha1_file(entry->u.value.sha1)) {2340unsigned char sha1[20];2341int flags;23422343if(read_ref_full(entry->name, sha1,0, &flags))2344/* We should at least have found the packed ref. */2345die("Internal error");2346if((flags & REF_ISSYMREF) || !(flags & REF_ISPACKED)) {2347/*2348 * This packed reference is overridden by a2349 * loose reference, so it is OK that its value2350 * is no longer valid; for example, it might2351 * refer to an object that has been garbage2352 * collected. For this purpose we don't even2353 * care whether the loose reference itself is2354 * invalid, broken, symbolic, etc. Silently2355 * remove the packed reference.2356 */2357string_list_append(refs_to_delete, entry->name);2358return0;2359}2360/*2361 * There is no overriding loose reference, so the fact2362 * that this reference doesn't refer to a valid object2363 * indicates some kind of repository corruption.2364 * Report the problem, then omit the reference from2365 * the output.2366 */2367error("%sdoes not point to a valid object!", entry->name);2368string_list_append(refs_to_delete, entry->name);2369return0;2370}23712372return0;2373}23742375static intrepack_without_ref(const char*refname)2376{2377struct ref_dir *packed;2378struct string_list refs_to_delete = STRING_LIST_INIT_DUP;2379struct string_list_item *ref_to_delete;23802381if(!get_packed_ref(refname))2382return0;/* refname does not exist in packed refs */23832384if(lock_packed_refs(0)) {2385unable_to_lock_error(git_path("packed-refs"), errno);2386returnerror("cannot delete '%s' from packed refs", refname);2387}2388 packed =get_packed_refs(&ref_cache);23892390/* Remove refname from the cache: */2391if(remove_entry(packed, refname) == -1) {2392/*2393 * The packed entry disappeared while we were2394 * acquiring the lock.2395 */2396rollback_packed_refs();2397return0;2398}23992400/* Remove any other accumulated cruft: */2401do_for_each_entry_in_dir(packed,0, curate_packed_ref_fn, &refs_to_delete);2402for_each_string_list_item(ref_to_delete, &refs_to_delete) {2403if(remove_entry(packed, ref_to_delete->string) == -1)2404die("internal error");2405}24062407/* Write what remains: */2408returncommit_packed_refs();2409}24102411intdelete_ref(const char*refname,const unsigned char*sha1,int delopt)2412{2413struct ref_lock *lock;2414int err, i =0, ret =0, flag =0;24152416 lock =lock_ref_sha1_basic(refname, sha1, delopt, &flag);2417if(!lock)2418return1;2419if(!(flag & REF_ISPACKED) || flag & REF_ISSYMREF) {2420/* loose */2421 i =strlen(lock->lk->filename) -5;/* .lock */2422 lock->lk->filename[i] =0;2423 err =unlink_or_warn(lock->lk->filename);2424if(err && errno != ENOENT)2425 ret =1;24262427 lock->lk->filename[i] ='.';2428}2429/* removing the loose one could have resurrected an earlier2430 * packed one. Also, if it was not loose we need to repack2431 * without it.2432 */2433 ret |=repack_without_ref(lock->ref_name);24342435unlink_or_warn(git_path("logs/%s", lock->ref_name));2436clear_loose_ref_cache(&ref_cache);2437unlock_ref(lock);2438return ret;2439}24402441/*2442 * People using contrib's git-new-workdir have .git/logs/refs ->2443 * /some/other/path/.git/logs/refs, and that may live on another device.2444 *2445 * IOW, to avoid cross device rename errors, the temporary renamed log must2446 * live into logs/refs.2447 */2448#define TMP_RENAMED_LOG"logs/refs/.tmp-renamed-log"24492450intrename_ref(const char*oldrefname,const char*newrefname,const char*logmsg)2451{2452unsigned char sha1[20], orig_sha1[20];2453int flag =0, logmoved =0;2454struct ref_lock *lock;2455struct stat loginfo;2456int log = !lstat(git_path("logs/%s", oldrefname), &loginfo);2457const char*symref = NULL;24582459if(log &&S_ISLNK(loginfo.st_mode))2460returnerror("reflog for%sis a symlink", oldrefname);24612462 symref =resolve_ref_unsafe(oldrefname, orig_sha1,1, &flag);2463if(flag & REF_ISSYMREF)2464returnerror("refname%sis a symbolic ref, renaming it is not supported",2465 oldrefname);2466if(!symref)2467returnerror("refname%snot found", oldrefname);24682469if(!is_refname_available(newrefname, oldrefname,get_packed_refs(&ref_cache)))2470return1;24712472if(!is_refname_available(newrefname, oldrefname,get_loose_refs(&ref_cache)))2473return1;24742475if(log &&rename(git_path("logs/%s", oldrefname),git_path(TMP_RENAMED_LOG)))2476returnerror("unable to move logfile logs/%sto "TMP_RENAMED_LOG":%s",2477 oldrefname,strerror(errno));24782479if(delete_ref(oldrefname, orig_sha1, REF_NODEREF)) {2480error("unable to delete old%s", oldrefname);2481goto rollback;2482}24832484if(!read_ref_full(newrefname, sha1,1, &flag) &&2485delete_ref(newrefname, sha1, REF_NODEREF)) {2486if(errno==EISDIR) {2487if(remove_empty_directories(git_path("%s", newrefname))) {2488error("Directory not empty:%s", newrefname);2489goto rollback;2490}2491}else{2492error("unable to delete existing%s", newrefname);2493goto rollback;2494}2495}24962497if(log &&safe_create_leading_directories(git_path("logs/%s", newrefname))) {2498error("unable to create directory for%s", newrefname);2499goto rollback;2500}25012502 retry:2503if(log &&rename(git_path(TMP_RENAMED_LOG),git_path("logs/%s", newrefname))) {2504if(errno==EISDIR || errno==ENOTDIR) {2505/*2506 * rename(a, b) when b is an existing2507 * directory ought to result in ISDIR, but2508 * Solaris 5.8 gives ENOTDIR. Sheesh.2509 */2510if(remove_empty_directories(git_path("logs/%s", newrefname))) {2511error("Directory not empty: logs/%s", newrefname);2512goto rollback;2513}2514goto retry;2515}else{2516error("unable to move logfile "TMP_RENAMED_LOG" to logs/%s:%s",2517 newrefname,strerror(errno));2518goto rollback;2519}2520}2521 logmoved = log;25222523 lock =lock_ref_sha1_basic(newrefname, NULL,0, NULL);2524if(!lock) {2525error("unable to lock%sfor update", newrefname);2526goto rollback;2527}2528 lock->force_write =1;2529hashcpy(lock->old_sha1, orig_sha1);2530if(write_ref_sha1(lock, orig_sha1, logmsg)) {2531error("unable to write current sha1 into%s", newrefname);2532goto rollback;2533}25342535return0;25362537 rollback:2538 lock =lock_ref_sha1_basic(oldrefname, NULL,0, NULL);2539if(!lock) {2540error("unable to lock%sfor rollback", oldrefname);2541goto rollbacklog;2542}25432544 lock->force_write =1;2545 flag = log_all_ref_updates;2546 log_all_ref_updates =0;2547if(write_ref_sha1(lock, orig_sha1, NULL))2548error("unable to write current sha1 into%s", oldrefname);2549 log_all_ref_updates = flag;25502551 rollbacklog:2552if(logmoved &&rename(git_path("logs/%s", newrefname),git_path("logs/%s", oldrefname)))2553error("unable to restore logfile%sfrom%s:%s",2554 oldrefname, newrefname,strerror(errno));2555if(!logmoved && log &&2556rename(git_path(TMP_RENAMED_LOG),git_path("logs/%s", oldrefname)))2557error("unable to restore logfile%sfrom "TMP_RENAMED_LOG":%s",2558 oldrefname,strerror(errno));25592560return1;2561}25622563intclose_ref(struct ref_lock *lock)2564{2565if(close_lock_file(lock->lk))2566return-1;2567 lock->lock_fd = -1;2568return0;2569}25702571intcommit_ref(struct ref_lock *lock)2572{2573if(commit_lock_file(lock->lk))2574return-1;2575 lock->lock_fd = -1;2576return0;2577}25782579voidunlock_ref(struct ref_lock *lock)2580{2581/* Do not free lock->lk -- atexit() still looks at them */2582if(lock->lk)2583rollback_lock_file(lock->lk);2584free(lock->ref_name);2585free(lock->orig_ref_name);2586free(lock);2587}25882589/*2590 * copy the reflog message msg to buf, which has been allocated sufficiently2591 * large, while cleaning up the whitespaces. Especially, convert LF to space,2592 * because reflog file is one line per entry.2593 */2594static intcopy_msg(char*buf,const char*msg)2595{2596char*cp = buf;2597char c;2598int wasspace =1;25992600*cp++ ='\t';2601while((c = *msg++)) {2602if(wasspace &&isspace(c))2603continue;2604 wasspace =isspace(c);2605if(wasspace)2606 c =' ';2607*cp++ = c;2608}2609while(buf < cp &&isspace(cp[-1]))2610 cp--;2611*cp++ ='\n';2612return cp - buf;2613}26142615intlog_ref_setup(const char*refname,char*logfile,int bufsize)2616{2617int logfd, oflags = O_APPEND | O_WRONLY;26182619git_snpath(logfile, bufsize,"logs/%s", refname);2620if(log_all_ref_updates &&2621(!prefixcmp(refname,"refs/heads/") ||2622!prefixcmp(refname,"refs/remotes/") ||2623!prefixcmp(refname,"refs/notes/") ||2624!strcmp(refname,"HEAD"))) {2625if(safe_create_leading_directories(logfile) <0)2626returnerror("unable to create directory for%s",2627 logfile);2628 oflags |= O_CREAT;2629}26302631 logfd =open(logfile, oflags,0666);2632if(logfd <0) {2633if(!(oflags & O_CREAT) && errno == ENOENT)2634return0;26352636if((oflags & O_CREAT) && errno == EISDIR) {2637if(remove_empty_directories(logfile)) {2638returnerror("There are still logs under '%s'",2639 logfile);2640}2641 logfd =open(logfile, oflags,0666);2642}26432644if(logfd <0)2645returnerror("Unable to append to%s:%s",2646 logfile,strerror(errno));2647}26482649adjust_shared_perm(logfile);2650close(logfd);2651return0;2652}26532654static intlog_ref_write(const char*refname,const unsigned char*old_sha1,2655const unsigned char*new_sha1,const char*msg)2656{2657int logfd, result, written, oflags = O_APPEND | O_WRONLY;2658unsigned maxlen, len;2659int msglen;2660char log_file[PATH_MAX];2661char*logrec;2662const char*committer;26632664if(log_all_ref_updates <0)2665 log_all_ref_updates = !is_bare_repository();26662667 result =log_ref_setup(refname, log_file,sizeof(log_file));2668if(result)2669return result;26702671 logfd =open(log_file, oflags);2672if(logfd <0)2673return0;2674 msglen = msg ?strlen(msg) :0;2675 committer =git_committer_info(0);2676 maxlen =strlen(committer) + msglen +100;2677 logrec =xmalloc(maxlen);2678 len =sprintf(logrec,"%s %s %s\n",2679sha1_to_hex(old_sha1),2680sha1_to_hex(new_sha1),2681 committer);2682if(msglen)2683 len +=copy_msg(logrec + len -1, msg) -1;2684 written = len <= maxlen ?write_in_full(logfd, logrec, len) : -1;2685free(logrec);2686if(close(logfd) !=0|| written != len)2687returnerror("Unable to append to%s", log_file);2688return0;2689}26902691static intis_branch(const char*refname)2692{2693return!strcmp(refname,"HEAD") || !prefixcmp(refname,"refs/heads/");2694}26952696intwrite_ref_sha1(struct ref_lock *lock,2697const unsigned char*sha1,const char*logmsg)2698{2699static char term ='\n';2700struct object *o;27012702if(!lock)2703return-1;2704if(!lock->force_write && !hashcmp(lock->old_sha1, sha1)) {2705unlock_ref(lock);2706return0;2707}2708 o =parse_object(sha1);2709if(!o) {2710error("Trying to write ref%swith nonexistent object%s",2711 lock->ref_name,sha1_to_hex(sha1));2712unlock_ref(lock);2713return-1;2714}2715if(o->type != OBJ_COMMIT &&is_branch(lock->ref_name)) {2716error("Trying to write non-commit object%sto branch%s",2717sha1_to_hex(sha1), lock->ref_name);2718unlock_ref(lock);2719return-1;2720}2721if(write_in_full(lock->lock_fd,sha1_to_hex(sha1),40) !=40||2722write_in_full(lock->lock_fd, &term,1) !=12723||close_ref(lock) <0) {2724error("Couldn't write%s", lock->lk->filename);2725unlock_ref(lock);2726return-1;2727}2728clear_loose_ref_cache(&ref_cache);2729if(log_ref_write(lock->ref_name, lock->old_sha1, sha1, logmsg) <0||2730(strcmp(lock->ref_name, lock->orig_ref_name) &&2731log_ref_write(lock->orig_ref_name, lock->old_sha1, sha1, logmsg) <0)) {2732unlock_ref(lock);2733return-1;2734}2735if(strcmp(lock->orig_ref_name,"HEAD") !=0) {2736/*2737 * Special hack: If a branch is updated directly and HEAD2738 * points to it (may happen on the remote side of a push2739 * for example) then logically the HEAD reflog should be2740 * updated too.2741 * A generic solution implies reverse symref information,2742 * but finding all symrefs pointing to the given branch2743 * would be rather costly for this rare event (the direct2744 * update of a branch) to be worth it. So let's cheat and2745 * check with HEAD only which should cover 99% of all usage2746 * scenarios (even 100% of the default ones).2747 */2748unsigned char head_sha1[20];2749int head_flag;2750const char*head_ref;2751 head_ref =resolve_ref_unsafe("HEAD", head_sha1,1, &head_flag);2752if(head_ref && (head_flag & REF_ISSYMREF) &&2753!strcmp(head_ref, lock->ref_name))2754log_ref_write("HEAD", lock->old_sha1, sha1, logmsg);2755}2756if(commit_ref(lock)) {2757error("Couldn't set%s", lock->ref_name);2758unlock_ref(lock);2759return-1;2760}2761unlock_ref(lock);2762return0;2763}27642765intcreate_symref(const char*ref_target,const char*refs_heads_master,2766const char*logmsg)2767{2768const char*lockpath;2769char ref[1000];2770int fd, len, written;2771char*git_HEAD =git_pathdup("%s", ref_target);2772unsigned char old_sha1[20], new_sha1[20];27732774if(logmsg &&read_ref(ref_target, old_sha1))2775hashclr(old_sha1);27762777if(safe_create_leading_directories(git_HEAD) <0)2778returnerror("unable to create directory for%s", git_HEAD);27792780#ifndef NO_SYMLINK_HEAD2781if(prefer_symlink_refs) {2782unlink(git_HEAD);2783if(!symlink(refs_heads_master, git_HEAD))2784goto done;2785fprintf(stderr,"no symlink - falling back to symbolic ref\n");2786}2787#endif27882789 len =snprintf(ref,sizeof(ref),"ref:%s\n", refs_heads_master);2790if(sizeof(ref) <= len) {2791error("refname too long:%s", refs_heads_master);2792goto error_free_return;2793}2794 lockpath =mkpath("%s.lock", git_HEAD);2795 fd =open(lockpath, O_CREAT | O_EXCL | O_WRONLY,0666);2796if(fd <0) {2797error("Unable to open%sfor writing", lockpath);2798goto error_free_return;2799}2800 written =write_in_full(fd, ref, len);2801if(close(fd) !=0|| written != len) {2802error("Unable to write to%s", lockpath);2803goto error_unlink_return;2804}2805if(rename(lockpath, git_HEAD) <0) {2806error("Unable to create%s", git_HEAD);2807goto error_unlink_return;2808}2809if(adjust_shared_perm(git_HEAD)) {2810error("Unable to fix permissions on%s", lockpath);2811 error_unlink_return:2812unlink_or_warn(lockpath);2813 error_free_return:2814free(git_HEAD);2815return-1;2816}28172818#ifndef NO_SYMLINK_HEAD2819 done:2820#endif2821if(logmsg && !read_ref(refs_heads_master, new_sha1))2822log_ref_write(ref_target, old_sha1, new_sha1, logmsg);28232824free(git_HEAD);2825return0;2826}28272828static char*ref_msg(const char*line,const char*endp)2829{2830const char*ep;2831 line +=82;2832 ep =memchr(line,'\n', endp - line);2833if(!ep)2834 ep = endp;2835returnxmemdupz(line, ep - line);2836}28372838intread_ref_at(const char*refname,unsigned long at_time,int cnt,2839unsigned char*sha1,char**msg,2840unsigned long*cutoff_time,int*cutoff_tz,int*cutoff_cnt)2841{2842const char*logfile, *logdata, *logend, *rec, *lastgt, *lastrec;2843char*tz_c;2844int logfd, tz, reccnt =0;2845struct stat st;2846unsigned long date;2847unsigned char logged_sha1[20];2848void*log_mapped;2849size_t mapsz;28502851 logfile =git_path("logs/%s", refname);2852 logfd =open(logfile, O_RDONLY,0);2853if(logfd <0)2854die_errno("Unable to read log '%s'", logfile);2855fstat(logfd, &st);2856if(!st.st_size)2857die("Log%sis empty.", logfile);2858 mapsz =xsize_t(st.st_size);2859 log_mapped =xmmap(NULL, mapsz, PROT_READ, MAP_PRIVATE, logfd,0);2860 logdata = log_mapped;2861close(logfd);28622863 lastrec = NULL;2864 rec = logend = logdata + st.st_size;2865while(logdata < rec) {2866 reccnt++;2867if(logdata < rec && *(rec-1) =='\n')2868 rec--;2869 lastgt = NULL;2870while(logdata < rec && *(rec-1) !='\n') {2871 rec--;2872if(*rec =='>')2873 lastgt = rec;2874}2875if(!lastgt)2876die("Log%sis corrupt.", logfile);2877 date =strtoul(lastgt +1, &tz_c,10);2878if(date <= at_time || cnt ==0) {2879 tz =strtoul(tz_c, NULL,10);2880if(msg)2881*msg =ref_msg(rec, logend);2882if(cutoff_time)2883*cutoff_time = date;2884if(cutoff_tz)2885*cutoff_tz = tz;2886if(cutoff_cnt)2887*cutoff_cnt = reccnt -1;2888if(lastrec) {2889if(get_sha1_hex(lastrec, logged_sha1))2890die("Log%sis corrupt.", logfile);2891if(get_sha1_hex(rec +41, sha1))2892die("Log%sis corrupt.", logfile);2893if(hashcmp(logged_sha1, sha1)) {2894warning("Log%shas gap after%s.",2895 logfile,show_date(date, tz, DATE_RFC2822));2896}2897}2898else if(date == at_time) {2899if(get_sha1_hex(rec +41, sha1))2900die("Log%sis corrupt.", logfile);2901}2902else{2903if(get_sha1_hex(rec +41, logged_sha1))2904die("Log%sis corrupt.", logfile);2905if(hashcmp(logged_sha1, sha1)) {2906warning("Log%sunexpectedly ended on%s.",2907 logfile,show_date(date, tz, DATE_RFC2822));2908}2909}2910munmap(log_mapped, mapsz);2911return0;2912}2913 lastrec = rec;2914if(cnt >0)2915 cnt--;2916}29172918 rec = logdata;2919while(rec < logend && *rec !='>'&& *rec !='\n')2920 rec++;2921if(rec == logend || *rec =='\n')2922die("Log%sis corrupt.", logfile);2923 date =strtoul(rec +1, &tz_c,10);2924 tz =strtoul(tz_c, NULL,10);2925if(get_sha1_hex(logdata, sha1))2926die("Log%sis corrupt.", logfile);2927if(is_null_sha1(sha1)) {2928if(get_sha1_hex(logdata +41, sha1))2929die("Log%sis corrupt.", logfile);2930}2931if(msg)2932*msg =ref_msg(logdata, logend);2933munmap(log_mapped, mapsz);29342935if(cutoff_time)2936*cutoff_time = date;2937if(cutoff_tz)2938*cutoff_tz = tz;2939if(cutoff_cnt)2940*cutoff_cnt = reccnt;2941return1;2942}29432944static intshow_one_reflog_ent(struct strbuf *sb, each_reflog_ent_fn fn,void*cb_data)2945{2946unsigned char osha1[20], nsha1[20];2947char*email_end, *message;2948unsigned long timestamp;2949int tz;29502951/* old SP new SP name <email> SP time TAB msg LF */2952if(sb->len <83|| sb->buf[sb->len -1] !='\n'||2953get_sha1_hex(sb->buf, osha1) || sb->buf[40] !=' '||2954get_sha1_hex(sb->buf +41, nsha1) || sb->buf[81] !=' '||2955!(email_end =strchr(sb->buf +82,'>')) ||2956 email_end[1] !=' '||2957!(timestamp =strtoul(email_end +2, &message,10)) ||2958!message || message[0] !=' '||2959(message[1] !='+'&& message[1] !='-') ||2960!isdigit(message[2]) || !isdigit(message[3]) ||2961!isdigit(message[4]) || !isdigit(message[5]))2962return0;/* corrupt? */2963 email_end[1] ='\0';2964 tz =strtol(message +1, NULL,10);2965if(message[6] !='\t')2966 message +=6;2967else2968 message +=7;2969returnfn(osha1, nsha1, sb->buf +82, timestamp, tz, message, cb_data);2970}29712972static char*find_beginning_of_line(char*bob,char*scan)2973{2974while(bob < scan && *(--scan) !='\n')2975;/* keep scanning backwards */2976/*2977 * Return either beginning of the buffer, or LF at the end of2978 * the previous line.2979 */2980return scan;2981}29822983intfor_each_reflog_ent_reverse(const char*refname, each_reflog_ent_fn fn,void*cb_data)2984{2985struct strbuf sb = STRBUF_INIT;2986FILE*logfp;2987long pos;2988int ret =0, at_tail =1;29892990 logfp =fopen(git_path("logs/%s", refname),"r");2991if(!logfp)2992return-1;29932994/* Jump to the end */2995if(fseek(logfp,0, SEEK_END) <0)2996returnerror("cannot seek back reflog for%s:%s",2997 refname,strerror(errno));2998 pos =ftell(logfp);2999while(!ret &&0< pos) {3000int cnt;3001size_t nread;3002char buf[BUFSIZ];3003char*endp, *scanp;30043005/* Fill next block from the end */3006 cnt = (sizeof(buf) < pos) ?sizeof(buf) : pos;3007if(fseek(logfp, pos - cnt, SEEK_SET))3008returnerror("cannot seek back reflog for%s:%s",3009 refname,strerror(errno));3010 nread =fread(buf, cnt,1, logfp);3011if(nread !=1)3012returnerror("cannot read%dbytes from reflog for%s:%s",3013 cnt, refname,strerror(errno));3014 pos -= cnt;30153016 scanp = endp = buf + cnt;3017if(at_tail && scanp[-1] =='\n')3018/* Looking at the final LF at the end of the file */3019 scanp--;3020 at_tail =0;30213022while(buf < scanp) {3023/*3024 * terminating LF of the previous line, or the beginning3025 * of the buffer.3026 */3027char*bp;30283029 bp =find_beginning_of_line(buf, scanp);30303031if(*bp !='\n') {3032strbuf_splice(&sb,0,0, buf, endp - buf);3033if(pos)3034break;/* need to fill another block */3035 scanp = buf -1;/* leave loop */3036}else{3037/*3038 * (bp + 1) thru endp is the beginning of the3039 * current line we have in sb3040 */3041strbuf_splice(&sb,0,0, bp +1, endp - (bp +1));3042 scanp = bp;3043 endp = bp +1;3044}3045 ret =show_one_reflog_ent(&sb, fn, cb_data);3046strbuf_reset(&sb);3047if(ret)3048break;3049}30503051}3052if(!ret && sb.len)3053 ret =show_one_reflog_ent(&sb, fn, cb_data);30543055fclose(logfp);3056strbuf_release(&sb);3057return ret;3058}30593060intfor_each_reflog_ent(const char*refname, each_reflog_ent_fn fn,void*cb_data)3061{3062FILE*logfp;3063struct strbuf sb = STRBUF_INIT;3064int ret =0;30653066 logfp =fopen(git_path("logs/%s", refname),"r");3067if(!logfp)3068return-1;30693070while(!ret && !strbuf_getwholeline(&sb, logfp,'\n'))3071 ret =show_one_reflog_ent(&sb, fn, cb_data);3072fclose(logfp);3073strbuf_release(&sb);3074return ret;3075}3076/*3077 * Call fn for each reflog in the namespace indicated by name. name3078 * must be empty or end with '/'. Name will be used as a scratch3079 * space, but its contents will be restored before return.3080 */3081static intdo_for_each_reflog(struct strbuf *name, each_ref_fn fn,void*cb_data)3082{3083DIR*d =opendir(git_path("logs/%s", name->buf));3084int retval =0;3085struct dirent *de;3086int oldlen = name->len;30873088if(!d)3089return name->len ? errno :0;30903091while((de =readdir(d)) != NULL) {3092struct stat st;30933094if(de->d_name[0] =='.')3095continue;3096if(has_extension(de->d_name,".lock"))3097continue;3098strbuf_addstr(name, de->d_name);3099if(stat(git_path("logs/%s", name->buf), &st) <0) {3100;/* silently ignore */3101}else{3102if(S_ISDIR(st.st_mode)) {3103strbuf_addch(name,'/');3104 retval =do_for_each_reflog(name, fn, cb_data);3105}else{3106unsigned char sha1[20];3107if(read_ref_full(name->buf, sha1,0, NULL))3108 retval =error("bad ref for%s", name->buf);3109else3110 retval =fn(name->buf, sha1,0, cb_data);3111}3112if(retval)3113break;3114}3115strbuf_setlen(name, oldlen);3116}3117closedir(d);3118return retval;3119}31203121intfor_each_reflog(each_ref_fn fn,void*cb_data)3122{3123int retval;3124struct strbuf name;3125strbuf_init(&name, PATH_MAX);3126 retval =do_for_each_reflog(&name, fn, cb_data);3127strbuf_release(&name);3128return retval;3129}31303131intupdate_ref(const char*action,const char*refname,3132const unsigned char*sha1,const unsigned char*oldval,3133int flags,enum action_on_err onerr)3134{3135static struct ref_lock *lock;3136 lock =lock_any_ref_for_update(refname, oldval, flags);3137if(!lock) {3138const char*str ="Cannot lock the ref '%s'.";3139switch(onerr) {3140case MSG_ON_ERR:error(str, refname);break;3141case DIE_ON_ERR:die(str, refname);break;3142case QUIET_ON_ERR:break;3143}3144return1;3145}3146if(write_ref_sha1(lock, sha1, action) <0) {3147const char*str ="Cannot update the ref '%s'.";3148switch(onerr) {3149case MSG_ON_ERR:error(str, refname);break;3150case DIE_ON_ERR:die(str, refname);break;3151case QUIET_ON_ERR:break;3152}3153return1;3154}3155return0;3156}31573158struct ref *find_ref_by_name(const struct ref *list,const char*name)3159{3160for( ; list; list = list->next)3161if(!strcmp(list->name, name))3162return(struct ref *)list;3163return NULL;3164}31653166/*3167 * generate a format suitable for scanf from a ref_rev_parse_rules3168 * rule, that is replace the "%.*s" spec with a "%s" spec3169 */3170static voidgen_scanf_fmt(char*scanf_fmt,const char*rule)3171{3172char*spec;31733174 spec =strstr(rule,"%.*s");3175if(!spec ||strstr(spec +4,"%.*s"))3176die("invalid rule in ref_rev_parse_rules:%s", rule);31773178/* copy all until spec */3179strncpy(scanf_fmt, rule, spec - rule);3180 scanf_fmt[spec - rule] ='\0';3181/* copy new spec */3182strcat(scanf_fmt,"%s");3183/* copy remaining rule */3184strcat(scanf_fmt, spec +4);31853186return;3187}31883189char*shorten_unambiguous_ref(const char*refname,int strict)3190{3191int i;3192static char**scanf_fmts;3193static int nr_rules;3194char*short_name;31953196/* pre generate scanf formats from ref_rev_parse_rules[] */3197if(!nr_rules) {3198size_t total_len =0;31993200/* the rule list is NULL terminated, count them first */3201for(; ref_rev_parse_rules[nr_rules]; nr_rules++)3202/* no +1 because strlen("%s") < strlen("%.*s") */3203 total_len +=strlen(ref_rev_parse_rules[nr_rules]);32043205 scanf_fmts =xmalloc(nr_rules *sizeof(char*) + total_len);32063207 total_len =0;3208for(i =0; i < nr_rules; i++) {3209 scanf_fmts[i] = (char*)&scanf_fmts[nr_rules]3210+ total_len;3211gen_scanf_fmt(scanf_fmts[i], ref_rev_parse_rules[i]);3212 total_len +=strlen(ref_rev_parse_rules[i]);3213}3214}32153216/* bail out if there are no rules */3217if(!nr_rules)3218returnxstrdup(refname);32193220/* buffer for scanf result, at most refname must fit */3221 short_name =xstrdup(refname);32223223/* skip first rule, it will always match */3224for(i = nr_rules -1; i >0; --i) {3225int j;3226int rules_to_fail = i;3227int short_name_len;32283229if(1!=sscanf(refname, scanf_fmts[i], short_name))3230continue;32313232 short_name_len =strlen(short_name);32333234/*3235 * in strict mode, all (except the matched one) rules3236 * must fail to resolve to a valid non-ambiguous ref3237 */3238if(strict)3239 rules_to_fail = nr_rules;32403241/*3242 * check if the short name resolves to a valid ref,3243 * but use only rules prior to the matched one3244 */3245for(j =0; j < rules_to_fail; j++) {3246const char*rule = ref_rev_parse_rules[j];3247char refname[PATH_MAX];32483249/* skip matched rule */3250if(i == j)3251continue;32523253/*3254 * the short name is ambiguous, if it resolves3255 * (with this previous rule) to a valid ref3256 * read_ref() returns 0 on success3257 */3258mksnpath(refname,sizeof(refname),3259 rule, short_name_len, short_name);3260if(ref_exists(refname))3261break;3262}32633264/*3265 * short name is non-ambiguous if all previous rules3266 * haven't resolved to a valid ref3267 */3268if(j == rules_to_fail)3269return short_name;3270}32713272free(short_name);3273returnxstrdup(refname);3274}32753276static struct string_list *hide_refs;32773278intparse_hide_refs_config(const char*var,const char*value,const char*section)3279{3280if(!strcmp("transfer.hiderefs", var) ||3281/* NEEDSWORK: use parse_config_key() once both are merged */3282(!prefixcmp(var, section) && var[strlen(section)] =='.'&&3283!strcmp(var +strlen(section),".hiderefs"))) {3284char*ref;3285int len;32863287if(!value)3288returnconfig_error_nonbool(var);3289 ref =xstrdup(value);3290 len =strlen(ref);3291while(len && ref[len -1] =='/')3292 ref[--len] ='\0';3293if(!hide_refs) {3294 hide_refs =xcalloc(1,sizeof(*hide_refs));3295 hide_refs->strdup_strings =1;3296}3297string_list_append(hide_refs, ref);3298}3299return0;3300}33013302intref_is_hidden(const char*refname)3303{3304struct string_list_item *item;33053306if(!hide_refs)3307return0;3308for_each_string_list_item(item, hide_refs) {3309int len;3310if(prefixcmp(refname, item->string))3311continue;3312 len =strlen(item->string);3313if(!refname[len] || refname[len] =='/')3314return1;3315}3316return0;3317}