1/* 2 * GIT - The information manager from hell 3 * 4 * Copyright (C) Linus Torvalds, 2005 5 */ 6#define NO_THE_INDEX_COMPATIBILITY_MACROS 7#include"cache.h" 8#include"cache-tree.h" 9#include"refs.h" 10#include"dir.h" 11 12/* Index extensions. 13 * 14 * The first letter should be 'A'..'Z' for extensions that are not 15 * necessary for a correct operation (i.e. optimization data). 16 * When new extensions are added that _needs_ to be understood in 17 * order to correctly interpret the index file, pick character that 18 * is outside the range, to cause the reader to abort. 19 */ 20 21#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 22#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 23 24struct index_state the_index; 25 26static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 27{ 28 istate->cache[nr] = ce; 29add_name_hash(istate, ce); 30} 31 32static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 33{ 34struct cache_entry *old = istate->cache[nr]; 35 36remove_name_hash(old); 37set_index_entry(istate, nr, ce); 38 istate->cache_changed =1; 39} 40 41/* 42 * This only updates the "non-critical" parts of the directory 43 * cache, ie the parts that aren't tracked by GIT, and only used 44 * to validate the cache. 45 */ 46voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 47{ 48 ce->ce_ctime = st->st_ctime; 49 ce->ce_mtime = st->st_mtime; 50 ce->ce_dev = st->st_dev; 51 ce->ce_ino = st->st_ino; 52 ce->ce_uid = st->st_uid; 53 ce->ce_gid = st->st_gid; 54 ce->ce_size = st->st_size; 55 56if(assume_unchanged) 57 ce->ce_flags |= CE_VALID; 58 59if(S_ISREG(st->st_mode)) 60ce_mark_uptodate(ce); 61} 62 63static intce_compare_data(struct cache_entry *ce,struct stat *st) 64{ 65int match = -1; 66int fd =open(ce->name, O_RDONLY); 67 68if(fd >=0) { 69unsigned char sha1[20]; 70if(!index_fd(sha1, fd, st,0, OBJ_BLOB, ce->name)) 71 match =hashcmp(sha1, ce->sha1); 72/* index_fd() closed the file descriptor already */ 73} 74return match; 75} 76 77static intce_compare_link(struct cache_entry *ce,size_t expected_size) 78{ 79int match = -1; 80char*target; 81void*buffer; 82unsigned long size; 83enum object_type type; 84int len; 85 86 target =xmalloc(expected_size); 87 len =readlink(ce->name, target, expected_size); 88if(len != expected_size) { 89free(target); 90return-1; 91} 92 buffer =read_sha1_file(ce->sha1, &type, &size); 93if(!buffer) { 94free(target); 95return-1; 96} 97if(size == expected_size) 98 match =memcmp(buffer, target, size); 99free(buffer); 100free(target); 101return match; 102} 103 104static intce_compare_gitlink(struct cache_entry *ce) 105{ 106unsigned char sha1[20]; 107 108/* 109 * We don't actually require that the .git directory 110 * under GITLINK directory be a valid git directory. It 111 * might even be missing (in case nobody populated that 112 * sub-project). 113 * 114 * If so, we consider it always to match. 115 */ 116if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 117return0; 118returnhashcmp(sha1, ce->sha1); 119} 120 121static intce_modified_check_fs(struct cache_entry *ce,struct stat *st) 122{ 123switch(st->st_mode & S_IFMT) { 124case S_IFREG: 125if(ce_compare_data(ce, st)) 126return DATA_CHANGED; 127break; 128case S_IFLNK: 129if(ce_compare_link(ce,xsize_t(st->st_size))) 130return DATA_CHANGED; 131break; 132case S_IFDIR: 133if(S_ISGITLINK(ce->ce_mode)) 134return0; 135default: 136return TYPE_CHANGED; 137} 138return0; 139} 140 141static intce_match_stat_basic(struct cache_entry *ce,struct stat *st) 142{ 143unsigned int changed =0; 144 145if(ce->ce_flags & CE_REMOVE) 146return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 147 148switch(ce->ce_mode & S_IFMT) { 149case S_IFREG: 150 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 151/* We consider only the owner x bit to be relevant for 152 * "mode changes" 153 */ 154if(trust_executable_bit && 155(0100& (ce->ce_mode ^ st->st_mode))) 156 changed |= MODE_CHANGED; 157break; 158case S_IFLNK: 159if(!S_ISLNK(st->st_mode) && 160(has_symlinks || !S_ISREG(st->st_mode))) 161 changed |= TYPE_CHANGED; 162break; 163case S_IFGITLINK: 164if(!S_ISDIR(st->st_mode)) 165 changed |= TYPE_CHANGED; 166else if(ce_compare_gitlink(ce)) 167 changed |= DATA_CHANGED; 168return changed; 169default: 170die("internal error: ce_mode is%o", ce->ce_mode); 171} 172if(ce->ce_mtime != (unsigned int) st->st_mtime) 173 changed |= MTIME_CHANGED; 174if(ce->ce_ctime != (unsigned int) st->st_ctime) 175 changed |= CTIME_CHANGED; 176 177if(ce->ce_uid != (unsigned int) st->st_uid || 178 ce->ce_gid != (unsigned int) st->st_gid) 179 changed |= OWNER_CHANGED; 180if(ce->ce_ino != (unsigned int) st->st_ino) 181 changed |= INODE_CHANGED; 182 183#ifdef USE_STDEV 184/* 185 * st_dev breaks on network filesystems where different 186 * clients will have different views of what "device" 187 * the filesystem is on 188 */ 189if(ce->ce_dev != (unsigned int) st->st_dev) 190 changed |= INODE_CHANGED; 191#endif 192 193if(ce->ce_size != (unsigned int) st->st_size) 194 changed |= DATA_CHANGED; 195 196return changed; 197} 198 199static intis_racy_timestamp(const struct index_state *istate,struct cache_entry *ce) 200{ 201return(istate->timestamp && 202((unsigned int)istate->timestamp) <= ce->ce_mtime); 203} 204 205intie_match_stat(const struct index_state *istate, 206struct cache_entry *ce,struct stat *st, 207unsigned int options) 208{ 209unsigned int changed; 210int ignore_valid = options & CE_MATCH_IGNORE_VALID; 211int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 212 213/* 214 * If it's marked as always valid in the index, it's 215 * valid whatever the checked-out copy says. 216 */ 217if(!ignore_valid && (ce->ce_flags & CE_VALID)) 218return0; 219 220 changed =ce_match_stat_basic(ce, st); 221 222/* 223 * Within 1 second of this sequence: 224 * echo xyzzy >file && git-update-index --add file 225 * running this command: 226 * echo frotz >file 227 * would give a falsely clean cache entry. The mtime and 228 * length match the cache, and other stat fields do not change. 229 * 230 * We could detect this at update-index time (the cache entry 231 * being registered/updated records the same time as "now") 232 * and delay the return from git-update-index, but that would 233 * effectively mean we can make at most one commit per second, 234 * which is not acceptable. Instead, we check cache entries 235 * whose mtime are the same as the index file timestamp more 236 * carefully than others. 237 */ 238if(!changed &&is_racy_timestamp(istate, ce)) { 239if(assume_racy_is_modified) 240 changed |= DATA_CHANGED; 241else 242 changed |=ce_modified_check_fs(ce, st); 243} 244 245return changed; 246} 247 248intie_modified(const struct index_state *istate, 249struct cache_entry *ce,struct stat *st,unsigned int options) 250{ 251int changed, changed_fs; 252 253 changed =ie_match_stat(istate, ce, st, options); 254if(!changed) 255return0; 256/* 257 * If the mode or type has changed, there's no point in trying 258 * to refresh the entry - it's not going to match 259 */ 260if(changed & (MODE_CHANGED | TYPE_CHANGED)) 261return changed; 262 263/* Immediately after read-tree or update-index --cacheinfo, 264 * the length field is zero. For other cases the ce_size 265 * should match the SHA1 recorded in the index entry. 266 */ 267if((changed & DATA_CHANGED) && ce->ce_size !=0) 268return changed; 269 270 changed_fs =ce_modified_check_fs(ce, st); 271if(changed_fs) 272return changed | changed_fs; 273return0; 274} 275 276intbase_name_compare(const char*name1,int len1,int mode1, 277const char*name2,int len2,int mode2) 278{ 279unsigned char c1, c2; 280int len = len1 < len2 ? len1 : len2; 281int cmp; 282 283 cmp =memcmp(name1, name2, len); 284if(cmp) 285return cmp; 286 c1 = name1[len]; 287 c2 = name2[len]; 288if(!c1 &&S_ISDIR(mode1)) 289 c1 ='/'; 290if(!c2 &&S_ISDIR(mode2)) 291 c2 ='/'; 292return(c1 < c2) ? -1: (c1 > c2) ?1:0; 293} 294 295/* 296 * df_name_compare() is identical to base_name_compare(), except it 297 * compares conflicting directory/file entries as equal. Note that 298 * while a directory name compares as equal to a regular file, they 299 * then individually compare _differently_ to a filename that has 300 * a dot after the basename (because '\0' < '.' < '/'). 301 * 302 * This is used by routines that want to traverse the git namespace 303 * but then handle conflicting entries together when possible. 304 */ 305intdf_name_compare(const char*name1,int len1,int mode1, 306const char*name2,int len2,int mode2) 307{ 308int len = len1 < len2 ? len1 : len2, cmp; 309unsigned char c1, c2; 310 311 cmp =memcmp(name1, name2, len); 312if(cmp) 313return cmp; 314/* Directories and files compare equal (same length, same name) */ 315if(len1 == len2) 316return0; 317 c1 = name1[len]; 318if(!c1 &&S_ISDIR(mode1)) 319 c1 ='/'; 320 c2 = name2[len]; 321if(!c2 &&S_ISDIR(mode2)) 322 c2 ='/'; 323if(c1 =='/'&& !c2) 324return0; 325if(c2 =='/'&& !c1) 326return0; 327return c1 - c2; 328} 329 330intcache_name_compare(const char*name1,int flags1,const char*name2,int flags2) 331{ 332int len1 = flags1 & CE_NAMEMASK; 333int len2 = flags2 & CE_NAMEMASK; 334int len = len1 < len2 ? len1 : len2; 335int cmp; 336 337 cmp =memcmp(name1, name2, len); 338if(cmp) 339return cmp; 340if(len1 < len2) 341return-1; 342if(len1 > len2) 343return1; 344 345/* Compare stages */ 346 flags1 &= CE_STAGEMASK; 347 flags2 &= CE_STAGEMASK; 348 349if(flags1 < flags2) 350return-1; 351if(flags1 > flags2) 352return1; 353return0; 354} 355 356intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 357{ 358int first, last; 359 360 first =0; 361 last = istate->cache_nr; 362while(last > first) { 363int next = (last + first) >>1; 364struct cache_entry *ce = istate->cache[next]; 365int cmp =cache_name_compare(name, namelen, ce->name, ce->ce_flags); 366if(!cmp) 367return next; 368if(cmp <0) { 369 last = next; 370continue; 371} 372 first = next+1; 373} 374return-first-1; 375} 376 377/* Remove entry, return true if there are more entries to go.. */ 378intremove_index_entry_at(struct index_state *istate,int pos) 379{ 380struct cache_entry *ce = istate->cache[pos]; 381 382remove_name_hash(ce); 383 istate->cache_changed =1; 384 istate->cache_nr--; 385if(pos >= istate->cache_nr) 386return0; 387memmove(istate->cache + pos, 388 istate->cache + pos +1, 389(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 390return1; 391} 392 393intremove_file_from_index(struct index_state *istate,const char*path) 394{ 395int pos =index_name_pos(istate, path,strlen(path)); 396if(pos <0) 397 pos = -pos-1; 398cache_tree_invalidate_path(istate->cache_tree, path); 399while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 400remove_index_entry_at(istate, pos); 401return0; 402} 403 404static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 405{ 406return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 407} 408 409static intindex_name_pos_also_unmerged(struct index_state *istate, 410const char*path,int namelen) 411{ 412int pos =index_name_pos(istate, path, namelen); 413struct cache_entry *ce; 414 415if(pos >=0) 416return pos; 417 418/* maybe unmerged? */ 419 pos = -1- pos; 420if(pos >= istate->cache_nr || 421compare_name((ce = istate->cache[pos]), path, namelen)) 422return-1; 423 424/* order of preference: stage 2, 1, 3 */ 425if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 426ce_stage((ce = istate->cache[pos +1])) ==2&& 427!compare_name(ce, path, namelen)) 428 pos++; 429return pos; 430} 431 432static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 433{ 434int len =ce_namelen(ce); 435returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 436} 437 438/* 439 * If we add a filename that aliases in the cache, we will use the 440 * name that we already have - but we don't want to update the same 441 * alias twice, because that implies that there were actually two 442 * different files with aliasing names! 443 * 444 * So we use the CE_ADDED flag to verify that the alias was an old 445 * one before we accept it as 446 */ 447static struct cache_entry *create_alias_ce(struct cache_entry *ce,struct cache_entry *alias) 448{ 449int len; 450struct cache_entry *new; 451 452if(alias->ce_flags & CE_ADDED) 453die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 454 455/* Ok, create the new entry using the name of the existing alias */ 456 len =ce_namelen(alias); 457new=xcalloc(1,cache_entry_size(len)); 458memcpy(new->name, alias->name, len); 459copy_cache_entry(new, ce); 460free(ce); 461return new; 462} 463 464intadd_file_to_index(struct index_state *istate,const char*path,int verbose) 465{ 466int size, namelen; 467struct stat st; 468struct cache_entry *ce, *alias; 469unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_RACY_IS_DIRTY; 470 471if(lstat(path, &st)) 472die("%s: unable to stat (%s)", path,strerror(errno)); 473 474if(!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode) && !S_ISDIR(st.st_mode)) 475die("%s: can only add regular files, symbolic links or git-directories", path); 476 477 namelen =strlen(path); 478if(S_ISDIR(st.st_mode)) { 479while(namelen && path[namelen-1] =='/') 480 namelen--; 481} 482 size =cache_entry_size(namelen); 483 ce =xcalloc(1, size); 484memcpy(ce->name, path, namelen); 485 ce->ce_flags = namelen; 486fill_stat_cache_info(ce, &st); 487 488if(trust_executable_bit && has_symlinks) 489 ce->ce_mode =create_ce_mode(st.st_mode); 490else{ 491/* If there is an existing entry, pick the mode bits and type 492 * from it, otherwise assume unexecutable regular file. 493 */ 494struct cache_entry *ent; 495int pos =index_name_pos_also_unmerged(istate, path, namelen); 496 497 ent = (0<= pos) ? istate->cache[pos] : NULL; 498 ce->ce_mode =ce_mode_from_stat(ent, st.st_mode); 499} 500 501 alias =index_name_exists(istate, ce->name,ce_namelen(ce), ignore_case); 502if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, &st, ce_option)) { 503/* Nothing changed, really */ 504free(ce); 505ce_mark_uptodate(alias); 506 alias->ce_flags |= CE_ADDED; 507return0; 508} 509if(index_path(ce->sha1, path, &st,1)) 510die("unable to index file%s", path); 511if(ignore_case && alias &&different_name(ce, alias)) 512 ce =create_alias_ce(ce, alias); 513 ce->ce_flags |= CE_ADDED; 514if(add_index_entry(istate, ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE)) 515die("unable to add%sto index",path); 516if(verbose) 517printf("add '%s'\n", path); 518return0; 519} 520 521struct cache_entry *make_cache_entry(unsigned int mode, 522const unsigned char*sha1,const char*path,int stage, 523int refresh) 524{ 525int size, len; 526struct cache_entry *ce; 527 528if(!verify_path(path)) 529return NULL; 530 531 len =strlen(path); 532 size =cache_entry_size(len); 533 ce =xcalloc(1, size); 534 535hashcpy(ce->sha1, sha1); 536memcpy(ce->name, path, len); 537 ce->ce_flags =create_ce_flags(len, stage); 538 ce->ce_mode =create_ce_mode(mode); 539 540if(refresh) 541returnrefresh_cache_entry(ce,0); 542 543return ce; 544} 545 546intce_same_name(struct cache_entry *a,struct cache_entry *b) 547{ 548int len =ce_namelen(a); 549returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 550} 551 552intce_path_match(const struct cache_entry *ce,const char**pathspec) 553{ 554const char*match, *name; 555int len; 556 557if(!pathspec) 558return1; 559 560 len =ce_namelen(ce); 561 name = ce->name; 562while((match = *pathspec++) != NULL) { 563int matchlen =strlen(match); 564if(matchlen > len) 565continue; 566if(memcmp(name, match, matchlen)) 567continue; 568if(matchlen && name[matchlen-1] =='/') 569return1; 570if(name[matchlen] =='/'|| !name[matchlen]) 571return1; 572if(!matchlen) 573return1; 574} 575return0; 576} 577 578/* 579 * We fundamentally don't like some paths: we don't want 580 * dot or dot-dot anywhere, and for obvious reasons don't 581 * want to recurse into ".git" either. 582 * 583 * Also, we don't want double slashes or slashes at the 584 * end that can make pathnames ambiguous. 585 */ 586static intverify_dotfile(const char*rest) 587{ 588/* 589 * The first character was '.', but that 590 * has already been discarded, we now test 591 * the rest. 592 */ 593switch(*rest) { 594/* "." is not allowed */ 595case'\0':case'/': 596return0; 597 598/* 599 * ".git" followed by NUL or slash is bad. This 600 * shares the path end test with the ".." case. 601 */ 602case'g': 603if(rest[1] !='i') 604break; 605if(rest[2] !='t') 606break; 607 rest +=2; 608/* fallthrough */ 609case'.': 610if(rest[1] =='\0'|| rest[1] =='/') 611return0; 612} 613return1; 614} 615 616intverify_path(const char*path) 617{ 618char c; 619 620goto inside; 621for(;;) { 622if(!c) 623return1; 624if(c =='/') { 625inside: 626 c = *path++; 627switch(c) { 628default: 629continue; 630case'/':case'\0': 631break; 632case'.': 633if(verify_dotfile(path)) 634continue; 635} 636return0; 637} 638 c = *path++; 639} 640} 641 642/* 643 * Do we have another file that has the beginning components being a 644 * proper superset of the name we're trying to add? 645 */ 646static inthas_file_name(struct index_state *istate, 647const struct cache_entry *ce,int pos,int ok_to_replace) 648{ 649int retval =0; 650int len =ce_namelen(ce); 651int stage =ce_stage(ce); 652const char*name = ce->name; 653 654while(pos < istate->cache_nr) { 655struct cache_entry *p = istate->cache[pos++]; 656 657if(len >=ce_namelen(p)) 658break; 659if(memcmp(name, p->name, len)) 660break; 661if(ce_stage(p) != stage) 662continue; 663if(p->name[len] !='/') 664continue; 665if(p->ce_flags & CE_REMOVE) 666continue; 667 retval = -1; 668if(!ok_to_replace) 669break; 670remove_index_entry_at(istate, --pos); 671} 672return retval; 673} 674 675/* 676 * Do we have another file with a pathname that is a proper 677 * subset of the name we're trying to add? 678 */ 679static inthas_dir_name(struct index_state *istate, 680const struct cache_entry *ce,int pos,int ok_to_replace) 681{ 682int retval =0; 683int stage =ce_stage(ce); 684const char*name = ce->name; 685const char*slash = name +ce_namelen(ce); 686 687for(;;) { 688int len; 689 690for(;;) { 691if(*--slash =='/') 692break; 693if(slash <= ce->name) 694return retval; 695} 696 len = slash - name; 697 698 pos =index_name_pos(istate, name,create_ce_flags(len, stage)); 699if(pos >=0) { 700/* 701 * Found one, but not so fast. This could 702 * be a marker that says "I was here, but 703 * I am being removed". Such an entry is 704 * not a part of the resulting tree, and 705 * it is Ok to have a directory at the same 706 * path. 707 */ 708if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 709 retval = -1; 710if(!ok_to_replace) 711break; 712remove_index_entry_at(istate, pos); 713continue; 714} 715} 716else 717 pos = -pos-1; 718 719/* 720 * Trivial optimization: if we find an entry that 721 * already matches the sub-directory, then we know 722 * we're ok, and we can exit. 723 */ 724while(pos < istate->cache_nr) { 725struct cache_entry *p = istate->cache[pos]; 726if((ce_namelen(p) <= len) || 727(p->name[len] !='/') || 728memcmp(p->name, name, len)) 729break;/* not our subdirectory */ 730if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 731/* 732 * p is at the same stage as our entry, and 733 * is a subdirectory of what we are looking 734 * at, so we cannot have conflicts at our 735 * level or anything shorter. 736 */ 737return retval; 738 pos++; 739} 740} 741return retval; 742} 743 744/* We may be in a situation where we already have path/file and path 745 * is being added, or we already have path and path/file is being 746 * added. Either one would result in a nonsense tree that has path 747 * twice when git-write-tree tries to write it out. Prevent it. 748 * 749 * If ok-to-replace is specified, we remove the conflicting entries 750 * from the cache so the caller should recompute the insert position. 751 * When this happens, we return non-zero. 752 */ 753static intcheck_file_directory_conflict(struct index_state *istate, 754const struct cache_entry *ce, 755int pos,int ok_to_replace) 756{ 757int retval; 758 759/* 760 * When ce is an "I am going away" entry, we allow it to be added 761 */ 762if(ce->ce_flags & CE_REMOVE) 763return0; 764 765/* 766 * We check if the path is a sub-path of a subsequent pathname 767 * first, since removing those will not change the position 768 * in the array. 769 */ 770 retval =has_file_name(istate, ce, pos, ok_to_replace); 771 772/* 773 * Then check if the path might have a clashing sub-directory 774 * before it. 775 */ 776return retval +has_dir_name(istate, ce, pos, ok_to_replace); 777} 778 779static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option) 780{ 781int pos; 782int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 783int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 784int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 785 786cache_tree_invalidate_path(istate->cache_tree, ce->name); 787 pos =index_name_pos(istate, ce->name, ce->ce_flags); 788 789/* existing match? Just replace it. */ 790if(pos >=0) { 791replace_index_entry(istate, pos, ce); 792return0; 793} 794 pos = -pos-1; 795 796/* 797 * Inserting a merged entry ("stage 0") into the index 798 * will always replace all non-merged entries.. 799 */ 800if(pos < istate->cache_nr &&ce_stage(ce) ==0) { 801while(ce_same_name(istate->cache[pos], ce)) { 802 ok_to_add =1; 803if(!remove_index_entry_at(istate, pos)) 804break; 805} 806} 807 808if(!ok_to_add) 809return-1; 810if(!verify_path(ce->name)) 811return-1; 812 813if(!skip_df_check && 814check_file_directory_conflict(istate, ce, pos, ok_to_replace)) { 815if(!ok_to_replace) 816returnerror("'%s' appears as both a file and as a directory", 817 ce->name); 818 pos =index_name_pos(istate, ce->name, ce->ce_flags); 819 pos = -pos-1; 820} 821return pos +1; 822} 823 824intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option) 825{ 826int pos; 827 828if(option & ADD_CACHE_JUST_APPEND) 829 pos = istate->cache_nr; 830else{ 831int ret; 832 ret =add_index_entry_with_check(istate, ce, option); 833if(ret <=0) 834return ret; 835 pos = ret -1; 836} 837 838/* Make sure the array is big enough .. */ 839if(istate->cache_nr == istate->cache_alloc) { 840 istate->cache_alloc =alloc_nr(istate->cache_alloc); 841 istate->cache =xrealloc(istate->cache, 842 istate->cache_alloc *sizeof(struct cache_entry *)); 843} 844 845/* Add it in.. */ 846 istate->cache_nr++; 847if(istate->cache_nr > pos +1) 848memmove(istate->cache + pos +1, 849 istate->cache + pos, 850(istate->cache_nr - pos -1) *sizeof(ce)); 851set_index_entry(istate, pos, ce); 852 istate->cache_changed =1; 853return0; 854} 855 856/* 857 * "refresh" does not calculate a new sha1 file or bring the 858 * cache up-to-date for mode/content changes. But what it 859 * _does_ do is to "re-match" the stat information of a file 860 * with the cache, so that you can refresh the cache for a 861 * file that hasn't been changed but where the stat entry is 862 * out of date. 863 * 864 * For example, you'd want to do this after doing a "git-read-tree", 865 * to link up the stat cache details with the proper files. 866 */ 867static struct cache_entry *refresh_cache_ent(struct index_state *istate, 868struct cache_entry *ce, 869unsigned int options,int*err) 870{ 871struct stat st; 872struct cache_entry *updated; 873int changed, size; 874int ignore_valid = options & CE_MATCH_IGNORE_VALID; 875 876if(ce_uptodate(ce)) 877return ce; 878 879if(lstat(ce->name, &st) <0) { 880if(err) 881*err = errno; 882return NULL; 883} 884 885 changed =ie_match_stat(istate, ce, &st, options); 886if(!changed) { 887/* 888 * The path is unchanged. If we were told to ignore 889 * valid bit, then we did the actual stat check and 890 * found that the entry is unmodified. If the entry 891 * is not marked VALID, this is the place to mark it 892 * valid again, under "assume unchanged" mode. 893 */ 894if(ignore_valid && assume_unchanged && 895!(ce->ce_flags & CE_VALID)) 896;/* mark this one VALID again */ 897else{ 898/* 899 * We do not mark the index itself "modified" 900 * because CE_UPTODATE flag is in-core only; 901 * we are not going to write this change out. 902 */ 903ce_mark_uptodate(ce); 904return ce; 905} 906} 907 908if(ie_modified(istate, ce, &st, options)) { 909if(err) 910*err = EINVAL; 911return NULL; 912} 913 914 size =ce_size(ce); 915 updated =xmalloc(size); 916memcpy(updated, ce, size); 917fill_stat_cache_info(updated, &st); 918/* 919 * If ignore_valid is not set, we should leave CE_VALID bit 920 * alone. Otherwise, paths marked with --no-assume-unchanged 921 * (i.e. things to be edited) will reacquire CE_VALID bit 922 * automatically, which is not really what we want. 923 */ 924if(!ignore_valid && assume_unchanged && 925!(ce->ce_flags & CE_VALID)) 926 updated->ce_flags &= ~CE_VALID; 927 928return updated; 929} 930 931intrefresh_index(struct index_state *istate,unsigned int flags,const char**pathspec,char*seen) 932{ 933int i; 934int has_errors =0; 935int really = (flags & REFRESH_REALLY) !=0; 936int allow_unmerged = (flags & REFRESH_UNMERGED) !=0; 937int quiet = (flags & REFRESH_QUIET) !=0; 938int not_new = (flags & REFRESH_IGNORE_MISSING) !=0; 939unsigned int options = really ? CE_MATCH_IGNORE_VALID :0; 940 941for(i =0; i < istate->cache_nr; i++) { 942struct cache_entry *ce, *new; 943int cache_errno =0; 944 945 ce = istate->cache[i]; 946if(ce_stage(ce)) { 947while((i < istate->cache_nr) && 948!strcmp(istate->cache[i]->name, ce->name)) 949 i++; 950 i--; 951if(allow_unmerged) 952continue; 953printf("%s: needs merge\n", ce->name); 954 has_errors =1; 955continue; 956} 957 958if(pathspec && !match_pathspec(pathspec, ce->name,strlen(ce->name),0, seen)) 959continue; 960 961new=refresh_cache_ent(istate, ce, options, &cache_errno); 962if(new== ce) 963continue; 964if(!new) { 965if(not_new && cache_errno == ENOENT) 966continue; 967if(really && cache_errno == EINVAL) { 968/* If we are doing --really-refresh that 969 * means the index is not valid anymore. 970 */ 971 ce->ce_flags &= ~CE_VALID; 972 istate->cache_changed =1; 973} 974if(quiet) 975continue; 976printf("%s: needs update\n", ce->name); 977 has_errors =1; 978continue; 979} 980 981replace_index_entry(istate, i,new); 982} 983return has_errors; 984} 985 986struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really) 987{ 988returnrefresh_cache_ent(&the_index, ce, really, NULL); 989} 990 991static intverify_hdr(struct cache_header *hdr,unsigned long size) 992{ 993 SHA_CTX c; 994unsigned char sha1[20]; 995 996if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE)) 997returnerror("bad signature"); 998if(hdr->hdr_version !=htonl(2)) 999returnerror("bad index version");1000SHA1_Init(&c);1001SHA1_Update(&c, hdr, size -20);1002SHA1_Final(sha1, &c);1003if(hashcmp(sha1, (unsigned char*)hdr + size -20))1004returnerror("bad index file sha1 signature");1005return0;1006}10071008static intread_index_extension(struct index_state *istate,1009const char*ext,void*data,unsigned long sz)1010{1011switch(CACHE_EXT(ext)) {1012case CACHE_EXT_TREE:1013 istate->cache_tree =cache_tree_read(data, sz);1014break;1015default:1016if(*ext <'A'||'Z'< *ext)1017returnerror("index uses %.4s extension, which we do not understand",1018 ext);1019fprintf(stderr,"ignoring %.4s extension\n", ext);1020break;1021}1022return0;1023}10241025intread_index(struct index_state *istate)1026{1027returnread_index_from(istate,get_index_file());1028}10291030static voidconvert_from_disk(struct ondisk_cache_entry *ondisk,struct cache_entry *ce)1031{1032size_t len;10331034 ce->ce_ctime =ntohl(ondisk->ctime.sec);1035 ce->ce_mtime =ntohl(ondisk->mtime.sec);1036 ce->ce_dev =ntohl(ondisk->dev);1037 ce->ce_ino =ntohl(ondisk->ino);1038 ce->ce_mode =ntohl(ondisk->mode);1039 ce->ce_uid =ntohl(ondisk->uid);1040 ce->ce_gid =ntohl(ondisk->gid);1041 ce->ce_size =ntohl(ondisk->size);1042/* On-disk flags are just 16 bits */1043 ce->ce_flags =ntohs(ondisk->flags);1044hashcpy(ce->sha1, ondisk->sha1);10451046 len = ce->ce_flags & CE_NAMEMASK;1047if(len == CE_NAMEMASK)1048 len =strlen(ondisk->name);1049/*1050 * NEEDSWORK: If the original index is crafted, this copy could1051 * go unchecked.1052 */1053memcpy(ce->name, ondisk->name, len +1);1054}10551056staticinlinesize_testimate_cache_size(size_t ondisk_size,unsigned int entries)1057{1058long per_entry;10591060 per_entry =sizeof(struct cache_entry) -sizeof(struct ondisk_cache_entry);10611062/*1063 * Alignment can cause differences. This should be "alignof", but1064 * since that's a gcc'ism, just use the size of a pointer.1065 */1066 per_entry +=sizeof(void*);1067return ondisk_size + entries*per_entry;1068}10691070/* remember to discard_cache() before reading a different cache! */1071intread_index_from(struct index_state *istate,const char*path)1072{1073int fd, i;1074struct stat st;1075unsigned long src_offset, dst_offset;1076struct cache_header *hdr;1077void*mmap;1078size_t mmap_size;10791080 errno = EBUSY;1081if(istate->alloc)1082return istate->cache_nr;10831084 errno = ENOENT;1085 istate->timestamp =0;1086 fd =open(path, O_RDONLY);1087if(fd <0) {1088if(errno == ENOENT)1089return0;1090die("index file open failed (%s)",strerror(errno));1091}10921093if(fstat(fd, &st))1094die("cannot stat the open index (%s)",strerror(errno));10951096 errno = EINVAL;1097 mmap_size =xsize_t(st.st_size);1098if(mmap_size <sizeof(struct cache_header) +20)1099die("index file smaller than expected");11001101 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1102close(fd);1103if(mmap == MAP_FAILED)1104die("unable to map index file");11051106 hdr = mmap;1107if(verify_hdr(hdr, mmap_size) <0)1108goto unmap;11091110 istate->cache_nr =ntohl(hdr->hdr_entries);1111 istate->cache_alloc =alloc_nr(istate->cache_nr);1112 istate->cache =xcalloc(istate->cache_alloc,sizeof(struct cache_entry *));11131114/*1115 * The disk format is actually larger than the in-memory format,1116 * due to space for nsec etc, so even though the in-memory one1117 * has room for a few more flags, we can allocate using the same1118 * index size1119 */1120 istate->alloc =xmalloc(estimate_cache_size(mmap_size, istate->cache_nr));11211122 src_offset =sizeof(*hdr);1123 dst_offset =0;1124for(i =0; i < istate->cache_nr; i++) {1125struct ondisk_cache_entry *disk_ce;1126struct cache_entry *ce;11271128 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1129 ce = (struct cache_entry *)((char*)istate->alloc + dst_offset);1130convert_from_disk(disk_ce, ce);1131set_index_entry(istate, i, ce);11321133 src_offset +=ondisk_ce_size(ce);1134 dst_offset +=ce_size(ce);1135}1136 istate->timestamp = st.st_mtime;1137while(src_offset <= mmap_size -20-8) {1138/* After an array of active_nr index entries,1139 * there can be arbitrary number of extended1140 * sections, each of which is prefixed with1141 * extension name (4-byte) and section length1142 * in 4-byte network byte order.1143 */1144unsigned long extsize;1145memcpy(&extsize, (char*)mmap + src_offset +4,4);1146 extsize =ntohl(extsize);1147if(read_index_extension(istate,1148(const char*) mmap + src_offset,1149(char*) mmap + src_offset +8,1150 extsize) <0)1151goto unmap;1152 src_offset +=8;1153 src_offset += extsize;1154}1155munmap(mmap, mmap_size);1156return istate->cache_nr;11571158unmap:1159munmap(mmap, mmap_size);1160 errno = EINVAL;1161die("index file corrupt");1162}11631164intdiscard_index(struct index_state *istate)1165{1166 istate->cache_nr =0;1167 istate->cache_changed =0;1168 istate->timestamp =0;1169free_hash(&istate->name_hash);1170cache_tree_free(&(istate->cache_tree));1171free(istate->alloc);1172 istate->alloc = NULL;11731174/* no need to throw away allocated active_cache */1175return0;1176}11771178intunmerged_index(const struct index_state *istate)1179{1180int i;1181for(i =0; i < istate->cache_nr; i++) {1182if(ce_stage(istate->cache[i]))1183return1;1184}1185return0;1186}11871188#define WRITE_BUFFER_SIZE 81921189static unsigned char write_buffer[WRITE_BUFFER_SIZE];1190static unsigned long write_buffer_len;11911192static intce_write_flush(SHA_CTX *context,int fd)1193{1194unsigned int buffered = write_buffer_len;1195if(buffered) {1196SHA1_Update(context, write_buffer, buffered);1197if(write_in_full(fd, write_buffer, buffered) != buffered)1198return-1;1199 write_buffer_len =0;1200}1201return0;1202}12031204static intce_write(SHA_CTX *context,int fd,void*data,unsigned int len)1205{1206while(len) {1207unsigned int buffered = write_buffer_len;1208unsigned int partial = WRITE_BUFFER_SIZE - buffered;1209if(partial > len)1210 partial = len;1211memcpy(write_buffer + buffered, data, partial);1212 buffered += partial;1213if(buffered == WRITE_BUFFER_SIZE) {1214 write_buffer_len = buffered;1215if(ce_write_flush(context, fd))1216return-1;1217 buffered =0;1218}1219 write_buffer_len = buffered;1220 len -= partial;1221 data = (char*) data + partial;1222}1223return0;1224}12251226static intwrite_index_ext_header(SHA_CTX *context,int fd,1227unsigned int ext,unsigned int sz)1228{1229 ext =htonl(ext);1230 sz =htonl(sz);1231return((ce_write(context, fd, &ext,4) <0) ||1232(ce_write(context, fd, &sz,4) <0)) ? -1:0;1233}12341235static intce_flush(SHA_CTX *context,int fd)1236{1237unsigned int left = write_buffer_len;12381239if(left) {1240 write_buffer_len =0;1241SHA1_Update(context, write_buffer, left);1242}12431244/* Flush first if not enough space for SHA1 signature */1245if(left +20> WRITE_BUFFER_SIZE) {1246if(write_in_full(fd, write_buffer, left) != left)1247return-1;1248 left =0;1249}12501251/* Append the SHA1 signature at the end */1252SHA1_Final(write_buffer + left, context);1253 left +=20;1254return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1255}12561257static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1258{1259/*1260 * The only thing we care about in this function is to smudge the1261 * falsely clean entry due to touch-update-touch race, so we leave1262 * everything else as they are. We are called for entries whose1263 * ce_mtime match the index file mtime.1264 */1265struct stat st;12661267if(lstat(ce->name, &st) <0)1268return;1269if(ce_match_stat_basic(ce, &st))1270return;1271if(ce_modified_check_fs(ce, &st)) {1272/* This is "racily clean"; smudge it. Note that this1273 * is a tricky code. At first glance, it may appear1274 * that it can break with this sequence:1275 *1276 * $ echo xyzzy >frotz1277 * $ git-update-index --add frotz1278 * $ : >frotz1279 * $ sleep 31280 * $ echo filfre >nitfol1281 * $ git-update-index --add nitfol1282 *1283 * but it does not. When the second update-index runs,1284 * it notices that the entry "frotz" has the same timestamp1285 * as index, and if we were to smudge it by resetting its1286 * size to zero here, then the object name recorded1287 * in index is the 6-byte file but the cached stat information1288 * becomes zero --- which would then match what we would1289 * obtain from the filesystem next time we stat("frotz").1290 *1291 * However, the second update-index, before calling1292 * this function, notices that the cached size is 61293 * bytes and what is on the filesystem is an empty1294 * file, and never calls us, so the cached size information1295 * for "frotz" stays 6 which does not match the filesystem.1296 */1297 ce->ce_size =0;1298}1299}13001301static intce_write_entry(SHA_CTX *c,int fd,struct cache_entry *ce)1302{1303int size =ondisk_ce_size(ce);1304struct ondisk_cache_entry *ondisk =xcalloc(1, size);13051306 ondisk->ctime.sec =htonl(ce->ce_ctime);1307 ondisk->ctime.nsec =0;1308 ondisk->mtime.sec =htonl(ce->ce_mtime);1309 ondisk->mtime.nsec =0;1310 ondisk->dev =htonl(ce->ce_dev);1311 ondisk->ino =htonl(ce->ce_ino);1312 ondisk->mode =htonl(ce->ce_mode);1313 ondisk->uid =htonl(ce->ce_uid);1314 ondisk->gid =htonl(ce->ce_gid);1315 ondisk->size =htonl(ce->ce_size);1316hashcpy(ondisk->sha1, ce->sha1);1317 ondisk->flags =htons(ce->ce_flags);1318memcpy(ondisk->name, ce->name,ce_namelen(ce));13191320returnce_write(c, fd, ondisk, size);1321}13221323intwrite_index(const struct index_state *istate,int newfd)1324{1325 SHA_CTX c;1326struct cache_header hdr;1327int i, err, removed;1328struct cache_entry **cache = istate->cache;1329int entries = istate->cache_nr;13301331for(i = removed =0; i < entries; i++)1332if(cache[i]->ce_flags & CE_REMOVE)1333 removed++;13341335 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1336 hdr.hdr_version =htonl(2);1337 hdr.hdr_entries =htonl(entries - removed);13381339SHA1_Init(&c);1340if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1341return-1;13421343for(i =0; i < entries; i++) {1344struct cache_entry *ce = cache[i];1345if(ce->ce_flags & CE_REMOVE)1346continue;1347if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1348ce_smudge_racily_clean_entry(ce);1349if(ce_write_entry(&c, newfd, ce) <0)1350return-1;1351}13521353/* Write extension data here */1354if(istate->cache_tree) {1355struct strbuf sb;13561357strbuf_init(&sb,0);1358cache_tree_write(&sb, istate->cache_tree);1359 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01360||ce_write(&c, newfd, sb.buf, sb.len) <0;1361strbuf_release(&sb);1362if(err)1363return-1;1364}1365returnce_flush(&c, newfd);1366}