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#include"tree.h" 12#include"commit.h" 13#include"blob.h" 14#include"resolve-undo.h" 15#include"strbuf.h" 16#include"varint.h" 17 18static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really); 19 20/* Mask for the name length in ce_flags in the on-disk index */ 21 22#define CE_NAMEMASK (0x0fff) 23 24/* Index extensions. 25 * 26 * The first letter should be 'A'..'Z' for extensions that are not 27 * necessary for a correct operation (i.e. optimization data). 28 * When new extensions are added that _needs_ to be understood in 29 * order to correctly interpret the index file, pick character that 30 * is outside the range, to cause the reader to abort. 31 */ 32 33#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 34#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 35#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUC" */ 36 37struct index_state the_index; 38 39static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 40{ 41 istate->cache[nr] = ce; 42add_name_hash(istate, ce); 43} 44 45static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 46{ 47struct cache_entry *old = istate->cache[nr]; 48 49remove_name_hash(old); 50set_index_entry(istate, nr, ce); 51 istate->cache_changed =1; 52} 53 54voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 55{ 56struct cache_entry *old = istate->cache[nr], *new; 57int namelen =strlen(new_name); 58 59new=xmalloc(cache_entry_size(namelen)); 60copy_cache_entry(new, old); 61new->ce_flags &= ~CE_STATE_MASK; 62new->ce_namelen = namelen; 63memcpy(new->name, new_name, namelen +1); 64 65cache_tree_invalidate_path(istate->cache_tree, old->name); 66remove_index_entry_at(istate, nr); 67add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 68} 69 70/* 71 * This only updates the "non-critical" parts of the directory 72 * cache, ie the parts that aren't tracked by GIT, and only used 73 * to validate the cache. 74 */ 75voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 76{ 77 ce->ce_ctime.sec = (unsigned int)st->st_ctime; 78 ce->ce_mtime.sec = (unsigned int)st->st_mtime; 79 ce->ce_ctime.nsec =ST_CTIME_NSEC(*st); 80 ce->ce_mtime.nsec =ST_MTIME_NSEC(*st); 81 ce->ce_dev = st->st_dev; 82 ce->ce_ino = st->st_ino; 83 ce->ce_uid = st->st_uid; 84 ce->ce_gid = st->st_gid; 85 ce->ce_size = st->st_size; 86 87if(assume_unchanged) 88 ce->ce_flags |= CE_VALID; 89 90if(S_ISREG(st->st_mode)) 91ce_mark_uptodate(ce); 92} 93 94static intce_compare_data(struct cache_entry *ce,struct stat *st) 95{ 96int match = -1; 97int fd =open(ce->name, O_RDONLY); 98 99if(fd >=0) { 100unsigned char sha1[20]; 101if(!index_fd(sha1, fd, st, OBJ_BLOB, ce->name,0)) 102 match =hashcmp(sha1, ce->sha1); 103/* index_fd() closed the file descriptor already */ 104} 105return match; 106} 107 108static intce_compare_link(struct cache_entry *ce,size_t expected_size) 109{ 110int match = -1; 111void*buffer; 112unsigned long size; 113enum object_type type; 114struct strbuf sb = STRBUF_INIT; 115 116if(strbuf_readlink(&sb, ce->name, expected_size)) 117return-1; 118 119 buffer =read_sha1_file(ce->sha1, &type, &size); 120if(buffer) { 121if(size == sb.len) 122 match =memcmp(buffer, sb.buf, size); 123free(buffer); 124} 125strbuf_release(&sb); 126return match; 127} 128 129static intce_compare_gitlink(struct cache_entry *ce) 130{ 131unsigned char sha1[20]; 132 133/* 134 * We don't actually require that the .git directory 135 * under GITLINK directory be a valid git directory. It 136 * might even be missing (in case nobody populated that 137 * sub-project). 138 * 139 * If so, we consider it always to match. 140 */ 141if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 142return0; 143returnhashcmp(sha1, ce->sha1); 144} 145 146static intce_modified_check_fs(struct cache_entry *ce,struct stat *st) 147{ 148switch(st->st_mode & S_IFMT) { 149case S_IFREG: 150if(ce_compare_data(ce, st)) 151return DATA_CHANGED; 152break; 153case S_IFLNK: 154if(ce_compare_link(ce,xsize_t(st->st_size))) 155return DATA_CHANGED; 156break; 157case S_IFDIR: 158if(S_ISGITLINK(ce->ce_mode)) 159returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 160default: 161return TYPE_CHANGED; 162} 163return0; 164} 165 166static intce_match_stat_basic(struct cache_entry *ce,struct stat *st) 167{ 168unsigned int changed =0; 169 170if(ce->ce_flags & CE_REMOVE) 171return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 172 173switch(ce->ce_mode & S_IFMT) { 174case S_IFREG: 175 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 176/* We consider only the owner x bit to be relevant for 177 * "mode changes" 178 */ 179if(trust_executable_bit && 180(0100& (ce->ce_mode ^ st->st_mode))) 181 changed |= MODE_CHANGED; 182break; 183case S_IFLNK: 184if(!S_ISLNK(st->st_mode) && 185(has_symlinks || !S_ISREG(st->st_mode))) 186 changed |= TYPE_CHANGED; 187break; 188case S_IFGITLINK: 189/* We ignore most of the st_xxx fields for gitlinks */ 190if(!S_ISDIR(st->st_mode)) 191 changed |= TYPE_CHANGED; 192else if(ce_compare_gitlink(ce)) 193 changed |= DATA_CHANGED; 194return changed; 195default: 196die("internal error: ce_mode is%o", ce->ce_mode); 197} 198if(ce->ce_mtime.sec != (unsigned int)st->st_mtime) 199 changed |= MTIME_CHANGED; 200if(trust_ctime && ce->ce_ctime.sec != (unsigned int)st->st_ctime) 201 changed |= CTIME_CHANGED; 202 203#ifdef USE_NSEC 204if(ce->ce_mtime.nsec !=ST_MTIME_NSEC(*st)) 205 changed |= MTIME_CHANGED; 206if(trust_ctime && ce->ce_ctime.nsec !=ST_CTIME_NSEC(*st)) 207 changed |= CTIME_CHANGED; 208#endif 209 210if(ce->ce_uid != (unsigned int) st->st_uid || 211 ce->ce_gid != (unsigned int) st->st_gid) 212 changed |= OWNER_CHANGED; 213if(ce->ce_ino != (unsigned int) st->st_ino) 214 changed |= INODE_CHANGED; 215 216#ifdef USE_STDEV 217/* 218 * st_dev breaks on network filesystems where different 219 * clients will have different views of what "device" 220 * the filesystem is on 221 */ 222if(ce->ce_dev != (unsigned int) st->st_dev) 223 changed |= INODE_CHANGED; 224#endif 225 226if(ce->ce_size != (unsigned int) st->st_size) 227 changed |= DATA_CHANGED; 228 229/* Racily smudged entry? */ 230if(!ce->ce_size) { 231if(!is_empty_blob_sha1(ce->sha1)) 232 changed |= DATA_CHANGED; 233} 234 235return changed; 236} 237 238static intis_racy_timestamp(const struct index_state *istate,struct cache_entry *ce) 239{ 240return(!S_ISGITLINK(ce->ce_mode) && 241 istate->timestamp.sec && 242#ifdef USE_NSEC 243/* nanosecond timestamped files can also be racy! */ 244(istate->timestamp.sec < ce->ce_mtime.sec || 245(istate->timestamp.sec == ce->ce_mtime.sec && 246 istate->timestamp.nsec <= ce->ce_mtime.nsec)) 247#else 248 istate->timestamp.sec <= ce->ce_mtime.sec 249#endif 250); 251} 252 253intie_match_stat(const struct index_state *istate, 254struct cache_entry *ce,struct stat *st, 255unsigned int options) 256{ 257unsigned int changed; 258int ignore_valid = options & CE_MATCH_IGNORE_VALID; 259int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 260int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 261 262/* 263 * If it's marked as always valid in the index, it's 264 * valid whatever the checked-out copy says. 265 * 266 * skip-worktree has the same effect with higher precedence 267 */ 268if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 269return0; 270if(!ignore_valid && (ce->ce_flags & CE_VALID)) 271return0; 272 273/* 274 * Intent-to-add entries have not been added, so the index entry 275 * by definition never matches what is in the work tree until it 276 * actually gets added. 277 */ 278if(ce->ce_flags & CE_INTENT_TO_ADD) 279return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 280 281 changed =ce_match_stat_basic(ce, st); 282 283/* 284 * Within 1 second of this sequence: 285 * echo xyzzy >file && git-update-index --add file 286 * running this command: 287 * echo frotz >file 288 * would give a falsely clean cache entry. The mtime and 289 * length match the cache, and other stat fields do not change. 290 * 291 * We could detect this at update-index time (the cache entry 292 * being registered/updated records the same time as "now") 293 * and delay the return from git-update-index, but that would 294 * effectively mean we can make at most one commit per second, 295 * which is not acceptable. Instead, we check cache entries 296 * whose mtime are the same as the index file timestamp more 297 * carefully than others. 298 */ 299if(!changed &&is_racy_timestamp(istate, ce)) { 300if(assume_racy_is_modified) 301 changed |= DATA_CHANGED; 302else 303 changed |=ce_modified_check_fs(ce, st); 304} 305 306return changed; 307} 308 309intie_modified(const struct index_state *istate, 310struct cache_entry *ce,struct stat *st,unsigned int options) 311{ 312int changed, changed_fs; 313 314 changed =ie_match_stat(istate, ce, st, options); 315if(!changed) 316return0; 317/* 318 * If the mode or type has changed, there's no point in trying 319 * to refresh the entry - it's not going to match 320 */ 321if(changed & (MODE_CHANGED | TYPE_CHANGED)) 322return changed; 323 324/* 325 * Immediately after read-tree or update-index --cacheinfo, 326 * the length field is zero, as we have never even read the 327 * lstat(2) information once, and we cannot trust DATA_CHANGED 328 * returned by ie_match_stat() which in turn was returned by 329 * ce_match_stat_basic() to signal that the filesize of the 330 * blob changed. We have to actually go to the filesystem to 331 * see if the contents match, and if so, should answer "unchanged". 332 * 333 * The logic does not apply to gitlinks, as ce_match_stat_basic() 334 * already has checked the actual HEAD from the filesystem in the 335 * subproject. If ie_match_stat() already said it is different, 336 * then we know it is. 337 */ 338if((changed & DATA_CHANGED) && 339(S_ISGITLINK(ce->ce_mode) || ce->ce_size !=0)) 340return changed; 341 342 changed_fs =ce_modified_check_fs(ce, st); 343if(changed_fs) 344return changed | changed_fs; 345return0; 346} 347 348intbase_name_compare(const char*name1,int len1,int mode1, 349const char*name2,int len2,int mode2) 350{ 351unsigned char c1, c2; 352int len = len1 < len2 ? len1 : len2; 353int cmp; 354 355 cmp =memcmp(name1, name2, len); 356if(cmp) 357return cmp; 358 c1 = name1[len]; 359 c2 = name2[len]; 360if(!c1 &&S_ISDIR(mode1)) 361 c1 ='/'; 362if(!c2 &&S_ISDIR(mode2)) 363 c2 ='/'; 364return(c1 < c2) ? -1: (c1 > c2) ?1:0; 365} 366 367/* 368 * df_name_compare() is identical to base_name_compare(), except it 369 * compares conflicting directory/file entries as equal. Note that 370 * while a directory name compares as equal to a regular file, they 371 * then individually compare _differently_ to a filename that has 372 * a dot after the basename (because '\0' < '.' < '/'). 373 * 374 * This is used by routines that want to traverse the git namespace 375 * but then handle conflicting entries together when possible. 376 */ 377intdf_name_compare(const char*name1,int len1,int mode1, 378const char*name2,int len2,int mode2) 379{ 380int len = len1 < len2 ? len1 : len2, cmp; 381unsigned char c1, c2; 382 383 cmp =memcmp(name1, name2, len); 384if(cmp) 385return cmp; 386/* Directories and files compare equal (same length, same name) */ 387if(len1 == len2) 388return0; 389 c1 = name1[len]; 390if(!c1 &&S_ISDIR(mode1)) 391 c1 ='/'; 392 c2 = name2[len]; 393if(!c2 &&S_ISDIR(mode2)) 394 c2 ='/'; 395if(c1 =='/'&& !c2) 396return0; 397if(c2 =='/'&& !c1) 398return0; 399return c1 - c2; 400} 401 402intcache_name_stage_compare(const char*name1,int len1,int stage1,const char*name2,int len2,int stage2) 403{ 404int len = len1 < len2 ? len1 : len2; 405int cmp; 406 407 cmp =memcmp(name1, name2, len); 408if(cmp) 409return cmp; 410if(len1 < len2) 411return-1; 412if(len1 > len2) 413return1; 414 415if(stage1 < stage2) 416return-1; 417if(stage1 > stage2) 418return1; 419return0; 420} 421 422intcache_name_compare(const char*name1,int len1,const char*name2,int len2) 423{ 424returncache_name_stage_compare(name1, len1,0, name2, len2,0); 425} 426 427intindex_name_stage_pos(const struct index_state *istate,const char*name,int namelen,int stage) 428{ 429int first, last; 430 431 first =0; 432 last = istate->cache_nr; 433while(last > first) { 434int next = (last + first) >>1; 435struct cache_entry *ce = istate->cache[next]; 436int cmp =cache_name_stage_compare(name, namelen, stage, ce->name,ce_namelen(ce),ce_stage(ce)); 437if(!cmp) 438return next; 439if(cmp <0) { 440 last = next; 441continue; 442} 443 first = next+1; 444} 445return-first-1; 446} 447 448intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 449{ 450returnindex_name_stage_pos(istate, name, namelen,0); 451} 452 453/* Remove entry, return true if there are more entries to go.. */ 454intremove_index_entry_at(struct index_state *istate,int pos) 455{ 456struct cache_entry *ce = istate->cache[pos]; 457 458record_resolve_undo(istate, ce); 459remove_name_hash(ce); 460 istate->cache_changed =1; 461 istate->cache_nr--; 462if(pos >= istate->cache_nr) 463return0; 464memmove(istate->cache + pos, 465 istate->cache + pos +1, 466(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 467return1; 468} 469 470/* 471 * Remove all cache ententries marked for removal, that is where 472 * CE_REMOVE is set in ce_flags. This is much more effective than 473 * calling remove_index_entry_at() for each entry to be removed. 474 */ 475voidremove_marked_cache_entries(struct index_state *istate) 476{ 477struct cache_entry **ce_array = istate->cache; 478unsigned int i, j; 479 480for(i = j =0; i < istate->cache_nr; i++) { 481if(ce_array[i]->ce_flags & CE_REMOVE) 482remove_name_hash(ce_array[i]); 483else 484 ce_array[j++] = ce_array[i]; 485} 486 istate->cache_changed =1; 487 istate->cache_nr = j; 488} 489 490intremove_file_from_index(struct index_state *istate,const char*path) 491{ 492int pos =index_name_pos(istate, path,strlen(path)); 493if(pos <0) 494 pos = -pos-1; 495cache_tree_invalidate_path(istate->cache_tree, path); 496while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 497remove_index_entry_at(istate, pos); 498return0; 499} 500 501static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 502{ 503return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 504} 505 506static intindex_name_pos_also_unmerged(struct index_state *istate, 507const char*path,int namelen) 508{ 509int pos =index_name_pos(istate, path, namelen); 510struct cache_entry *ce; 511 512if(pos >=0) 513return pos; 514 515/* maybe unmerged? */ 516 pos = -1- pos; 517if(pos >= istate->cache_nr || 518compare_name((ce = istate->cache[pos]), path, namelen)) 519return-1; 520 521/* order of preference: stage 2, 1, 3 */ 522if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 523ce_stage((ce = istate->cache[pos +1])) ==2&& 524!compare_name(ce, path, namelen)) 525 pos++; 526return pos; 527} 528 529static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 530{ 531int len =ce_namelen(ce); 532returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 533} 534 535/* 536 * If we add a filename that aliases in the cache, we will use the 537 * name that we already have - but we don't want to update the same 538 * alias twice, because that implies that there were actually two 539 * different files with aliasing names! 540 * 541 * So we use the CE_ADDED flag to verify that the alias was an old 542 * one before we accept it as 543 */ 544static struct cache_entry *create_alias_ce(struct cache_entry *ce,struct cache_entry *alias) 545{ 546int len; 547struct cache_entry *new; 548 549if(alias->ce_flags & CE_ADDED) 550die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 551 552/* Ok, create the new entry using the name of the existing alias */ 553 len =ce_namelen(alias); 554new=xcalloc(1,cache_entry_size(len)); 555memcpy(new->name, alias->name, len); 556copy_cache_entry(new, ce); 557free(ce); 558return new; 559} 560 561static voidrecord_intent_to_add(struct cache_entry *ce) 562{ 563unsigned char sha1[20]; 564if(write_sha1_file("",0, blob_type, sha1)) 565die("cannot create an empty blob in the object database"); 566hashcpy(ce->sha1, sha1); 567} 568 569intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 570{ 571int size, namelen, was_same; 572 mode_t st_mode = st->st_mode; 573struct cache_entry *ce, *alias; 574unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 575int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 576int pretend = flags & ADD_CACHE_PRETEND; 577int intent_only = flags & ADD_CACHE_INTENT; 578int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 579(intent_only ? ADD_CACHE_NEW_ONLY :0)); 580 581if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 582returnerror("%s: can only add regular files, symbolic links or git-directories", path); 583 584 namelen =strlen(path); 585if(S_ISDIR(st_mode)) { 586while(namelen && path[namelen-1] =='/') 587 namelen--; 588} 589 size =cache_entry_size(namelen); 590 ce =xcalloc(1, size); 591memcpy(ce->name, path, namelen); 592 ce->ce_namelen = namelen; 593if(!intent_only) 594fill_stat_cache_info(ce, st); 595else 596 ce->ce_flags |= CE_INTENT_TO_ADD; 597 598if(trust_executable_bit && has_symlinks) 599 ce->ce_mode =create_ce_mode(st_mode); 600else{ 601/* If there is an existing entry, pick the mode bits and type 602 * from it, otherwise assume unexecutable regular file. 603 */ 604struct cache_entry *ent; 605int pos =index_name_pos_also_unmerged(istate, path, namelen); 606 607 ent = (0<= pos) ? istate->cache[pos] : NULL; 608 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 609} 610 611/* When core.ignorecase=true, determine if a directory of the same name but differing 612 * case already exists within the Git repository. If it does, ensure the directory 613 * case of the file being added to the repository matches (is folded into) the existing 614 * entry's directory case. 615 */ 616if(ignore_case) { 617const char*startPtr = ce->name; 618const char*ptr = startPtr; 619while(*ptr) { 620while(*ptr && *ptr !='/') 621++ptr; 622if(*ptr =='/') { 623struct cache_entry *foundce; 624++ptr; 625 foundce =index_name_exists(&the_index, ce->name, ptr - ce->name, ignore_case); 626if(foundce) { 627memcpy((void*)startPtr, foundce->name + (startPtr - ce->name), ptr - startPtr); 628 startPtr = ptr; 629} 630} 631} 632} 633 634 alias =index_name_exists(istate, ce->name,ce_namelen(ce), ignore_case); 635if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 636/* Nothing changed, really */ 637free(ce); 638if(!S_ISGITLINK(alias->ce_mode)) 639ce_mark_uptodate(alias); 640 alias->ce_flags |= CE_ADDED; 641return0; 642} 643if(!intent_only) { 644if(index_path(ce->sha1, path, st, HASH_WRITE_OBJECT)) 645returnerror("unable to index file%s", path); 646}else 647record_intent_to_add(ce); 648 649if(ignore_case && alias &&different_name(ce, alias)) 650 ce =create_alias_ce(ce, alias); 651 ce->ce_flags |= CE_ADDED; 652 653/* It was suspected to be racily clean, but it turns out to be Ok */ 654 was_same = (alias && 655!ce_stage(alias) && 656!hashcmp(alias->sha1, ce->sha1) && 657 ce->ce_mode == alias->ce_mode); 658 659if(pretend) 660; 661else if(add_index_entry(istate, ce, add_option)) 662returnerror("unable to add%sto index",path); 663if(verbose && !was_same) 664printf("add '%s'\n", path); 665return0; 666} 667 668intadd_file_to_index(struct index_state *istate,const char*path,int flags) 669{ 670struct stat st; 671if(lstat(path, &st)) 672die_errno("unable to stat '%s'", path); 673returnadd_to_index(istate, path, &st, flags); 674} 675 676struct cache_entry *make_cache_entry(unsigned int mode, 677const unsigned char*sha1,const char*path,int stage, 678int refresh) 679{ 680int size, len; 681struct cache_entry *ce; 682 683if(!verify_path(path)) { 684error("Invalid path '%s'", path); 685return NULL; 686} 687 688 len =strlen(path); 689 size =cache_entry_size(len); 690 ce =xcalloc(1, size); 691 692hashcpy(ce->sha1, sha1); 693memcpy(ce->name, path, len); 694 ce->ce_flags =create_ce_flags(stage); 695 ce->ce_namelen = len; 696 ce->ce_mode =create_ce_mode(mode); 697 698if(refresh) 699returnrefresh_cache_entry(ce,0); 700 701return ce; 702} 703 704intce_same_name(struct cache_entry *a,struct cache_entry *b) 705{ 706int len =ce_namelen(a); 707returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 708} 709 710intce_path_match(const struct cache_entry *ce,const struct pathspec *pathspec) 711{ 712returnmatch_pathspec_depth(pathspec, ce->name,ce_namelen(ce),0, NULL); 713} 714 715/* 716 * We fundamentally don't like some paths: we don't want 717 * dot or dot-dot anywhere, and for obvious reasons don't 718 * want to recurse into ".git" either. 719 * 720 * Also, we don't want double slashes or slashes at the 721 * end that can make pathnames ambiguous. 722 */ 723static intverify_dotfile(const char*rest) 724{ 725/* 726 * The first character was '.', but that 727 * has already been discarded, we now test 728 * the rest. 729 */ 730 731/* "." is not allowed */ 732if(*rest =='\0'||is_dir_sep(*rest)) 733return0; 734 735switch(*rest) { 736/* 737 * ".git" followed by NUL or slash is bad. This 738 * shares the path end test with the ".." case. 739 */ 740case'g': 741if(rest[1] !='i') 742break; 743if(rest[2] !='t') 744break; 745 rest +=2; 746/* fallthrough */ 747case'.': 748if(rest[1] =='\0'||is_dir_sep(rest[1])) 749return0; 750} 751return1; 752} 753 754intverify_path(const char*path) 755{ 756char c; 757 758if(has_dos_drive_prefix(path)) 759return0; 760 761goto inside; 762for(;;) { 763if(!c) 764return1; 765if(is_dir_sep(c)) { 766inside: 767 c = *path++; 768if((c =='.'&& !verify_dotfile(path)) || 769is_dir_sep(c) || c =='\0') 770return0; 771} 772 c = *path++; 773} 774} 775 776/* 777 * Do we have another file that has the beginning components being a 778 * proper superset of the name we're trying to add? 779 */ 780static inthas_file_name(struct index_state *istate, 781const struct cache_entry *ce,int pos,int ok_to_replace) 782{ 783int retval =0; 784int len =ce_namelen(ce); 785int stage =ce_stage(ce); 786const char*name = ce->name; 787 788while(pos < istate->cache_nr) { 789struct cache_entry *p = istate->cache[pos++]; 790 791if(len >=ce_namelen(p)) 792break; 793if(memcmp(name, p->name, len)) 794break; 795if(ce_stage(p) != stage) 796continue; 797if(p->name[len] !='/') 798continue; 799if(p->ce_flags & CE_REMOVE) 800continue; 801 retval = -1; 802if(!ok_to_replace) 803break; 804remove_index_entry_at(istate, --pos); 805} 806return retval; 807} 808 809/* 810 * Do we have another file with a pathname that is a proper 811 * subset of the name we're trying to add? 812 */ 813static inthas_dir_name(struct index_state *istate, 814const struct cache_entry *ce,int pos,int ok_to_replace) 815{ 816int retval =0; 817int stage =ce_stage(ce); 818const char*name = ce->name; 819const char*slash = name +ce_namelen(ce); 820 821for(;;) { 822int len; 823 824for(;;) { 825if(*--slash =='/') 826break; 827if(slash <= ce->name) 828return retval; 829} 830 len = slash - name; 831 832 pos =index_name_stage_pos(istate, name, len, stage); 833if(pos >=0) { 834/* 835 * Found one, but not so fast. This could 836 * be a marker that says "I was here, but 837 * I am being removed". Such an entry is 838 * not a part of the resulting tree, and 839 * it is Ok to have a directory at the same 840 * path. 841 */ 842if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 843 retval = -1; 844if(!ok_to_replace) 845break; 846remove_index_entry_at(istate, pos); 847continue; 848} 849} 850else 851 pos = -pos-1; 852 853/* 854 * Trivial optimization: if we find an entry that 855 * already matches the sub-directory, then we know 856 * we're ok, and we can exit. 857 */ 858while(pos < istate->cache_nr) { 859struct cache_entry *p = istate->cache[pos]; 860if((ce_namelen(p) <= len) || 861(p->name[len] !='/') || 862memcmp(p->name, name, len)) 863break;/* not our subdirectory */ 864if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 865/* 866 * p is at the same stage as our entry, and 867 * is a subdirectory of what we are looking 868 * at, so we cannot have conflicts at our 869 * level or anything shorter. 870 */ 871return retval; 872 pos++; 873} 874} 875return retval; 876} 877 878/* We may be in a situation where we already have path/file and path 879 * is being added, or we already have path and path/file is being 880 * added. Either one would result in a nonsense tree that has path 881 * twice when git-write-tree tries to write it out. Prevent it. 882 * 883 * If ok-to-replace is specified, we remove the conflicting entries 884 * from the cache so the caller should recompute the insert position. 885 * When this happens, we return non-zero. 886 */ 887static intcheck_file_directory_conflict(struct index_state *istate, 888const struct cache_entry *ce, 889int pos,int ok_to_replace) 890{ 891int retval; 892 893/* 894 * When ce is an "I am going away" entry, we allow it to be added 895 */ 896if(ce->ce_flags & CE_REMOVE) 897return0; 898 899/* 900 * We check if the path is a sub-path of a subsequent pathname 901 * first, since removing those will not change the position 902 * in the array. 903 */ 904 retval =has_file_name(istate, ce, pos, ok_to_replace); 905 906/* 907 * Then check if the path might have a clashing sub-directory 908 * before it. 909 */ 910return retval +has_dir_name(istate, ce, pos, ok_to_replace); 911} 912 913static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option) 914{ 915int pos; 916int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 917int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 918int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 919int new_only = option & ADD_CACHE_NEW_ONLY; 920 921cache_tree_invalidate_path(istate->cache_tree, ce->name); 922 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 923 924/* existing match? Just replace it. */ 925if(pos >=0) { 926if(!new_only) 927replace_index_entry(istate, pos, ce); 928return0; 929} 930 pos = -pos-1; 931 932/* 933 * Inserting a merged entry ("stage 0") into the index 934 * will always replace all non-merged entries.. 935 */ 936if(pos < istate->cache_nr &&ce_stage(ce) ==0) { 937while(ce_same_name(istate->cache[pos], ce)) { 938 ok_to_add =1; 939if(!remove_index_entry_at(istate, pos)) 940break; 941} 942} 943 944if(!ok_to_add) 945return-1; 946if(!verify_path(ce->name)) 947returnerror("Invalid path '%s'", ce->name); 948 949if(!skip_df_check && 950check_file_directory_conflict(istate, ce, pos, ok_to_replace)) { 951if(!ok_to_replace) 952returnerror("'%s' appears as both a file and as a directory", 953 ce->name); 954 pos =index_name_stage_pos(istate, ce->name,ce_namelen(ce),ce_stage(ce)); 955 pos = -pos-1; 956} 957return pos +1; 958} 959 960intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option) 961{ 962int pos; 963 964if(option & ADD_CACHE_JUST_APPEND) 965 pos = istate->cache_nr; 966else{ 967int ret; 968 ret =add_index_entry_with_check(istate, ce, option); 969if(ret <=0) 970return ret; 971 pos = ret -1; 972} 973 974/* Make sure the array is big enough .. */ 975if(istate->cache_nr == istate->cache_alloc) { 976 istate->cache_alloc =alloc_nr(istate->cache_alloc); 977 istate->cache =xrealloc(istate->cache, 978 istate->cache_alloc *sizeof(struct cache_entry *)); 979} 980 981/* Add it in.. */ 982 istate->cache_nr++; 983if(istate->cache_nr > pos +1) 984memmove(istate->cache + pos +1, 985 istate->cache + pos, 986(istate->cache_nr - pos -1) *sizeof(ce)); 987set_index_entry(istate, pos, ce); 988 istate->cache_changed =1; 989return0; 990} 991 992/* 993 * "refresh" does not calculate a new sha1 file or bring the 994 * cache up-to-date for mode/content changes. But what it 995 * _does_ do is to "re-match" the stat information of a file 996 * with the cache, so that you can refresh the cache for a 997 * file that hasn't been changed but where the stat entry is 998 * out of date. 999 *1000 * For example, you'd want to do this after doing a "git-read-tree",1001 * to link up the stat cache details with the proper files.1002 */1003static struct cache_entry *refresh_cache_ent(struct index_state *istate,1004struct cache_entry *ce,1005unsigned int options,int*err,1006int*changed_ret)1007{1008struct stat st;1009struct cache_entry *updated;1010int changed, size;1011int ignore_valid = options & CE_MATCH_IGNORE_VALID;1012int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;10131014if(ce_uptodate(ce))1015return ce;10161017/*1018 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1019 * that the change to the work tree does not matter and told1020 * us not to worry.1021 */1022if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1023ce_mark_uptodate(ce);1024return ce;1025}1026if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1027ce_mark_uptodate(ce);1028return ce;1029}10301031if(lstat(ce->name, &st) <0) {1032if(err)1033*err = errno;1034return NULL;1035}10361037 changed =ie_match_stat(istate, ce, &st, options);1038if(changed_ret)1039*changed_ret = changed;1040if(!changed) {1041/*1042 * The path is unchanged. If we were told to ignore1043 * valid bit, then we did the actual stat check and1044 * found that the entry is unmodified. If the entry1045 * is not marked VALID, this is the place to mark it1046 * valid again, under "assume unchanged" mode.1047 */1048if(ignore_valid && assume_unchanged &&1049!(ce->ce_flags & CE_VALID))1050;/* mark this one VALID again */1051else{1052/*1053 * We do not mark the index itself "modified"1054 * because CE_UPTODATE flag is in-core only;1055 * we are not going to write this change out.1056 */1057if(!S_ISGITLINK(ce->ce_mode))1058ce_mark_uptodate(ce);1059return ce;1060}1061}10621063if(ie_modified(istate, ce, &st, options)) {1064if(err)1065*err = EINVAL;1066return NULL;1067}10681069 size =ce_size(ce);1070 updated =xmalloc(size);1071memcpy(updated, ce, size);1072fill_stat_cache_info(updated, &st);1073/*1074 * If ignore_valid is not set, we should leave CE_VALID bit1075 * alone. Otherwise, paths marked with --no-assume-unchanged1076 * (i.e. things to be edited) will reacquire CE_VALID bit1077 * automatically, which is not really what we want.1078 */1079if(!ignore_valid && assume_unchanged &&1080!(ce->ce_flags & CE_VALID))1081 updated->ce_flags &= ~CE_VALID;10821083return updated;1084}10851086static voidshow_file(const char* fmt,const char* name,int in_porcelain,1087int* first,const char*header_msg)1088{1089if(in_porcelain && *first && header_msg) {1090printf("%s\n", header_msg);1091*first =0;1092}1093printf(fmt, name);1094}10951096intrefresh_index(struct index_state *istate,unsigned int flags,const char**pathspec,1097char*seen,const char*header_msg)1098{1099int i;1100int has_errors =0;1101int really = (flags & REFRESH_REALLY) !=0;1102int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1103int quiet = (flags & REFRESH_QUIET) !=0;1104int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1105int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1106int first =1;1107int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1108unsigned int options = really ? CE_MATCH_IGNORE_VALID :0;1109const char*modified_fmt;1110const char*deleted_fmt;1111const char*typechange_fmt;1112const char*added_fmt;1113const char*unmerged_fmt;11141115 modified_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1116 deleted_fmt = (in_porcelain ?"D\t%s\n":"%s: needs update\n");1117 typechange_fmt = (in_porcelain ?"T\t%s\n":"%sneeds update\n");1118 added_fmt = (in_porcelain ?"A\t%s\n":"%sneeds update\n");1119 unmerged_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1120for(i =0; i < istate->cache_nr; i++) {1121struct cache_entry *ce, *new;1122int cache_errno =0;1123int changed =0;1124int filtered =0;11251126 ce = istate->cache[i];1127if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1128continue;11291130if(pathspec &&1131!match_pathspec(pathspec, ce->name,ce_namelen(ce),0, seen))1132 filtered =1;11331134if(ce_stage(ce)) {1135while((i < istate->cache_nr) &&1136!strcmp(istate->cache[i]->name, ce->name))1137 i++;1138 i--;1139if(allow_unmerged)1140continue;1141if(!filtered)1142show_file(unmerged_fmt, ce->name, in_porcelain,1143&first, header_msg);1144 has_errors =1;1145continue;1146}11471148if(filtered)1149continue;11501151new=refresh_cache_ent(istate, ce, options, &cache_errno, &changed);1152if(new== ce)1153continue;1154if(!new) {1155const char*fmt;11561157if(not_new && cache_errno == ENOENT)1158continue;1159if(really && cache_errno == EINVAL) {1160/* If we are doing --really-refresh that1161 * means the index is not valid anymore.1162 */1163 ce->ce_flags &= ~CE_VALID;1164 istate->cache_changed =1;1165}1166if(quiet)1167continue;11681169if(cache_errno == ENOENT)1170 fmt = deleted_fmt;1171else if(ce->ce_flags & CE_INTENT_TO_ADD)1172 fmt = added_fmt;/* must be before other checks */1173else if(changed & TYPE_CHANGED)1174 fmt = typechange_fmt;1175else1176 fmt = modified_fmt;1177show_file(fmt,1178 ce->name, in_porcelain, &first, header_msg);1179 has_errors =1;1180continue;1181}11821183replace_index_entry(istate, i,new);1184}1185return has_errors;1186}11871188static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really)1189{1190returnrefresh_cache_ent(&the_index, ce, really, NULL, NULL);1191}119211931194/*****************************************************************1195 * Index File I/O1196 *****************************************************************/11971198#define INDEX_FORMAT_DEFAULT 311991200/*1201 * dev/ino/uid/gid/size are also just tracked to the low 32 bits1202 * Again - this is just a (very strong in practice) heuristic that1203 * the inode hasn't changed.1204 *1205 * We save the fields in big-endian order to allow using the1206 * index file over NFS transparently.1207 */1208struct ondisk_cache_entry {1209struct cache_time ctime;1210struct cache_time mtime;1211unsigned int dev;1212unsigned int ino;1213unsigned int mode;1214unsigned int uid;1215unsigned int gid;1216unsigned int size;1217unsigned char sha1[20];1218unsigned short flags;1219char name[FLEX_ARRAY];/* more */1220};12211222/*1223 * This struct is used when CE_EXTENDED bit is 11224 * The struct must match ondisk_cache_entry exactly from1225 * ctime till flags1226 */1227struct ondisk_cache_entry_extended {1228struct cache_time ctime;1229struct cache_time mtime;1230unsigned int dev;1231unsigned int ino;1232unsigned int mode;1233unsigned int uid;1234unsigned int gid;1235unsigned int size;1236unsigned char sha1[20];1237unsigned short flags;1238unsigned short flags2;1239char name[FLEX_ARRAY];/* more */1240};12411242/* These are only used for v3 or lower */1243#define align_flex_name(STRUCT,len) ((offsetof(struct STRUCT,name) + (len) + 8) & ~7)1244#define ondisk_cache_entry_size(len) align_flex_name(ondisk_cache_entry,len)1245#define ondisk_cache_entry_extended_size(len) align_flex_name(ondisk_cache_entry_extended,len)1246#define ondisk_ce_size(ce) (((ce)->ce_flags & CE_EXTENDED) ? \1247 ondisk_cache_entry_extended_size(ce_namelen(ce)) : \1248 ondisk_cache_entry_size(ce_namelen(ce)))12491250static intverify_hdr(struct cache_header *hdr,unsigned long size)1251{1252 git_SHA_CTX c;1253unsigned char sha1[20];1254int hdr_version;12551256if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1257returnerror("bad signature");1258 hdr_version =ntohl(hdr->hdr_version);1259if(hdr_version <2||4< hdr_version)1260returnerror("bad index version%d", hdr_version);1261git_SHA1_Init(&c);1262git_SHA1_Update(&c, hdr, size -20);1263git_SHA1_Final(sha1, &c);1264if(hashcmp(sha1, (unsigned char*)hdr + size -20))1265returnerror("bad index file sha1 signature");1266return0;1267}12681269static intread_index_extension(struct index_state *istate,1270const char*ext,void*data,unsigned long sz)1271{1272switch(CACHE_EXT(ext)) {1273case CACHE_EXT_TREE:1274 istate->cache_tree =cache_tree_read(data, sz);1275break;1276case CACHE_EXT_RESOLVE_UNDO:1277 istate->resolve_undo =resolve_undo_read(data, sz);1278break;1279default:1280if(*ext <'A'||'Z'< *ext)1281returnerror("index uses %.4s extension, which we do not understand",1282 ext);1283fprintf(stderr,"ignoring %.4s extension\n", ext);1284break;1285}1286return0;1287}12881289intread_index(struct index_state *istate)1290{1291returnread_index_from(istate,get_index_file());1292}12931294#ifndef NEEDS_ALIGNED_ACCESS1295#define ntoh_s(var) ntohs(var)1296#define ntoh_l(var) ntohl(var)1297#else1298staticinlineuint16_tntoh_s_force_align(void*p)1299{1300uint16_t x;1301memcpy(&x, p,sizeof(x));1302returnntohs(x);1303}1304staticinlineuint32_tntoh_l_force_align(void*p)1305{1306uint32_t x;1307memcpy(&x, p,sizeof(x));1308returnntohl(x);1309}1310#define ntoh_s(var) ntoh_s_force_align(&(var))1311#define ntoh_l(var) ntoh_l_force_align(&(var))1312#endif13131314static struct cache_entry *cache_entry_from_ondisk(struct ondisk_cache_entry *ondisk,1315unsigned int flags,1316const char*name,1317size_t len)1318{1319struct cache_entry *ce =xmalloc(cache_entry_size(len));13201321 ce->ce_ctime.sec =ntoh_l(ondisk->ctime.sec);1322 ce->ce_mtime.sec =ntoh_l(ondisk->mtime.sec);1323 ce->ce_ctime.nsec =ntoh_l(ondisk->ctime.nsec);1324 ce->ce_mtime.nsec =ntoh_l(ondisk->mtime.nsec);1325 ce->ce_dev =ntoh_l(ondisk->dev);1326 ce->ce_ino =ntoh_l(ondisk->ino);1327 ce->ce_mode =ntoh_l(ondisk->mode);1328 ce->ce_uid =ntoh_l(ondisk->uid);1329 ce->ce_gid =ntoh_l(ondisk->gid);1330 ce->ce_size =ntoh_l(ondisk->size);1331 ce->ce_flags = flags & ~CE_NAMEMASK;1332 ce->ce_namelen = len;1333hashcpy(ce->sha1, ondisk->sha1);1334memcpy(ce->name, name, len);1335 ce->name[len] ='\0';1336return ce;1337}13381339/*1340 * Adjacent cache entries tend to share the leading paths, so it makes1341 * sense to only store the differences in later entries. In the v41342 * on-disk format of the index, each on-disk cache entry stores the1343 * number of bytes to be stripped from the end of the previous name,1344 * and the bytes to append to the result, to come up with its name.1345 */1346static unsigned longexpand_name_field(struct strbuf *name,const char*cp_)1347{1348const unsigned char*ep, *cp = (const unsigned char*)cp_;1349size_t len =decode_varint(&cp);13501351if(name->len < len)1352die("malformed name field in the index");1353strbuf_remove(name, name->len - len, len);1354for(ep = cp; *ep; ep++)1355;/* find the end */1356strbuf_add(name, cp, ep - cp);1357return(const char*)ep +1- cp_;1358}13591360static struct cache_entry *create_from_disk(struct ondisk_cache_entry *ondisk,1361unsigned long*ent_size,1362struct strbuf *previous_name)1363{1364struct cache_entry *ce;1365size_t len;1366const char*name;1367unsigned int flags;13681369/* On-disk flags are just 16 bits */1370 flags =ntoh_s(ondisk->flags);1371 len = flags & CE_NAMEMASK;13721373if(flags & CE_EXTENDED) {1374struct ondisk_cache_entry_extended *ondisk2;1375int extended_flags;1376 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1377 extended_flags =ntoh_s(ondisk2->flags2) <<16;1378/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1379if(extended_flags & ~CE_EXTENDED_FLAGS)1380die("Unknown index entry format%08x", extended_flags);1381 flags |= extended_flags;1382 name = ondisk2->name;1383}1384else1385 name = ondisk->name;13861387if(!previous_name) {1388/* v3 and earlier */1389if(len == CE_NAMEMASK)1390 len =strlen(name);1391 ce =cache_entry_from_ondisk(ondisk, flags, name, len);13921393*ent_size =ondisk_ce_size(ce);1394}else{1395unsigned long consumed;1396 consumed =expand_name_field(previous_name, name);1397 ce =cache_entry_from_ondisk(ondisk, flags,1398 previous_name->buf,1399 previous_name->len);14001401*ent_size = (name - ((char*)ondisk)) + consumed;1402}1403return ce;1404}14051406/* remember to discard_cache() before reading a different cache! */1407intread_index_from(struct index_state *istate,const char*path)1408{1409int fd, i;1410struct stat st;1411unsigned long src_offset;1412struct cache_header *hdr;1413void*mmap;1414size_t mmap_size;1415struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;14161417if(istate->initialized)1418return istate->cache_nr;14191420 istate->timestamp.sec =0;1421 istate->timestamp.nsec =0;1422 fd =open(path, O_RDONLY);1423if(fd <0) {1424if(errno == ENOENT)1425return0;1426die_errno("index file open failed");1427}14281429if(fstat(fd, &st))1430die_errno("cannot stat the open index");14311432 mmap_size =xsize_t(st.st_size);1433if(mmap_size <sizeof(struct cache_header) +20)1434die("index file smaller than expected");14351436 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1437if(mmap == MAP_FAILED)1438die_errno("unable to map index file");1439close(fd);14401441 hdr = mmap;1442if(verify_hdr(hdr, mmap_size) <0)1443goto unmap;14441445 istate->version =ntohl(hdr->hdr_version);1446 istate->cache_nr =ntohl(hdr->hdr_entries);1447 istate->cache_alloc =alloc_nr(istate->cache_nr);1448 istate->cache =xcalloc(istate->cache_alloc,sizeof(struct cache_entry *));1449 istate->initialized =1;14501451if(istate->version ==4)1452 previous_name = &previous_name_buf;1453else1454 previous_name = NULL;14551456 src_offset =sizeof(*hdr);1457for(i =0; i < istate->cache_nr; i++) {1458struct ondisk_cache_entry *disk_ce;1459struct cache_entry *ce;1460unsigned long consumed;14611462 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1463 ce =create_from_disk(disk_ce, &consumed, previous_name);1464set_index_entry(istate, i, ce);14651466 src_offset += consumed;1467}1468strbuf_release(&previous_name_buf);1469 istate->timestamp.sec = st.st_mtime;1470 istate->timestamp.nsec =ST_MTIME_NSEC(st);14711472while(src_offset <= mmap_size -20-8) {1473/* After an array of active_nr index entries,1474 * there can be arbitrary number of extended1475 * sections, each of which is prefixed with1476 * extension name (4-byte) and section length1477 * in 4-byte network byte order.1478 */1479uint32_t extsize;1480memcpy(&extsize, (char*)mmap + src_offset +4,4);1481 extsize =ntohl(extsize);1482if(read_index_extension(istate,1483(const char*) mmap + src_offset,1484(char*) mmap + src_offset +8,1485 extsize) <0)1486goto unmap;1487 src_offset +=8;1488 src_offset += extsize;1489}1490munmap(mmap, mmap_size);1491return istate->cache_nr;14921493unmap:1494munmap(mmap, mmap_size);1495die("index file corrupt");1496}14971498intis_index_unborn(struct index_state *istate)1499{1500return(!istate->cache_nr && !istate->timestamp.sec);1501}15021503intdiscard_index(struct index_state *istate)1504{1505int i;15061507for(i =0; i < istate->cache_nr; i++)1508free(istate->cache[i]);1509resolve_undo_clear_index(istate);1510 istate->cache_nr =0;1511 istate->cache_changed =0;1512 istate->timestamp.sec =0;1513 istate->timestamp.nsec =0;1514 istate->name_hash_initialized =0;1515free_hash(&istate->name_hash);1516cache_tree_free(&(istate->cache_tree));1517 istate->initialized =0;15181519/* no need to throw away allocated active_cache */1520return0;1521}15221523intunmerged_index(const struct index_state *istate)1524{1525int i;1526for(i =0; i < istate->cache_nr; i++) {1527if(ce_stage(istate->cache[i]))1528return1;1529}1530return0;1531}15321533#define WRITE_BUFFER_SIZE 81921534static unsigned char write_buffer[WRITE_BUFFER_SIZE];1535static unsigned long write_buffer_len;15361537static intce_write_flush(git_SHA_CTX *context,int fd)1538{1539unsigned int buffered = write_buffer_len;1540if(buffered) {1541git_SHA1_Update(context, write_buffer, buffered);1542if(write_in_full(fd, write_buffer, buffered) != buffered)1543return-1;1544 write_buffer_len =0;1545}1546return0;1547}15481549static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1550{1551while(len) {1552unsigned int buffered = write_buffer_len;1553unsigned int partial = WRITE_BUFFER_SIZE - buffered;1554if(partial > len)1555 partial = len;1556memcpy(write_buffer + buffered, data, partial);1557 buffered += partial;1558if(buffered == WRITE_BUFFER_SIZE) {1559 write_buffer_len = buffered;1560if(ce_write_flush(context, fd))1561return-1;1562 buffered =0;1563}1564 write_buffer_len = buffered;1565 len -= partial;1566 data = (char*) data + partial;1567}1568return0;1569}15701571static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1572unsigned int ext,unsigned int sz)1573{1574 ext =htonl(ext);1575 sz =htonl(sz);1576return((ce_write(context, fd, &ext,4) <0) ||1577(ce_write(context, fd, &sz,4) <0)) ? -1:0;1578}15791580static intce_flush(git_SHA_CTX *context,int fd)1581{1582unsigned int left = write_buffer_len;15831584if(left) {1585 write_buffer_len =0;1586git_SHA1_Update(context, write_buffer, left);1587}15881589/* Flush first if not enough space for SHA1 signature */1590if(left +20> WRITE_BUFFER_SIZE) {1591if(write_in_full(fd, write_buffer, left) != left)1592return-1;1593 left =0;1594}15951596/* Append the SHA1 signature at the end */1597git_SHA1_Final(write_buffer + left, context);1598 left +=20;1599return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1600}16011602static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1603{1604/*1605 * The only thing we care about in this function is to smudge the1606 * falsely clean entry due to touch-update-touch race, so we leave1607 * everything else as they are. We are called for entries whose1608 * ce_mtime match the index file mtime.1609 *1610 * Note that this actually does not do much for gitlinks, for1611 * which ce_match_stat_basic() always goes to the actual1612 * contents. The caller checks with is_racy_timestamp() which1613 * always says "no" for gitlinks, so we are not called for them ;-)1614 */1615struct stat st;16161617if(lstat(ce->name, &st) <0)1618return;1619if(ce_match_stat_basic(ce, &st))1620return;1621if(ce_modified_check_fs(ce, &st)) {1622/* This is "racily clean"; smudge it. Note that this1623 * is a tricky code. At first glance, it may appear1624 * that it can break with this sequence:1625 *1626 * $ echo xyzzy >frotz1627 * $ git-update-index --add frotz1628 * $ : >frotz1629 * $ sleep 31630 * $ echo filfre >nitfol1631 * $ git-update-index --add nitfol1632 *1633 * but it does not. When the second update-index runs,1634 * it notices that the entry "frotz" has the same timestamp1635 * as index, and if we were to smudge it by resetting its1636 * size to zero here, then the object name recorded1637 * in index is the 6-byte file but the cached stat information1638 * becomes zero --- which would then match what we would1639 * obtain from the filesystem next time we stat("frotz").1640 *1641 * However, the second update-index, before calling1642 * this function, notices that the cached size is 61643 * bytes and what is on the filesystem is an empty1644 * file, and never calls us, so the cached size information1645 * for "frotz" stays 6 which does not match the filesystem.1646 */1647 ce->ce_size =0;1648}1649}16501651/* Copy miscellaneous fields but not the name */1652static char*copy_cache_entry_to_ondisk(struct ondisk_cache_entry *ondisk,1653struct cache_entry *ce)1654{1655short flags;16561657 ondisk->ctime.sec =htonl(ce->ce_ctime.sec);1658 ondisk->mtime.sec =htonl(ce->ce_mtime.sec);1659 ondisk->ctime.nsec =htonl(ce->ce_ctime.nsec);1660 ondisk->mtime.nsec =htonl(ce->ce_mtime.nsec);1661 ondisk->dev =htonl(ce->ce_dev);1662 ondisk->ino =htonl(ce->ce_ino);1663 ondisk->mode =htonl(ce->ce_mode);1664 ondisk->uid =htonl(ce->ce_uid);1665 ondisk->gid =htonl(ce->ce_gid);1666 ondisk->size =htonl(ce->ce_size);1667hashcpy(ondisk->sha1, ce->sha1);16681669 flags = ce->ce_flags;1670 flags |= (ce_namelen(ce) >= CE_NAMEMASK ? CE_NAMEMASK :ce_namelen(ce));1671 ondisk->flags =htons(flags);1672if(ce->ce_flags & CE_EXTENDED) {1673struct ondisk_cache_entry_extended *ondisk2;1674 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1675 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1676return ondisk2->name;1677}1678else{1679return ondisk->name;1680}1681}16821683static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce,1684struct strbuf *previous_name)1685{1686int size;1687struct ondisk_cache_entry *ondisk;1688char*name;1689int result;16901691if(!previous_name) {1692 size =ondisk_ce_size(ce);1693 ondisk =xcalloc(1, size);1694 name =copy_cache_entry_to_ondisk(ondisk, ce);1695memcpy(name, ce->name,ce_namelen(ce));1696}else{1697int common, to_remove, prefix_size;1698unsigned char to_remove_vi[16];1699for(common =0;1700(ce->name[common] &&1701 common < previous_name->len &&1702 ce->name[common] == previous_name->buf[common]);1703 common++)1704;/* still matching */1705 to_remove = previous_name->len - common;1706 prefix_size =encode_varint(to_remove, to_remove_vi);17071708if(ce->ce_flags & CE_EXTENDED)1709 size =offsetof(struct ondisk_cache_entry_extended, name);1710else1711 size =offsetof(struct ondisk_cache_entry, name);1712 size += prefix_size + (ce_namelen(ce) - common +1);17131714 ondisk =xcalloc(1, size);1715 name =copy_cache_entry_to_ondisk(ondisk, ce);1716memcpy(name, to_remove_vi, prefix_size);1717memcpy(name + prefix_size, ce->name + common,ce_namelen(ce) - common);17181719strbuf_splice(previous_name, common, to_remove,1720 ce->name + common,ce_namelen(ce) - common);1721}17221723 result =ce_write(c, fd, ondisk, size);1724free(ondisk);1725return result;1726}17271728static inthas_racy_timestamp(struct index_state *istate)1729{1730int entries = istate->cache_nr;1731int i;17321733for(i =0; i < entries; i++) {1734struct cache_entry *ce = istate->cache[i];1735if(is_racy_timestamp(istate, ce))1736return1;1737}1738return0;1739}17401741/*1742 * Opportunisticly update the index but do not complain if we can't1743 */1744voidupdate_index_if_able(struct index_state *istate,struct lock_file *lockfile)1745{1746if((istate->cache_changed ||has_racy_timestamp(istate)) &&1747!write_index(istate, lockfile->fd))1748commit_locked_index(lockfile);1749else1750rollback_lock_file(lockfile);1751}17521753intwrite_index(struct index_state *istate,int newfd)1754{1755 git_SHA_CTX c;1756struct cache_header hdr;1757int i, err, removed, extended, hdr_version;1758struct cache_entry **cache = istate->cache;1759int entries = istate->cache_nr;1760struct stat st;1761struct strbuf previous_name_buf = STRBUF_INIT, *previous_name;17621763for(i = removed = extended =0; i < entries; i++) {1764if(cache[i]->ce_flags & CE_REMOVE)1765 removed++;17661767/* reduce extended entries if possible */1768 cache[i]->ce_flags &= ~CE_EXTENDED;1769if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {1770 extended++;1771 cache[i]->ce_flags |= CE_EXTENDED;1772}1773}17741775if(!istate->version)1776 istate->version = INDEX_FORMAT_DEFAULT;17771778/* demote version 3 to version 2 when the latter suffices */1779if(istate->version ==3|| istate->version ==2)1780 istate->version = extended ?3:2;17811782 hdr_version = istate->version;17831784 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1785 hdr.hdr_version =htonl(hdr_version);1786 hdr.hdr_entries =htonl(entries - removed);17871788git_SHA1_Init(&c);1789if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1790return-1;17911792 previous_name = (hdr_version ==4) ? &previous_name_buf : NULL;1793for(i =0; i < entries; i++) {1794struct cache_entry *ce = cache[i];1795if(ce->ce_flags & CE_REMOVE)1796continue;1797if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1798ce_smudge_racily_clean_entry(ce);1799if(is_null_sha1(ce->sha1))1800returnerror("cache entry has null sha1:%s", ce->name);1801if(ce_write_entry(&c, newfd, ce, previous_name) <0)1802return-1;1803}1804strbuf_release(&previous_name_buf);18051806/* Write extension data here */1807if(istate->cache_tree) {1808struct strbuf sb = STRBUF_INIT;18091810cache_tree_write(&sb, istate->cache_tree);1811 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01812||ce_write(&c, newfd, sb.buf, sb.len) <0;1813strbuf_release(&sb);1814if(err)1815return-1;1816}1817if(istate->resolve_undo) {1818struct strbuf sb = STRBUF_INIT;18191820resolve_undo_write(&sb, istate->resolve_undo);1821 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,1822 sb.len) <01823||ce_write(&c, newfd, sb.buf, sb.len) <0;1824strbuf_release(&sb);1825if(err)1826return-1;1827}18281829if(ce_flush(&c, newfd) ||fstat(newfd, &st))1830return-1;1831 istate->timestamp.sec = (unsigned int)st.st_mtime;1832 istate->timestamp.nsec =ST_MTIME_NSEC(st);1833return0;1834}18351836/*1837 * Read the index file that is potentially unmerged into given1838 * index_state, dropping any unmerged entries. Returns true if1839 * the index is unmerged. Callers who want to refuse to work1840 * from an unmerged state can call this and check its return value,1841 * instead of calling read_cache().1842 */1843intread_index_unmerged(struct index_state *istate)1844{1845int i;1846int unmerged =0;18471848read_index(istate);1849for(i =0; i < istate->cache_nr; i++) {1850struct cache_entry *ce = istate->cache[i];1851struct cache_entry *new_ce;1852int size, len;18531854if(!ce_stage(ce))1855continue;1856 unmerged =1;1857 len =ce_namelen(ce);1858 size =cache_entry_size(len);1859 new_ce =xcalloc(1, size);1860memcpy(new_ce->name, ce->name, len);1861 new_ce->ce_flags =create_ce_flags(0) | CE_CONFLICTED;1862 new_ce->ce_namelen = len;1863 new_ce->ce_mode = ce->ce_mode;1864if(add_index_entry(istate, new_ce,0))1865returnerror("%s: cannot drop to stage #0",1866 ce->name);1867 i =index_name_pos(istate, new_ce->name, len);1868}1869return unmerged;1870}18711872/*1873 * Returns 1 if the path is an "other" path with respect to1874 * the index; that is, the path is not mentioned in the index at all,1875 * either as a file, a directory with some files in the index,1876 * or as an unmerged entry.1877 *1878 * We helpfully remove a trailing "/" from directories so that1879 * the output of read_directory can be used as-is.1880 */1881intindex_name_is_other(const struct index_state *istate,const char*name,1882int namelen)1883{1884int pos;1885if(namelen && name[namelen -1] =='/')1886 namelen--;1887 pos =index_name_pos(istate, name, namelen);1888if(0<= pos)1889return0;/* exact match */1890 pos = -pos -1;1891if(pos < istate->cache_nr) {1892struct cache_entry *ce = istate->cache[pos];1893if(ce_namelen(ce) == namelen &&1894!memcmp(ce->name, name, namelen))1895return0;/* Yup, this one exists unmerged */1896}1897return1;1898}