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"diff.h" 14#include"diffcore.h" 15#include"revision.h" 16#include"blob.h" 17#include"resolve-undo.h" 18 19static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really); 20 21/* Index extensions. 22 * 23 * The first letter should be 'A'..'Z' for extensions that are not 24 * necessary for a correct operation (i.e. optimization data). 25 * When new extensions are added that _needs_ to be understood in 26 * order to correctly interpret the index file, pick character that 27 * is outside the range, to cause the reader to abort. 28 */ 29 30#define CACHE_EXT(s) ( (s[0]<<24)|(s[1]<<16)|(s[2]<<8)|(s[3]) ) 31#define CACHE_EXT_TREE 0x54524545/* "TREE" */ 32#define CACHE_EXT_RESOLVE_UNDO 0x52455543/* "REUN" */ 33 34struct index_state the_index; 35 36static voidset_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 37{ 38 istate->cache[nr] = ce; 39add_name_hash(istate, ce); 40} 41 42static voidreplace_index_entry(struct index_state *istate,int nr,struct cache_entry *ce) 43{ 44struct cache_entry *old = istate->cache[nr]; 45 46remove_name_hash(old); 47set_index_entry(istate, nr, ce); 48 istate->cache_changed =1; 49} 50 51voidrename_index_entry_at(struct index_state *istate,int nr,const char*new_name) 52{ 53struct cache_entry *old = istate->cache[nr], *new; 54int namelen =strlen(new_name); 55 56new=xmalloc(cache_entry_size(namelen)); 57copy_cache_entry(new, old); 58new->ce_flags &= ~(CE_STATE_MASK | CE_NAMEMASK); 59new->ce_flags |= (namelen >= CE_NAMEMASK ? CE_NAMEMASK : namelen); 60memcpy(new->name, new_name, namelen +1); 61 62cache_tree_invalidate_path(istate->cache_tree, old->name); 63remove_index_entry_at(istate, nr); 64add_index_entry(istate,new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE); 65} 66 67/* 68 * This only updates the "non-critical" parts of the directory 69 * cache, ie the parts that aren't tracked by GIT, and only used 70 * to validate the cache. 71 */ 72voidfill_stat_cache_info(struct cache_entry *ce,struct stat *st) 73{ 74 ce->ce_ctime.sec = (unsigned int)st->st_ctime; 75 ce->ce_mtime.sec = (unsigned int)st->st_mtime; 76 ce->ce_ctime.nsec =ST_CTIME_NSEC(*st); 77 ce->ce_mtime.nsec =ST_MTIME_NSEC(*st); 78 ce->ce_dev = st->st_dev; 79 ce->ce_ino = st->st_ino; 80 ce->ce_uid = st->st_uid; 81 ce->ce_gid = st->st_gid; 82 ce->ce_size = st->st_size; 83 84if(assume_unchanged) 85 ce->ce_flags |= CE_VALID; 86 87if(S_ISREG(st->st_mode)) 88ce_mark_uptodate(ce); 89} 90 91static intce_compare_data(struct cache_entry *ce,struct stat *st) 92{ 93int match = -1; 94int fd =open(ce->name, O_RDONLY); 95 96if(fd >=0) { 97unsigned char sha1[20]; 98if(!index_fd(sha1, fd, st,0, OBJ_BLOB, ce->name)) 99 match =hashcmp(sha1, ce->sha1); 100/* index_fd() closed the file descriptor already */ 101} 102return match; 103} 104 105static intce_compare_link(struct cache_entry *ce,size_t expected_size) 106{ 107int match = -1; 108void*buffer; 109unsigned long size; 110enum object_type type; 111struct strbuf sb = STRBUF_INIT; 112 113if(strbuf_readlink(&sb, ce->name, expected_size)) 114return-1; 115 116 buffer =read_sha1_file(ce->sha1, &type, &size); 117if(buffer) { 118if(size == sb.len) 119 match =memcmp(buffer, sb.buf, size); 120free(buffer); 121} 122strbuf_release(&sb); 123return match; 124} 125 126static intce_compare_gitlink(struct cache_entry *ce) 127{ 128unsigned char sha1[20]; 129 130/* 131 * We don't actually require that the .git directory 132 * under GITLINK directory be a valid git directory. It 133 * might even be missing (in case nobody populated that 134 * sub-project). 135 * 136 * If so, we consider it always to match. 137 */ 138if(resolve_gitlink_ref(ce->name,"HEAD", sha1) <0) 139return0; 140returnhashcmp(sha1, ce->sha1); 141} 142 143static intce_modified_check_fs(struct cache_entry *ce,struct stat *st) 144{ 145switch(st->st_mode & S_IFMT) { 146case S_IFREG: 147if(ce_compare_data(ce, st)) 148return DATA_CHANGED; 149break; 150case S_IFLNK: 151if(ce_compare_link(ce,xsize_t(st->st_size))) 152return DATA_CHANGED; 153break; 154case S_IFDIR: 155if(S_ISGITLINK(ce->ce_mode)) 156returnce_compare_gitlink(ce) ? DATA_CHANGED :0; 157default: 158return TYPE_CHANGED; 159} 160return0; 161} 162 163static intis_empty_blob_sha1(const unsigned char*sha1) 164{ 165static const unsigned char empty_blob_sha1[20] = { 1660xe6,0x9d,0xe2,0x9b,0xb2,0xd1,0xd6,0x43,0x4b,0x8b, 1670x29,0xae,0x77,0x5a,0xd8,0xc2,0xe4,0x8c,0x53,0x91 168}; 169 170return!hashcmp(sha1, empty_blob_sha1); 171} 172 173static intce_match_stat_basic(struct cache_entry *ce,struct stat *st) 174{ 175unsigned int changed =0; 176 177if(ce->ce_flags & CE_REMOVE) 178return MODE_CHANGED | DATA_CHANGED | TYPE_CHANGED; 179 180switch(ce->ce_mode & S_IFMT) { 181case S_IFREG: 182 changed |= !S_ISREG(st->st_mode) ? TYPE_CHANGED :0; 183/* We consider only the owner x bit to be relevant for 184 * "mode changes" 185 */ 186if(trust_executable_bit && 187(0100& (ce->ce_mode ^ st->st_mode))) 188 changed |= MODE_CHANGED; 189break; 190case S_IFLNK: 191if(!S_ISLNK(st->st_mode) && 192(has_symlinks || !S_ISREG(st->st_mode))) 193 changed |= TYPE_CHANGED; 194break; 195case S_IFGITLINK: 196/* We ignore most of the st_xxx fields for gitlinks */ 197if(!S_ISDIR(st->st_mode)) 198 changed |= TYPE_CHANGED; 199else if(ce_compare_gitlink(ce)) 200 changed |= DATA_CHANGED; 201return changed; 202default: 203die("internal error: ce_mode is%o", ce->ce_mode); 204} 205if(ce->ce_mtime.sec != (unsigned int)st->st_mtime) 206 changed |= MTIME_CHANGED; 207if(trust_ctime && ce->ce_ctime.sec != (unsigned int)st->st_ctime) 208 changed |= CTIME_CHANGED; 209 210#ifdef USE_NSEC 211if(ce->ce_mtime.nsec !=ST_MTIME_NSEC(*st)) 212 changed |= MTIME_CHANGED; 213if(trust_ctime && ce->ce_ctime.nsec !=ST_CTIME_NSEC(*st)) 214 changed |= CTIME_CHANGED; 215#endif 216 217if(ce->ce_uid != (unsigned int) st->st_uid || 218 ce->ce_gid != (unsigned int) st->st_gid) 219 changed |= OWNER_CHANGED; 220if(ce->ce_ino != (unsigned int) st->st_ino) 221 changed |= INODE_CHANGED; 222 223#ifdef USE_STDEV 224/* 225 * st_dev breaks on network filesystems where different 226 * clients will have different views of what "device" 227 * the filesystem is on 228 */ 229if(ce->ce_dev != (unsigned int) st->st_dev) 230 changed |= INODE_CHANGED; 231#endif 232 233if(ce->ce_size != (unsigned int) st->st_size) 234 changed |= DATA_CHANGED; 235 236/* Racily smudged entry? */ 237if(!ce->ce_size) { 238if(!is_empty_blob_sha1(ce->sha1)) 239 changed |= DATA_CHANGED; 240} 241 242return changed; 243} 244 245static intis_racy_timestamp(const struct index_state *istate,struct cache_entry *ce) 246{ 247return(!S_ISGITLINK(ce->ce_mode) && 248 istate->timestamp.sec && 249#ifdef USE_NSEC 250/* nanosecond timestamped files can also be racy! */ 251(istate->timestamp.sec < ce->ce_mtime.sec || 252(istate->timestamp.sec == ce->ce_mtime.sec && 253 istate->timestamp.nsec <= ce->ce_mtime.nsec)) 254#else 255 istate->timestamp.sec <= ce->ce_mtime.sec 256#endif 257); 258} 259 260intie_match_stat(const struct index_state *istate, 261struct cache_entry *ce,struct stat *st, 262unsigned int options) 263{ 264unsigned int changed; 265int ignore_valid = options & CE_MATCH_IGNORE_VALID; 266int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; 267int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; 268 269/* 270 * If it's marked as always valid in the index, it's 271 * valid whatever the checked-out copy says. 272 * 273 * skip-worktree has the same effect with higher precedence 274 */ 275if(!ignore_skip_worktree &&ce_skip_worktree(ce)) 276return0; 277if(!ignore_valid && (ce->ce_flags & CE_VALID)) 278return0; 279 280/* 281 * Intent-to-add entries have not been added, so the index entry 282 * by definition never matches what is in the work tree until it 283 * actually gets added. 284 */ 285if(ce->ce_flags & CE_INTENT_TO_ADD) 286return DATA_CHANGED | TYPE_CHANGED | MODE_CHANGED; 287 288 changed =ce_match_stat_basic(ce, st); 289 290/* 291 * Within 1 second of this sequence: 292 * echo xyzzy >file && git-update-index --add file 293 * running this command: 294 * echo frotz >file 295 * would give a falsely clean cache entry. The mtime and 296 * length match the cache, and other stat fields do not change. 297 * 298 * We could detect this at update-index time (the cache entry 299 * being registered/updated records the same time as "now") 300 * and delay the return from git-update-index, but that would 301 * effectively mean we can make at most one commit per second, 302 * which is not acceptable. Instead, we check cache entries 303 * whose mtime are the same as the index file timestamp more 304 * carefully than others. 305 */ 306if(!changed &&is_racy_timestamp(istate, ce)) { 307if(assume_racy_is_modified) 308 changed |= DATA_CHANGED; 309else 310 changed |=ce_modified_check_fs(ce, st); 311} 312 313return changed; 314} 315 316intie_modified(const struct index_state *istate, 317struct cache_entry *ce,struct stat *st,unsigned int options) 318{ 319int changed, changed_fs; 320 321 changed =ie_match_stat(istate, ce, st, options); 322if(!changed) 323return0; 324/* 325 * If the mode or type has changed, there's no point in trying 326 * to refresh the entry - it's not going to match 327 */ 328if(changed & (MODE_CHANGED | TYPE_CHANGED)) 329return changed; 330 331/* 332 * Immediately after read-tree or update-index --cacheinfo, 333 * the length field is zero, as we have never even read the 334 * lstat(2) information once, and we cannot trust DATA_CHANGED 335 * returned by ie_match_stat() which in turn was returned by 336 * ce_match_stat_basic() to signal that the filesize of the 337 * blob changed. We have to actually go to the filesystem to 338 * see if the contents match, and if so, should answer "unchanged". 339 * 340 * The logic does not apply to gitlinks, as ce_match_stat_basic() 341 * already has checked the actual HEAD from the filesystem in the 342 * subproject. If ie_match_stat() already said it is different, 343 * then we know it is. 344 */ 345if((changed & DATA_CHANGED) && 346(S_ISGITLINK(ce->ce_mode) || ce->ce_size !=0)) 347return changed; 348 349 changed_fs =ce_modified_check_fs(ce, st); 350if(changed_fs) 351return changed | changed_fs; 352return0; 353} 354 355intbase_name_compare(const char*name1,int len1,int mode1, 356const char*name2,int len2,int mode2) 357{ 358unsigned char c1, c2; 359int len = len1 < len2 ? len1 : len2; 360int cmp; 361 362 cmp =memcmp(name1, name2, len); 363if(cmp) 364return cmp; 365 c1 = name1[len]; 366 c2 = name2[len]; 367if(!c1 &&S_ISDIR(mode1)) 368 c1 ='/'; 369if(!c2 &&S_ISDIR(mode2)) 370 c2 ='/'; 371return(c1 < c2) ? -1: (c1 > c2) ?1:0; 372} 373 374/* 375 * df_name_compare() is identical to base_name_compare(), except it 376 * compares conflicting directory/file entries as equal. Note that 377 * while a directory name compares as equal to a regular file, they 378 * then individually compare _differently_ to a filename that has 379 * a dot after the basename (because '\0' < '.' < '/'). 380 * 381 * This is used by routines that want to traverse the git namespace 382 * but then handle conflicting entries together when possible. 383 */ 384intdf_name_compare(const char*name1,int len1,int mode1, 385const char*name2,int len2,int mode2) 386{ 387int len = len1 < len2 ? len1 : len2, cmp; 388unsigned char c1, c2; 389 390 cmp =memcmp(name1, name2, len); 391if(cmp) 392return cmp; 393/* Directories and files compare equal (same length, same name) */ 394if(len1 == len2) 395return0; 396 c1 = name1[len]; 397if(!c1 &&S_ISDIR(mode1)) 398 c1 ='/'; 399 c2 = name2[len]; 400if(!c2 &&S_ISDIR(mode2)) 401 c2 ='/'; 402if(c1 =='/'&& !c2) 403return0; 404if(c2 =='/'&& !c1) 405return0; 406return c1 - c2; 407} 408 409intcache_name_compare(const char*name1,int flags1,const char*name2,int flags2) 410{ 411int len1 = flags1 & CE_NAMEMASK; 412int len2 = flags2 & CE_NAMEMASK; 413int len = len1 < len2 ? len1 : len2; 414int cmp; 415 416 cmp =memcmp(name1, name2, len); 417if(cmp) 418return cmp; 419if(len1 < len2) 420return-1; 421if(len1 > len2) 422return1; 423 424/* Compare stages */ 425 flags1 &= CE_STAGEMASK; 426 flags2 &= CE_STAGEMASK; 427 428if(flags1 < flags2) 429return-1; 430if(flags1 > flags2) 431return1; 432return0; 433} 434 435intindex_name_pos(const struct index_state *istate,const char*name,int namelen) 436{ 437int first, last; 438 439 first =0; 440 last = istate->cache_nr; 441while(last > first) { 442int next = (last + first) >>1; 443struct cache_entry *ce = istate->cache[next]; 444int cmp =cache_name_compare(name, namelen, ce->name, ce->ce_flags); 445if(!cmp) 446return next; 447if(cmp <0) { 448 last = next; 449continue; 450} 451 first = next+1; 452} 453return-first-1; 454} 455 456/* Remove entry, return true if there are more entries to go.. */ 457intremove_index_entry_at(struct index_state *istate,int pos) 458{ 459struct cache_entry *ce = istate->cache[pos]; 460 461record_resolve_undo(istate, ce); 462remove_name_hash(ce); 463 istate->cache_changed =1; 464 istate->cache_nr--; 465if(pos >= istate->cache_nr) 466return0; 467memmove(istate->cache + pos, 468 istate->cache + pos +1, 469(istate->cache_nr - pos) *sizeof(struct cache_entry *)); 470return1; 471} 472 473/* 474 * Remove all cache ententries marked for removal, that is where 475 * CE_REMOVE is set in ce_flags. This is much more effective than 476 * calling remove_index_entry_at() for each entry to be removed. 477 */ 478voidremove_marked_cache_entries(struct index_state *istate) 479{ 480struct cache_entry **ce_array = istate->cache; 481unsigned int i, j; 482 483for(i = j =0; i < istate->cache_nr; i++) { 484if(ce_array[i]->ce_flags & CE_REMOVE) 485remove_name_hash(ce_array[i]); 486else 487 ce_array[j++] = ce_array[i]; 488} 489 istate->cache_changed =1; 490 istate->cache_nr = j; 491} 492 493intremove_file_from_index(struct index_state *istate,const char*path) 494{ 495int pos =index_name_pos(istate, path,strlen(path)); 496if(pos <0) 497 pos = -pos-1; 498cache_tree_invalidate_path(istate->cache_tree, path); 499while(pos < istate->cache_nr && !strcmp(istate->cache[pos]->name, path)) 500remove_index_entry_at(istate, pos); 501return0; 502} 503 504static intcompare_name(struct cache_entry *ce,const char*path,int namelen) 505{ 506return namelen !=ce_namelen(ce) ||memcmp(path, ce->name, namelen); 507} 508 509static intindex_name_pos_also_unmerged(struct index_state *istate, 510const char*path,int namelen) 511{ 512int pos =index_name_pos(istate, path, namelen); 513struct cache_entry *ce; 514 515if(pos >=0) 516return pos; 517 518/* maybe unmerged? */ 519 pos = -1- pos; 520if(pos >= istate->cache_nr || 521compare_name((ce = istate->cache[pos]), path, namelen)) 522return-1; 523 524/* order of preference: stage 2, 1, 3 */ 525if(ce_stage(ce) ==1&& pos +1< istate->cache_nr && 526ce_stage((ce = istate->cache[pos +1])) ==2&& 527!compare_name(ce, path, namelen)) 528 pos++; 529return pos; 530} 531 532static intdifferent_name(struct cache_entry *ce,struct cache_entry *alias) 533{ 534int len =ce_namelen(ce); 535returnce_namelen(alias) != len ||memcmp(ce->name, alias->name, len); 536} 537 538/* 539 * If we add a filename that aliases in the cache, we will use the 540 * name that we already have - but we don't want to update the same 541 * alias twice, because that implies that there were actually two 542 * different files with aliasing names! 543 * 544 * So we use the CE_ADDED flag to verify that the alias was an old 545 * one before we accept it as 546 */ 547static struct cache_entry *create_alias_ce(struct cache_entry *ce,struct cache_entry *alias) 548{ 549int len; 550struct cache_entry *new; 551 552if(alias->ce_flags & CE_ADDED) 553die("Will not add file alias '%s' ('%s' already exists in index)", ce->name, alias->name); 554 555/* Ok, create the new entry using the name of the existing alias */ 556 len =ce_namelen(alias); 557new=xcalloc(1,cache_entry_size(len)); 558memcpy(new->name, alias->name, len); 559copy_cache_entry(new, ce); 560free(ce); 561return new; 562} 563 564static voidrecord_intent_to_add(struct cache_entry *ce) 565{ 566unsigned char sha1[20]; 567if(write_sha1_file("",0, blob_type, sha1)) 568die("cannot create an empty blob in the object database"); 569hashcpy(ce->sha1, sha1); 570} 571 572intadd_to_index(struct index_state *istate,const char*path,struct stat *st,int flags) 573{ 574int size, namelen, was_same; 575 mode_t st_mode = st->st_mode; 576struct cache_entry *ce, *alias; 577unsigned ce_option = CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE|CE_MATCH_RACY_IS_DIRTY; 578int verbose = flags & (ADD_CACHE_VERBOSE | ADD_CACHE_PRETEND); 579int pretend = flags & ADD_CACHE_PRETEND; 580int intent_only = flags & ADD_CACHE_INTENT; 581int add_option = (ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE| 582(intent_only ? ADD_CACHE_NEW_ONLY :0)); 583 584if(!S_ISREG(st_mode) && !S_ISLNK(st_mode) && !S_ISDIR(st_mode)) 585returnerror("%s: can only add regular files, symbolic links or git-directories", path); 586 587 namelen =strlen(path); 588if(S_ISDIR(st_mode)) { 589while(namelen && path[namelen-1] =='/') 590 namelen--; 591} 592 size =cache_entry_size(namelen); 593 ce =xcalloc(1, size); 594memcpy(ce->name, path, namelen); 595 ce->ce_flags = namelen; 596if(!intent_only) 597fill_stat_cache_info(ce, st); 598else 599 ce->ce_flags |= CE_INTENT_TO_ADD; 600 601if(trust_executable_bit && has_symlinks) 602 ce->ce_mode =create_ce_mode(st_mode); 603else{ 604/* If there is an existing entry, pick the mode bits and type 605 * from it, otherwise assume unexecutable regular file. 606 */ 607struct cache_entry *ent; 608int pos =index_name_pos_also_unmerged(istate, path, namelen); 609 610 ent = (0<= pos) ? istate->cache[pos] : NULL; 611 ce->ce_mode =ce_mode_from_stat(ent, st_mode); 612} 613 614 alias =index_name_exists(istate, ce->name,ce_namelen(ce), ignore_case); 615if(alias && !ce_stage(alias) && !ie_match_stat(istate, alias, st, ce_option)) { 616/* Nothing changed, really */ 617free(ce); 618ce_mark_uptodate(alias); 619 alias->ce_flags |= CE_ADDED; 620return0; 621} 622if(!intent_only) { 623if(index_path(ce->sha1, path, st,1)) 624returnerror("unable to index file%s", path); 625}else 626record_intent_to_add(ce); 627 628if(ignore_case && alias &&different_name(ce, alias)) 629 ce =create_alias_ce(ce, alias); 630 ce->ce_flags |= CE_ADDED; 631 632/* It was suspected to be racily clean, but it turns out to be Ok */ 633 was_same = (alias && 634!ce_stage(alias) && 635!hashcmp(alias->sha1, ce->sha1) && 636 ce->ce_mode == alias->ce_mode); 637 638if(pretend) 639; 640else if(add_index_entry(istate, ce, add_option)) 641returnerror("unable to add%sto index",path); 642if(verbose && !was_same) 643printf("add '%s'\n", path); 644return0; 645} 646 647intadd_file_to_index(struct index_state *istate,const char*path,int flags) 648{ 649struct stat st; 650if(lstat(path, &st)) 651die_errno("unable to stat '%s'", path); 652returnadd_to_index(istate, path, &st, flags); 653} 654 655struct cache_entry *make_cache_entry(unsigned int mode, 656const unsigned char*sha1,const char*path,int stage, 657int refresh) 658{ 659int size, len; 660struct cache_entry *ce; 661 662if(!verify_path(path)) { 663error("Invalid path '%s'", path); 664return NULL; 665} 666 667 len =strlen(path); 668 size =cache_entry_size(len); 669 ce =xcalloc(1, size); 670 671hashcpy(ce->sha1, sha1); 672memcpy(ce->name, path, len); 673 ce->ce_flags =create_ce_flags(len, stage); 674 ce->ce_mode =create_ce_mode(mode); 675 676if(refresh) 677returnrefresh_cache_entry(ce,0); 678 679return ce; 680} 681 682intce_same_name(struct cache_entry *a,struct cache_entry *b) 683{ 684int len =ce_namelen(a); 685returnce_namelen(b) == len && !memcmp(a->name, b->name, len); 686} 687 688intce_path_match(const struct cache_entry *ce,const char**pathspec) 689{ 690const char*match, *name; 691int len; 692 693if(!pathspec) 694return1; 695 696 len =ce_namelen(ce); 697 name = ce->name; 698while((match = *pathspec++) != NULL) { 699int matchlen =strlen(match); 700if(matchlen > len) 701continue; 702if(memcmp(name, match, matchlen)) 703continue; 704if(matchlen && name[matchlen-1] =='/') 705return1; 706if(name[matchlen] =='/'|| !name[matchlen]) 707return1; 708if(!matchlen) 709return1; 710} 711return0; 712} 713 714/* 715 * We fundamentally don't like some paths: we don't want 716 * dot or dot-dot anywhere, and for obvious reasons don't 717 * want to recurse into ".git" either. 718 * 719 * Also, we don't want double slashes or slashes at the 720 * end that can make pathnames ambiguous. 721 */ 722static intverify_dotfile(const char*rest) 723{ 724/* 725 * The first character was '.', but that 726 * has already been discarded, we now test 727 * the rest. 728 */ 729switch(*rest) { 730/* "." is not allowed */ 731case'\0':case'/': 732return0; 733 734/* 735 * ".git" followed by NUL or slash is bad. This 736 * shares the path end test with the ".." case. 737 */ 738case'g': 739if(rest[1] !='i') 740break; 741if(rest[2] !='t') 742break; 743 rest +=2; 744/* fallthrough */ 745case'.': 746if(rest[1] =='\0'|| rest[1] =='/') 747return0; 748} 749return1; 750} 751 752intverify_path(const char*path) 753{ 754char c; 755 756goto inside; 757for(;;) { 758if(!c) 759return1; 760if(c =='/') { 761inside: 762 c = *path++; 763switch(c) { 764default: 765continue; 766case'/':case'\0': 767break; 768case'.': 769if(verify_dotfile(path)) 770continue; 771} 772return0; 773} 774 c = *path++; 775} 776} 777 778/* 779 * Do we have another file that has the beginning components being a 780 * proper superset of the name we're trying to add? 781 */ 782static inthas_file_name(struct index_state *istate, 783const struct cache_entry *ce,int pos,int ok_to_replace) 784{ 785int retval =0; 786int len =ce_namelen(ce); 787int stage =ce_stage(ce); 788const char*name = ce->name; 789 790while(pos < istate->cache_nr) { 791struct cache_entry *p = istate->cache[pos++]; 792 793if(len >=ce_namelen(p)) 794break; 795if(memcmp(name, p->name, len)) 796break; 797if(ce_stage(p) != stage) 798continue; 799if(p->name[len] !='/') 800continue; 801if(p->ce_flags & CE_REMOVE) 802continue; 803 retval = -1; 804if(!ok_to_replace) 805break; 806remove_index_entry_at(istate, --pos); 807} 808return retval; 809} 810 811/* 812 * Do we have another file with a pathname that is a proper 813 * subset of the name we're trying to add? 814 */ 815static inthas_dir_name(struct index_state *istate, 816const struct cache_entry *ce,int pos,int ok_to_replace) 817{ 818int retval =0; 819int stage =ce_stage(ce); 820const char*name = ce->name; 821const char*slash = name +ce_namelen(ce); 822 823for(;;) { 824int len; 825 826for(;;) { 827if(*--slash =='/') 828break; 829if(slash <= ce->name) 830return retval; 831} 832 len = slash - name; 833 834 pos =index_name_pos(istate, name,create_ce_flags(len, stage)); 835if(pos >=0) { 836/* 837 * Found one, but not so fast. This could 838 * be a marker that says "I was here, but 839 * I am being removed". Such an entry is 840 * not a part of the resulting tree, and 841 * it is Ok to have a directory at the same 842 * path. 843 */ 844if(!(istate->cache[pos]->ce_flags & CE_REMOVE)) { 845 retval = -1; 846if(!ok_to_replace) 847break; 848remove_index_entry_at(istate, pos); 849continue; 850} 851} 852else 853 pos = -pos-1; 854 855/* 856 * Trivial optimization: if we find an entry that 857 * already matches the sub-directory, then we know 858 * we're ok, and we can exit. 859 */ 860while(pos < istate->cache_nr) { 861struct cache_entry *p = istate->cache[pos]; 862if((ce_namelen(p) <= len) || 863(p->name[len] !='/') || 864memcmp(p->name, name, len)) 865break;/* not our subdirectory */ 866if(ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE)) 867/* 868 * p is at the same stage as our entry, and 869 * is a subdirectory of what we are looking 870 * at, so we cannot have conflicts at our 871 * level or anything shorter. 872 */ 873return retval; 874 pos++; 875} 876} 877return retval; 878} 879 880/* We may be in a situation where we already have path/file and path 881 * is being added, or we already have path and path/file is being 882 * added. Either one would result in a nonsense tree that has path 883 * twice when git-write-tree tries to write it out. Prevent it. 884 * 885 * If ok-to-replace is specified, we remove the conflicting entries 886 * from the cache so the caller should recompute the insert position. 887 * When this happens, we return non-zero. 888 */ 889static intcheck_file_directory_conflict(struct index_state *istate, 890const struct cache_entry *ce, 891int pos,int ok_to_replace) 892{ 893int retval; 894 895/* 896 * When ce is an "I am going away" entry, we allow it to be added 897 */ 898if(ce->ce_flags & CE_REMOVE) 899return0; 900 901/* 902 * We check if the path is a sub-path of a subsequent pathname 903 * first, since removing those will not change the position 904 * in the array. 905 */ 906 retval =has_file_name(istate, ce, pos, ok_to_replace); 907 908/* 909 * Then check if the path might have a clashing sub-directory 910 * before it. 911 */ 912return retval +has_dir_name(istate, ce, pos, ok_to_replace); 913} 914 915static intadd_index_entry_with_check(struct index_state *istate,struct cache_entry *ce,int option) 916{ 917int pos; 918int ok_to_add = option & ADD_CACHE_OK_TO_ADD; 919int ok_to_replace = option & ADD_CACHE_OK_TO_REPLACE; 920int skip_df_check = option & ADD_CACHE_SKIP_DFCHECK; 921int new_only = option & ADD_CACHE_NEW_ONLY; 922 923cache_tree_invalidate_path(istate->cache_tree, ce->name); 924 pos =index_name_pos(istate, ce->name, ce->ce_flags); 925 926/* existing match? Just replace it. */ 927if(pos >=0) { 928if(!new_only) 929replace_index_entry(istate, pos, ce); 930return0; 931} 932 pos = -pos-1; 933 934/* 935 * Inserting a merged entry ("stage 0") into the index 936 * will always replace all non-merged entries.. 937 */ 938if(pos < istate->cache_nr &&ce_stage(ce) ==0) { 939while(ce_same_name(istate->cache[pos], ce)) { 940 ok_to_add =1; 941if(!remove_index_entry_at(istate, pos)) 942break; 943} 944} 945 946if(!ok_to_add) 947return-1; 948if(!verify_path(ce->name)) 949returnerror("Invalid path '%s'", ce->name); 950 951if(!skip_df_check && 952check_file_directory_conflict(istate, ce, pos, ok_to_replace)) { 953if(!ok_to_replace) 954returnerror("'%s' appears as both a file and as a directory", 955 ce->name); 956 pos =index_name_pos(istate, ce->name, ce->ce_flags); 957 pos = -pos-1; 958} 959return pos +1; 960} 961 962intadd_index_entry(struct index_state *istate,struct cache_entry *ce,int option) 963{ 964int pos; 965 966if(option & ADD_CACHE_JUST_APPEND) 967 pos = istate->cache_nr; 968else{ 969int ret; 970 ret =add_index_entry_with_check(istate, ce, option); 971if(ret <=0) 972return ret; 973 pos = ret -1; 974} 975 976/* Make sure the array is big enough .. */ 977if(istate->cache_nr == istate->cache_alloc) { 978 istate->cache_alloc =alloc_nr(istate->cache_alloc); 979 istate->cache =xrealloc(istate->cache, 980 istate->cache_alloc *sizeof(struct cache_entry *)); 981} 982 983/* Add it in.. */ 984 istate->cache_nr++; 985if(istate->cache_nr > pos +1) 986memmove(istate->cache + pos +1, 987 istate->cache + pos, 988(istate->cache_nr - pos -1) *sizeof(ce)); 989set_index_entry(istate, pos, ce); 990 istate->cache_changed =1; 991return0; 992} 993 994/* 995 * "refresh" does not calculate a new sha1 file or bring the 996 * cache up-to-date for mode/content changes. But what it 997 * _does_ do is to "re-match" the stat information of a file 998 * with the cache, so that you can refresh the cache for a 999 * file that hasn't been changed but where the stat entry is1000 * out of date.1001 *1002 * For example, you'd want to do this after doing a "git-read-tree",1003 * to link up the stat cache details with the proper files.1004 */1005static struct cache_entry *refresh_cache_ent(struct index_state *istate,1006struct cache_entry *ce,1007unsigned int options,int*err)1008{1009struct stat st;1010struct cache_entry *updated;1011int changed, size;1012int ignore_valid = options & CE_MATCH_IGNORE_VALID;1013int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE;10141015if(ce_uptodate(ce))1016return ce;10171018/*1019 * CE_VALID or CE_SKIP_WORKTREE means the user promised us1020 * that the change to the work tree does not matter and told1021 * us not to worry.1022 */1023if(!ignore_skip_worktree &&ce_skip_worktree(ce)) {1024ce_mark_uptodate(ce);1025return ce;1026}1027if(!ignore_valid && (ce->ce_flags & CE_VALID)) {1028ce_mark_uptodate(ce);1029return ce;1030}10311032if(lstat(ce->name, &st) <0) {1033if(err)1034*err = errno;1035return NULL;1036}10371038 changed =ie_match_stat(istate, ce, &st, options);1039if(!changed) {1040/*1041 * The path is unchanged. If we were told to ignore1042 * valid bit, then we did the actual stat check and1043 * found that the entry is unmodified. If the entry1044 * is not marked VALID, this is the place to mark it1045 * valid again, under "assume unchanged" mode.1046 */1047if(ignore_valid && assume_unchanged &&1048!(ce->ce_flags & CE_VALID))1049;/* mark this one VALID again */1050else{1051/*1052 * We do not mark the index itself "modified"1053 * because CE_UPTODATE flag is in-core only;1054 * we are not going to write this change out.1055 */1056ce_mark_uptodate(ce);1057return ce;1058}1059}10601061if(ie_modified(istate, ce, &st, options)) {1062if(err)1063*err = EINVAL;1064return NULL;1065}10661067 size =ce_size(ce);1068 updated =xmalloc(size);1069memcpy(updated, ce, size);1070fill_stat_cache_info(updated, &st);1071/*1072 * If ignore_valid is not set, we should leave CE_VALID bit1073 * alone. Otherwise, paths marked with --no-assume-unchanged1074 * (i.e. things to be edited) will reacquire CE_VALID bit1075 * automatically, which is not really what we want.1076 */1077if(!ignore_valid && assume_unchanged &&1078!(ce->ce_flags & CE_VALID))1079 updated->ce_flags &= ~CE_VALID;10801081return updated;1082}10831084static voidshow_file(const char* fmt,const char* name,int in_porcelain,1085int* first,char*header_msg)1086{1087if(in_porcelain && *first && header_msg) {1088printf("%s\n", header_msg);1089*first=0;1090}1091printf(fmt, name);1092}10931094intrefresh_index(struct index_state *istate,unsigned int flags,const char**pathspec,1095char*seen,char*header_msg)1096{1097int i;1098int has_errors =0;1099int really = (flags & REFRESH_REALLY) !=0;1100int allow_unmerged = (flags & REFRESH_UNMERGED) !=0;1101int quiet = (flags & REFRESH_QUIET) !=0;1102int not_new = (flags & REFRESH_IGNORE_MISSING) !=0;1103int ignore_submodules = (flags & REFRESH_IGNORE_SUBMODULES) !=0;1104int first =1;1105int in_porcelain = (flags & REFRESH_IN_PORCELAIN);1106unsigned int options = really ? CE_MATCH_IGNORE_VALID :0;1107const char*needs_update_fmt;1108const char*needs_merge_fmt;11091110 needs_update_fmt = (in_porcelain ?"M\t%s\n":"%s: needs update\n");1111 needs_merge_fmt = (in_porcelain ?"U\t%s\n":"%s: needs merge\n");1112for(i =0; i < istate->cache_nr; i++) {1113struct cache_entry *ce, *new;1114int cache_errno =0;11151116 ce = istate->cache[i];1117if(ignore_submodules &&S_ISGITLINK(ce->ce_mode))1118continue;11191120if(ce_stage(ce)) {1121while((i < istate->cache_nr) &&1122!strcmp(istate->cache[i]->name, ce->name))1123 i++;1124 i--;1125if(allow_unmerged)1126continue;1127show_file(needs_merge_fmt, ce->name, in_porcelain, &first, header_msg);1128 has_errors =1;1129continue;1130}11311132if(pathspec && !match_pathspec(pathspec, ce->name,strlen(ce->name),0, seen))1133continue;11341135new=refresh_cache_ent(istate, ce, options, &cache_errno);1136if(new== ce)1137continue;1138if(!new) {1139if(not_new && cache_errno == ENOENT)1140continue;1141if(really && cache_errno == EINVAL) {1142/* If we are doing --really-refresh that1143 * means the index is not valid anymore.1144 */1145 ce->ce_flags &= ~CE_VALID;1146 istate->cache_changed =1;1147}1148if(quiet)1149continue;1150show_file(needs_update_fmt, ce->name, in_porcelain, &first, header_msg);1151 has_errors =1;1152continue;1153}11541155replace_index_entry(istate, i,new);1156}1157return has_errors;1158}11591160static struct cache_entry *refresh_cache_entry(struct cache_entry *ce,int really)1161{1162returnrefresh_cache_ent(&the_index, ce, really, NULL);1163}11641165static intverify_hdr(struct cache_header *hdr,unsigned long size)1166{1167 git_SHA_CTX c;1168unsigned char sha1[20];11691170if(hdr->hdr_signature !=htonl(CACHE_SIGNATURE))1171returnerror("bad signature");1172if(hdr->hdr_version !=htonl(2) && hdr->hdr_version !=htonl(3))1173returnerror("bad index version");1174git_SHA1_Init(&c);1175git_SHA1_Update(&c, hdr, size -20);1176git_SHA1_Final(sha1, &c);1177if(hashcmp(sha1, (unsigned char*)hdr + size -20))1178returnerror("bad index file sha1 signature");1179return0;1180}11811182static intread_index_extension(struct index_state *istate,1183const char*ext,void*data,unsigned long sz)1184{1185switch(CACHE_EXT(ext)) {1186case CACHE_EXT_TREE:1187 istate->cache_tree =cache_tree_read(data, sz);1188break;1189case CACHE_EXT_RESOLVE_UNDO:1190 istate->resolve_undo =resolve_undo_read(data, sz);1191break;1192default:1193if(*ext <'A'||'Z'< *ext)1194returnerror("index uses %.4s extension, which we do not understand",1195 ext);1196fprintf(stderr,"ignoring %.4s extension\n", ext);1197break;1198}1199return0;1200}12011202intread_index(struct index_state *istate)1203{1204returnread_index_from(istate,get_index_file());1205}12061207static voidconvert_from_disk(struct ondisk_cache_entry *ondisk,struct cache_entry *ce)1208{1209size_t len;1210const char*name;12111212 ce->ce_ctime.sec =ntohl(ondisk->ctime.sec);1213 ce->ce_mtime.sec =ntohl(ondisk->mtime.sec);1214 ce->ce_ctime.nsec =ntohl(ondisk->ctime.nsec);1215 ce->ce_mtime.nsec =ntohl(ondisk->mtime.nsec);1216 ce->ce_dev =ntohl(ondisk->dev);1217 ce->ce_ino =ntohl(ondisk->ino);1218 ce->ce_mode =ntohl(ondisk->mode);1219 ce->ce_uid =ntohl(ondisk->uid);1220 ce->ce_gid =ntohl(ondisk->gid);1221 ce->ce_size =ntohl(ondisk->size);1222/* On-disk flags are just 16 bits */1223 ce->ce_flags =ntohs(ondisk->flags);12241225hashcpy(ce->sha1, ondisk->sha1);12261227 len = ce->ce_flags & CE_NAMEMASK;12281229if(ce->ce_flags & CE_EXTENDED) {1230struct ondisk_cache_entry_extended *ondisk2;1231int extended_flags;1232 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1233 extended_flags =ntohs(ondisk2->flags2) <<16;1234/* We do not yet understand any bit out of CE_EXTENDED_FLAGS */1235if(extended_flags & ~CE_EXTENDED_FLAGS)1236die("Unknown index entry format%08x", extended_flags);1237 ce->ce_flags |= extended_flags;1238 name = ondisk2->name;1239}1240else1241 name = ondisk->name;12421243if(len == CE_NAMEMASK)1244 len =strlen(name);1245/*1246 * NEEDSWORK: If the original index is crafted, this copy could1247 * go unchecked.1248 */1249memcpy(ce->name, name, len +1);1250}12511252staticinlinesize_testimate_cache_size(size_t ondisk_size,unsigned int entries)1253{1254long per_entry;12551256 per_entry =sizeof(struct cache_entry) -sizeof(struct ondisk_cache_entry);12571258/*1259 * Alignment can cause differences. This should be "alignof", but1260 * since that's a gcc'ism, just use the size of a pointer.1261 */1262 per_entry +=sizeof(void*);1263return ondisk_size + entries*per_entry;1264}12651266/* remember to discard_cache() before reading a different cache! */1267intread_index_from(struct index_state *istate,const char*path)1268{1269int fd, i;1270struct stat st;1271unsigned long src_offset, dst_offset;1272struct cache_header *hdr;1273void*mmap;1274size_t mmap_size;12751276 errno = EBUSY;1277if(istate->initialized)1278return istate->cache_nr;12791280 errno = ENOENT;1281 istate->timestamp.sec =0;1282 istate->timestamp.nsec =0;1283 fd =open(path, O_RDONLY);1284if(fd <0) {1285if(errno == ENOENT)1286return0;1287die_errno("index file open failed");1288}12891290if(fstat(fd, &st))1291die_errno("cannot stat the open index");12921293 errno = EINVAL;1294 mmap_size =xsize_t(st.st_size);1295if(mmap_size <sizeof(struct cache_header) +20)1296die("index file smaller than expected");12971298 mmap =xmmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd,0);1299close(fd);1300if(mmap == MAP_FAILED)1301die_errno("unable to map index file");13021303 hdr = mmap;1304if(verify_hdr(hdr, mmap_size) <0)1305goto unmap;13061307 istate->cache_nr =ntohl(hdr->hdr_entries);1308 istate->cache_alloc =alloc_nr(istate->cache_nr);1309 istate->cache =xcalloc(istate->cache_alloc,sizeof(struct cache_entry *));13101311/*1312 * The disk format is actually larger than the in-memory format,1313 * due to space for nsec etc, so even though the in-memory one1314 * has room for a few more flags, we can allocate using the same1315 * index size1316 */1317 istate->alloc =xmalloc(estimate_cache_size(mmap_size, istate->cache_nr));1318 istate->initialized =1;13191320 src_offset =sizeof(*hdr);1321 dst_offset =0;1322for(i =0; i < istate->cache_nr; i++) {1323struct ondisk_cache_entry *disk_ce;1324struct cache_entry *ce;13251326 disk_ce = (struct ondisk_cache_entry *)((char*)mmap + src_offset);1327 ce = (struct cache_entry *)((char*)istate->alloc + dst_offset);1328convert_from_disk(disk_ce, ce);1329set_index_entry(istate, i, ce);13301331 src_offset +=ondisk_ce_size(ce);1332 dst_offset +=ce_size(ce);1333}1334 istate->timestamp.sec = st.st_mtime;1335 istate->timestamp.nsec =ST_MTIME_NSEC(st);13361337while(src_offset <= mmap_size -20-8) {1338/* After an array of active_nr index entries,1339 * there can be arbitrary number of extended1340 * sections, each of which is prefixed with1341 * extension name (4-byte) and section length1342 * in 4-byte network byte order.1343 */1344uint32_t extsize;1345memcpy(&extsize, (char*)mmap + src_offset +4,4);1346 extsize =ntohl(extsize);1347if(read_index_extension(istate,1348(const char*) mmap + src_offset,1349(char*) mmap + src_offset +8,1350 extsize) <0)1351goto unmap;1352 src_offset +=8;1353 src_offset += extsize;1354}1355munmap(mmap, mmap_size);1356return istate->cache_nr;13571358unmap:1359munmap(mmap, mmap_size);1360 errno = EINVAL;1361die("index file corrupt");1362}13631364intis_index_unborn(struct index_state *istate)1365{1366return(!istate->cache_nr && !istate->alloc && !istate->timestamp.sec);1367}13681369intdiscard_index(struct index_state *istate)1370{1371resolve_undo_clear_index(istate);1372 istate->cache_nr =0;1373 istate->cache_changed =0;1374 istate->timestamp.sec =0;1375 istate->timestamp.nsec =0;1376 istate->name_hash_initialized =0;1377free_hash(&istate->name_hash);1378cache_tree_free(&(istate->cache_tree));1379free(istate->alloc);1380 istate->alloc = NULL;1381 istate->initialized =0;13821383/* no need to throw away allocated active_cache */1384return0;1385}13861387intunmerged_index(const struct index_state *istate)1388{1389int i;1390for(i =0; i < istate->cache_nr; i++) {1391if(ce_stage(istate->cache[i]))1392return1;1393}1394return0;1395}13961397#define WRITE_BUFFER_SIZE 81921398static unsigned char write_buffer[WRITE_BUFFER_SIZE];1399static unsigned long write_buffer_len;14001401static intce_write_flush(git_SHA_CTX *context,int fd)1402{1403unsigned int buffered = write_buffer_len;1404if(buffered) {1405git_SHA1_Update(context, write_buffer, buffered);1406if(write_in_full(fd, write_buffer, buffered) != buffered)1407return-1;1408 write_buffer_len =0;1409}1410return0;1411}14121413static intce_write(git_SHA_CTX *context,int fd,void*data,unsigned int len)1414{1415while(len) {1416unsigned int buffered = write_buffer_len;1417unsigned int partial = WRITE_BUFFER_SIZE - buffered;1418if(partial > len)1419 partial = len;1420memcpy(write_buffer + buffered, data, partial);1421 buffered += partial;1422if(buffered == WRITE_BUFFER_SIZE) {1423 write_buffer_len = buffered;1424if(ce_write_flush(context, fd))1425return-1;1426 buffered =0;1427}1428 write_buffer_len = buffered;1429 len -= partial;1430 data = (char*) data + partial;1431}1432return0;1433}14341435static intwrite_index_ext_header(git_SHA_CTX *context,int fd,1436unsigned int ext,unsigned int sz)1437{1438 ext =htonl(ext);1439 sz =htonl(sz);1440return((ce_write(context, fd, &ext,4) <0) ||1441(ce_write(context, fd, &sz,4) <0)) ? -1:0;1442}14431444static intce_flush(git_SHA_CTX *context,int fd)1445{1446unsigned int left = write_buffer_len;14471448if(left) {1449 write_buffer_len =0;1450git_SHA1_Update(context, write_buffer, left);1451}14521453/* Flush first if not enough space for SHA1 signature */1454if(left +20> WRITE_BUFFER_SIZE) {1455if(write_in_full(fd, write_buffer, left) != left)1456return-1;1457 left =0;1458}14591460/* Append the SHA1 signature at the end */1461git_SHA1_Final(write_buffer + left, context);1462 left +=20;1463return(write_in_full(fd, write_buffer, left) != left) ? -1:0;1464}14651466static voidce_smudge_racily_clean_entry(struct cache_entry *ce)1467{1468/*1469 * The only thing we care about in this function is to smudge the1470 * falsely clean entry due to touch-update-touch race, so we leave1471 * everything else as they are. We are called for entries whose1472 * ce_mtime match the index file mtime.1473 *1474 * Note that this actually does not do much for gitlinks, for1475 * which ce_match_stat_basic() always goes to the actual1476 * contents. The caller checks with is_racy_timestamp() which1477 * always says "no" for gitlinks, so we are not called for them ;-)1478 */1479struct stat st;14801481if(lstat(ce->name, &st) <0)1482return;1483if(ce_match_stat_basic(ce, &st))1484return;1485if(ce_modified_check_fs(ce, &st)) {1486/* This is "racily clean"; smudge it. Note that this1487 * is a tricky code. At first glance, it may appear1488 * that it can break with this sequence:1489 *1490 * $ echo xyzzy >frotz1491 * $ git-update-index --add frotz1492 * $ : >frotz1493 * $ sleep 31494 * $ echo filfre >nitfol1495 * $ git-update-index --add nitfol1496 *1497 * but it does not. When the second update-index runs,1498 * it notices that the entry "frotz" has the same timestamp1499 * as index, and if we were to smudge it by resetting its1500 * size to zero here, then the object name recorded1501 * in index is the 6-byte file but the cached stat information1502 * becomes zero --- which would then match what we would1503 * obtain from the filesystem next time we stat("frotz").1504 *1505 * However, the second update-index, before calling1506 * this function, notices that the cached size is 61507 * bytes and what is on the filesystem is an empty1508 * file, and never calls us, so the cached size information1509 * for "frotz" stays 6 which does not match the filesystem.1510 */1511 ce->ce_size =0;1512}1513}15141515static intce_write_entry(git_SHA_CTX *c,int fd,struct cache_entry *ce)1516{1517int size =ondisk_ce_size(ce);1518struct ondisk_cache_entry *ondisk =xcalloc(1, size);1519char*name;15201521 ondisk->ctime.sec =htonl(ce->ce_ctime.sec);1522 ondisk->mtime.sec =htonl(ce->ce_mtime.sec);1523 ondisk->ctime.nsec =htonl(ce->ce_ctime.nsec);1524 ondisk->mtime.nsec =htonl(ce->ce_mtime.nsec);1525 ondisk->dev =htonl(ce->ce_dev);1526 ondisk->ino =htonl(ce->ce_ino);1527 ondisk->mode =htonl(ce->ce_mode);1528 ondisk->uid =htonl(ce->ce_uid);1529 ondisk->gid =htonl(ce->ce_gid);1530 ondisk->size =htonl(ce->ce_size);1531hashcpy(ondisk->sha1, ce->sha1);1532 ondisk->flags =htons(ce->ce_flags);1533if(ce->ce_flags & CE_EXTENDED) {1534struct ondisk_cache_entry_extended *ondisk2;1535 ondisk2 = (struct ondisk_cache_entry_extended *)ondisk;1536 ondisk2->flags2 =htons((ce->ce_flags & CE_EXTENDED_FLAGS) >>16);1537 name = ondisk2->name;1538}1539else1540 name = ondisk->name;1541memcpy(name, ce->name,ce_namelen(ce));15421543returnce_write(c, fd, ondisk, size);1544}15451546intwrite_index(struct index_state *istate,int newfd)1547{1548 git_SHA_CTX c;1549struct cache_header hdr;1550int i, err, removed, extended;1551struct cache_entry **cache = istate->cache;1552int entries = istate->cache_nr;1553struct stat st;15541555for(i = removed = extended =0; i < entries; i++) {1556if(cache[i]->ce_flags & CE_REMOVE)1557 removed++;15581559/* reduce extended entries if possible */1560 cache[i]->ce_flags &= ~CE_EXTENDED;1561if(cache[i]->ce_flags & CE_EXTENDED_FLAGS) {1562 extended++;1563 cache[i]->ce_flags |= CE_EXTENDED;1564}1565}15661567 hdr.hdr_signature =htonl(CACHE_SIGNATURE);1568/* for extended format, increase version so older git won't try to read it */1569 hdr.hdr_version =htonl(extended ?3:2);1570 hdr.hdr_entries =htonl(entries - removed);15711572git_SHA1_Init(&c);1573if(ce_write(&c, newfd, &hdr,sizeof(hdr)) <0)1574return-1;15751576for(i =0; i < entries; i++) {1577struct cache_entry *ce = cache[i];1578if(ce->ce_flags & CE_REMOVE)1579continue;1580if(!ce_uptodate(ce) &&is_racy_timestamp(istate, ce))1581ce_smudge_racily_clean_entry(ce);1582if(ce_write_entry(&c, newfd, ce) <0)1583return-1;1584}15851586/* Write extension data here */1587if(istate->cache_tree) {1588struct strbuf sb = STRBUF_INIT;15891590cache_tree_write(&sb, istate->cache_tree);1591 err =write_index_ext_header(&c, newfd, CACHE_EXT_TREE, sb.len) <01592||ce_write(&c, newfd, sb.buf, sb.len) <0;1593strbuf_release(&sb);1594if(err)1595return-1;1596}1597if(istate->resolve_undo) {1598struct strbuf sb = STRBUF_INIT;15991600resolve_undo_write(&sb, istate->resolve_undo);1601 err =write_index_ext_header(&c, newfd, CACHE_EXT_RESOLVE_UNDO,1602 sb.len) <01603||ce_write(&c, newfd, sb.buf, sb.len) <0;1604strbuf_release(&sb);1605if(err)1606return-1;1607}16081609if(ce_flush(&c, newfd) ||fstat(newfd, &st))1610return-1;1611 istate->timestamp.sec = (unsigned int)st.st_mtime;1612 istate->timestamp.nsec =ST_MTIME_NSEC(st);1613return0;1614}16151616/*1617 * Read the index file that is potentially unmerged into given1618 * index_state, dropping any unmerged entries. Returns true if1619 * the index is unmerged. Callers who want to refuse to work1620 * from an unmerged state can call this and check its return value,1621 * instead of calling read_cache().1622 */1623intread_index_unmerged(struct index_state *istate)1624{1625int i;1626int unmerged =0;16271628read_index(istate);1629for(i =0; i < istate->cache_nr; i++) {1630struct cache_entry *ce = istate->cache[i];1631struct cache_entry *new_ce;1632int size, len;16331634if(!ce_stage(ce))1635continue;1636 unmerged =1;1637 len =strlen(ce->name);1638 size =cache_entry_size(len);1639 new_ce =xcalloc(1, size);1640memcpy(new_ce->name, ce->name, len);1641 new_ce->ce_flags =create_ce_flags(len,0) | CE_CONFLICTED;1642 new_ce->ce_mode = ce->ce_mode;1643if(add_index_entry(istate, new_ce,0))1644returnerror("%s: cannot drop to stage #0",1645 ce->name);1646 i =index_name_pos(istate, new_ce->name, len);1647}1648return unmerged;1649}16501651struct update_callback_data1652{1653int flags;1654int add_errors;1655};16561657static voidupdate_callback(struct diff_queue_struct *q,1658struct diff_options *opt,void*cbdata)1659{1660int i;1661struct update_callback_data *data = cbdata;16621663for(i =0; i < q->nr; i++) {1664struct diff_filepair *p = q->queue[i];1665const char*path = p->one->path;1666switch(p->status) {1667default:1668die("unexpected diff status%c", p->status);1669case DIFF_STATUS_UNMERGED:1670/*1671 * ADD_CACHE_IGNORE_REMOVAL is unset if "git1672 * add -u" is calling us, In such a case, a1673 * missing work tree file needs to be removed1674 * if there is an unmerged entry at stage #2,1675 * but such a diff record is followed by1676 * another with DIFF_STATUS_DELETED (and if1677 * there is no stage #2, we won't see DELETED1678 * nor MODIFIED). We can simply continue1679 * either way.1680 */1681if(!(data->flags & ADD_CACHE_IGNORE_REMOVAL))1682continue;1683/*1684 * Otherwise, it is "git add path" is asking1685 * to explicitly add it; we fall through. A1686 * missing work tree file is an error and is1687 * caught by add_file_to_index() in such a1688 * case.1689 */1690case DIFF_STATUS_MODIFIED:1691case DIFF_STATUS_TYPE_CHANGED:1692if(add_file_to_index(&the_index, path, data->flags)) {1693if(!(data->flags & ADD_CACHE_IGNORE_ERRORS))1694die("updating files failed");1695 data->add_errors++;1696}1697break;1698case DIFF_STATUS_DELETED:1699if(data->flags & ADD_CACHE_IGNORE_REMOVAL)1700break;1701if(!(data->flags & ADD_CACHE_PRETEND))1702remove_file_from_index(&the_index, path);1703if(data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))1704printf("remove '%s'\n", path);1705break;1706}1707}1708}17091710intadd_files_to_cache(const char*prefix,const char**pathspec,int flags)1711{1712struct update_callback_data data;1713struct rev_info rev;1714init_revisions(&rev, prefix);1715setup_revisions(0, NULL, &rev, NULL);1716 rev.prune_data = pathspec;1717 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;1718 rev.diffopt.format_callback = update_callback;1719 data.flags = flags;1720 data.add_errors =0;1721 rev.diffopt.format_callback_data = &data;1722run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);1723return!!data.add_errors;1724}17251726/*1727 * Returns 1 if the path is an "other" path with respect to1728 * the index; that is, the path is not mentioned in the index at all,1729 * either as a file, a directory with some files in the index,1730 * or as an unmerged entry.1731 *1732 * We helpfully remove a trailing "/" from directories so that1733 * the output of read_directory can be used as-is.1734 */1735intindex_name_is_other(const struct index_state *istate,const char*name,1736int namelen)1737{1738int pos;1739if(namelen && name[namelen -1] =='/')1740 namelen--;1741 pos =index_name_pos(istate, name, namelen);1742if(0<= pos)1743return0;/* exact match */1744 pos = -pos -1;1745if(pos < istate->cache_nr) {1746struct cache_entry *ce = istate->cache[pos];1747if(ce_namelen(ce) == namelen &&1748!memcmp(ce->name, name, namelen))1749return0;/* Yup, this one exists unmerged */1750}1751return1;1752}