1/* 2 * This handles recursive filename detection with exclude 3 * files, index knowledge etc.. 4 * 5 * See Documentation/technical/api-directory-listing.txt 6 * 7 * Copyright (C) Linus Torvalds, 2005-2006 8 * Junio Hamano, 2005-2006 9 */ 10#define NO_THE_INDEX_COMPATIBILITY_MACROS 11#include"cache.h" 12#include"dir.h" 13#include"attr.h" 14#include"refs.h" 15#include"wildmatch.h" 16#include"pathspec.h" 17#include"utf8.h" 18#include"varint.h" 19#include"ewah/ewok.h" 20 21/* 22 * Tells read_directory_recursive how a file or directory should be treated. 23 * Values are ordered by significance, e.g. if a directory contains both 24 * excluded and untracked files, it is listed as untracked because 25 * path_untracked > path_excluded. 26 */ 27enum path_treatment { 28 path_none =0, 29 path_recurse, 30 path_excluded, 31 path_untracked 32}; 33 34/* 35 * Support data structure for our opendir/readdir/closedir wrappers 36 */ 37struct cached_dir { 38DIR*fdir; 39struct untracked_cache_dir *untracked; 40int nr_files; 41int nr_dirs; 42 43struct dirent *de; 44const char*file; 45struct untracked_cache_dir *ucd; 46}; 47 48static enum path_treatment read_directory_recursive(struct dir_struct *dir, 49const char*path,int len,struct untracked_cache_dir *untracked, 50int check_only,const struct pathspec *pathspec); 51static intget_dtype(struct dirent *de,struct index_state *istate, 52const char*path,int len); 53 54intfspathcmp(const char*a,const char*b) 55{ 56return ignore_case ?strcasecmp(a, b) :strcmp(a, b); 57} 58 59intfspathncmp(const char*a,const char*b,size_t count) 60{ 61return ignore_case ?strncasecmp(a, b, count) :strncmp(a, b, count); 62} 63 64intgit_fnmatch(const struct pathspec_item *item, 65const char*pattern,const char*string, 66int prefix) 67{ 68if(prefix >0) { 69if(ps_strncmp(item, pattern, string, prefix)) 70return WM_NOMATCH; 71 pattern += prefix; 72 string += prefix; 73} 74if(item->flags & PATHSPEC_ONESTAR) { 75int pattern_len =strlen(++pattern); 76int string_len =strlen(string); 77return string_len < pattern_len || 78ps_strcmp(item, pattern, 79 string + string_len - pattern_len); 80} 81if(item->magic & PATHSPEC_GLOB) 82returnwildmatch(pattern, string, 83 WM_PATHNAME | 84(item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0), 85 NULL); 86else 87/* wildmatch has not learned no FNM_PATHNAME mode yet */ 88returnwildmatch(pattern, string, 89 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0, 90 NULL); 91} 92 93static intfnmatch_icase_mem(const char*pattern,int patternlen, 94const char*string,int stringlen, 95int flags) 96{ 97int match_status; 98struct strbuf pat_buf = STRBUF_INIT; 99struct strbuf str_buf = STRBUF_INIT; 100const char*use_pat = pattern; 101const char*use_str = string; 102 103if(pattern[patternlen]) { 104strbuf_add(&pat_buf, pattern, patternlen); 105 use_pat = pat_buf.buf; 106} 107if(string[stringlen]) { 108strbuf_add(&str_buf, string, stringlen); 109 use_str = str_buf.buf; 110} 111 112if(ignore_case) 113 flags |= WM_CASEFOLD; 114 match_status =wildmatch(use_pat, use_str, flags, NULL); 115 116strbuf_release(&pat_buf); 117strbuf_release(&str_buf); 118 119return match_status; 120} 121 122static size_tcommon_prefix_len(const struct pathspec *pathspec) 123{ 124int n; 125size_t max =0; 126 127/* 128 * ":(icase)path" is treated as a pathspec full of 129 * wildcard. In other words, only prefix is considered common 130 * prefix. If the pathspec is abc/foo abc/bar, running in 131 * subdir xyz, the common prefix is still xyz, not xuz/abc as 132 * in non-:(icase). 133 */ 134GUARD_PATHSPEC(pathspec, 135 PATHSPEC_FROMTOP | 136 PATHSPEC_MAXDEPTH | 137 PATHSPEC_LITERAL | 138 PATHSPEC_GLOB | 139 PATHSPEC_ICASE | 140 PATHSPEC_EXCLUDE | 141 PATHSPEC_ATTR); 142 143for(n =0; n < pathspec->nr; n++) { 144size_t i =0, len =0, item_len; 145if(pathspec->items[n].magic & PATHSPEC_EXCLUDE) 146continue; 147if(pathspec->items[n].magic & PATHSPEC_ICASE) 148 item_len = pathspec->items[n].prefix; 149else 150 item_len = pathspec->items[n].nowildcard_len; 151while(i < item_len && (n ==0|| i < max)) { 152char c = pathspec->items[n].match[i]; 153if(c != pathspec->items[0].match[i]) 154break; 155if(c =='/') 156 len = i +1; 157 i++; 158} 159if(n ==0|| len < max) { 160 max = len; 161if(!max) 162break; 163} 164} 165return max; 166} 167 168/* 169 * Returns a copy of the longest leading path common among all 170 * pathspecs. 171 */ 172char*common_prefix(const struct pathspec *pathspec) 173{ 174unsigned long len =common_prefix_len(pathspec); 175 176return len ?xmemdupz(pathspec->items[0].match, len) : NULL; 177} 178 179intfill_directory(struct dir_struct *dir,const struct pathspec *pathspec) 180{ 181const char*prefix; 182size_t prefix_len; 183 184/* 185 * Calculate common prefix for the pathspec, and 186 * use that to optimize the directory walk 187 */ 188 prefix_len =common_prefix_len(pathspec); 189 prefix = prefix_len ? pathspec->items[0].match :""; 190 191/* Read the directory and prune it */ 192read_directory(dir, prefix, prefix_len, pathspec); 193 194return prefix_len; 195} 196 197intwithin_depth(const char*name,int namelen, 198int depth,int max_depth) 199{ 200const char*cp = name, *cpe = name + namelen; 201 202while(cp < cpe) { 203if(*cp++ !='/') 204continue; 205 depth++; 206if(depth > max_depth) 207return0; 208} 209return1; 210} 211 212#define DO_MATCH_EXCLUDE (1<<0) 213#define DO_MATCH_DIRECTORY (1<<1) 214#define DO_MATCH_SUBMODULE (1<<2) 215 216static intmatch_attrs(const char*name,int namelen, 217const struct pathspec_item *item) 218{ 219int i; 220 221git_check_attr(name, item->attr_check); 222for(i =0; i < item->attr_match_nr; i++) { 223const char*value; 224int matched; 225enum attr_match_mode match_mode; 226 227 value = item->attr_check->items[i].value; 228 match_mode = item->attr_match[i].match_mode; 229 230if(ATTR_TRUE(value)) 231 matched = (match_mode == MATCH_SET); 232else if(ATTR_FALSE(value)) 233 matched = (match_mode == MATCH_UNSET); 234else if(ATTR_UNSET(value)) 235 matched = (match_mode == MATCH_UNSPECIFIED); 236else 237 matched = (match_mode == MATCH_VALUE && 238!strcmp(item->attr_match[i].value, value)); 239if(!matched) 240return0; 241} 242 243return1; 244} 245 246/* 247 * Does 'match' match the given name? 248 * A match is found if 249 * 250 * (1) the 'match' string is leading directory of 'name', or 251 * (2) the 'match' string is a wildcard and matches 'name', or 252 * (3) the 'match' string is exactly the same as 'name'. 253 * 254 * and the return value tells which case it was. 255 * 256 * It returns 0 when there is no match. 257 */ 258static intmatch_pathspec_item(const struct pathspec_item *item,int prefix, 259const char*name,int namelen,unsigned flags) 260{ 261/* name/namelen has prefix cut off by caller */ 262const char*match = item->match + prefix; 263int matchlen = item->len - prefix; 264 265/* 266 * The normal call pattern is: 267 * 1. prefix = common_prefix_len(ps); 268 * 2. prune something, or fill_directory 269 * 3. match_pathspec() 270 * 271 * 'prefix' at #1 may be shorter than the command's prefix and 272 * it's ok for #2 to match extra files. Those extras will be 273 * trimmed at #3. 274 * 275 * Suppose the pathspec is 'foo' and '../bar' running from 276 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 277 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 278 * user does not want XYZ/foo, only the "foo" part should be 279 * case-insensitive. We need to filter out XYZ/foo here. In 280 * other words, we do not trust the caller on comparing the 281 * prefix part when :(icase) is involved. We do exact 282 * comparison ourselves. 283 * 284 * Normally the caller (common_prefix_len() in fact) does 285 * _exact_ matching on name[-prefix+1..-1] and we do not need 286 * to check that part. Be defensive and check it anyway, in 287 * case common_prefix_len is changed, or a new caller is 288 * introduced that does not use common_prefix_len. 289 * 290 * If the penalty turns out too high when prefix is really 291 * long, maybe change it to 292 * strncmp(match, name, item->prefix - prefix) 293 */ 294if(item->prefix && (item->magic & PATHSPEC_ICASE) && 295strncmp(item->match, name - prefix, item->prefix)) 296return0; 297 298if(item->attr_match_nr && !match_attrs(name, namelen, item)) 299return0; 300 301/* If the match was just the prefix, we matched */ 302if(!*match) 303return MATCHED_RECURSIVELY; 304 305if(matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 306if(matchlen == namelen) 307return MATCHED_EXACTLY; 308 309if(match[matchlen-1] =='/'|| name[matchlen] =='/') 310return MATCHED_RECURSIVELY; 311}else if((flags & DO_MATCH_DIRECTORY) && 312 match[matchlen -1] =='/'&& 313 namelen == matchlen -1&& 314!ps_strncmp(item, match, name, namelen)) 315return MATCHED_EXACTLY; 316 317if(item->nowildcard_len < item->len && 318!git_fnmatch(item, match, name, 319 item->nowildcard_len - prefix)) 320return MATCHED_FNMATCH; 321 322/* Perform checks to see if "name" is a super set of the pathspec */ 323if(flags & DO_MATCH_SUBMODULE) { 324/* name is a literal prefix of the pathspec */ 325if((namelen < matchlen) && 326(match[namelen] =='/') && 327!ps_strncmp(item, match, name, namelen)) 328return MATCHED_RECURSIVELY; 329 330/* name" doesn't match up to the first wild character */ 331if(item->nowildcard_len < item->len && 332ps_strncmp(item, match, name, 333 item->nowildcard_len - prefix)) 334return0; 335 336/* 337 * Here is where we would perform a wildmatch to check if 338 * "name" can be matched as a directory (or a prefix) against 339 * the pathspec. Since wildmatch doesn't have this capability 340 * at the present we have to punt and say that it is a match, 341 * potentially returning a false positive 342 * The submodules themselves will be able to perform more 343 * accurate matching to determine if the pathspec matches. 344 */ 345return MATCHED_RECURSIVELY; 346} 347 348return0; 349} 350 351/* 352 * Given a name and a list of pathspecs, returns the nature of the 353 * closest (i.e. most specific) match of the name to any of the 354 * pathspecs. 355 * 356 * The caller typically calls this multiple times with the same 357 * pathspec and seen[] array but with different name/namelen 358 * (e.g. entries from the index) and is interested in seeing if and 359 * how each pathspec matches all the names it calls this function 360 * with. A mark is left in the seen[] array for each pathspec element 361 * indicating the closest type of match that element achieved, so if 362 * seen[n] remains zero after multiple invocations, that means the nth 363 * pathspec did not match any names, which could indicate that the 364 * user mistyped the nth pathspec. 365 */ 366static intdo_match_pathspec(const struct pathspec *ps, 367const char*name,int namelen, 368int prefix,char*seen, 369unsigned flags) 370{ 371int i, retval =0, exclude = flags & DO_MATCH_EXCLUDE; 372 373GUARD_PATHSPEC(ps, 374 PATHSPEC_FROMTOP | 375 PATHSPEC_MAXDEPTH | 376 PATHSPEC_LITERAL | 377 PATHSPEC_GLOB | 378 PATHSPEC_ICASE | 379 PATHSPEC_EXCLUDE | 380 PATHSPEC_ATTR); 381 382if(!ps->nr) { 383if(!ps->recursive || 384!(ps->magic & PATHSPEC_MAXDEPTH) || 385 ps->max_depth == -1) 386return MATCHED_RECURSIVELY; 387 388if(within_depth(name, namelen,0, ps->max_depth)) 389return MATCHED_EXACTLY; 390else 391return0; 392} 393 394 name += prefix; 395 namelen -= prefix; 396 397for(i = ps->nr -1; i >=0; i--) { 398int how; 399 400if((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 401( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 402continue; 403 404if(seen && seen[i] == MATCHED_EXACTLY) 405continue; 406/* 407 * Make exclude patterns optional and never report 408 * "pathspec ':(exclude)foo' matches no files" 409 */ 410if(seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 411 seen[i] = MATCHED_FNMATCH; 412 how =match_pathspec_item(ps->items+i, prefix, name, 413 namelen, flags); 414if(ps->recursive && 415(ps->magic & PATHSPEC_MAXDEPTH) && 416 ps->max_depth != -1&& 417 how && how != MATCHED_FNMATCH) { 418int len = ps->items[i].len; 419if(name[len] =='/') 420 len++; 421if(within_depth(name+len, namelen-len,0, ps->max_depth)) 422 how = MATCHED_EXACTLY; 423else 424 how =0; 425} 426if(how) { 427if(retval < how) 428 retval = how; 429if(seen && seen[i] < how) 430 seen[i] = how; 431} 432} 433return retval; 434} 435 436intmatch_pathspec(const struct pathspec *ps, 437const char*name,int namelen, 438int prefix,char*seen,int is_dir) 439{ 440int positive, negative; 441unsigned flags = is_dir ? DO_MATCH_DIRECTORY :0; 442 positive =do_match_pathspec(ps, name, namelen, 443 prefix, seen, flags); 444if(!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 445return positive; 446 negative =do_match_pathspec(ps, name, namelen, 447 prefix, seen, 448 flags | DO_MATCH_EXCLUDE); 449return negative ?0: positive; 450} 451 452/** 453 * Check if a submodule is a superset of the pathspec 454 */ 455intsubmodule_path_match(const struct pathspec *ps, 456const char*submodule_name, 457char*seen) 458{ 459int matched =do_match_pathspec(ps, submodule_name, 460strlen(submodule_name), 4610, seen, 462 DO_MATCH_DIRECTORY | 463 DO_MATCH_SUBMODULE); 464return matched; 465} 466 467intreport_path_error(const char*ps_matched, 468const struct pathspec *pathspec, 469const char*prefix) 470{ 471/* 472 * Make sure all pathspec matched; otherwise it is an error. 473 */ 474int num, errors =0; 475for(num =0; num < pathspec->nr; num++) { 476int other, found_dup; 477 478if(ps_matched[num]) 479continue; 480/* 481 * The caller might have fed identical pathspec 482 * twice. Do not barf on such a mistake. 483 * FIXME: parse_pathspec should have eliminated 484 * duplicate pathspec. 485 */ 486for(found_dup = other =0; 487!found_dup && other < pathspec->nr; 488 other++) { 489if(other == num || !ps_matched[other]) 490continue; 491if(!strcmp(pathspec->items[other].original, 492 pathspec->items[num].original)) 493/* 494 * Ok, we have a match already. 495 */ 496 found_dup =1; 497} 498if(found_dup) 499continue; 500 501error("pathspec '%s' did not match any file(s) known to git.", 502 pathspec->items[num].original); 503 errors++; 504} 505return errors; 506} 507 508/* 509 * Return the length of the "simple" part of a path match limiter. 510 */ 511intsimple_length(const char*match) 512{ 513int len = -1; 514 515for(;;) { 516unsigned char c = *match++; 517 len++; 518if(c =='\0'||is_glob_special(c)) 519return len; 520} 521} 522 523intno_wildcard(const char*string) 524{ 525return string[simple_length(string)] =='\0'; 526} 527 528voidparse_exclude_pattern(const char**pattern, 529int*patternlen, 530unsigned*flags, 531int*nowildcardlen) 532{ 533const char*p = *pattern; 534size_t i, len; 535 536*flags =0; 537if(*p =='!') { 538*flags |= EXC_FLAG_NEGATIVE; 539 p++; 540} 541 len =strlen(p); 542if(len && p[len -1] =='/') { 543 len--; 544*flags |= EXC_FLAG_MUSTBEDIR; 545} 546for(i =0; i < len; i++) { 547if(p[i] =='/') 548break; 549} 550if(i == len) 551*flags |= EXC_FLAG_NODIR; 552*nowildcardlen =simple_length(p); 553/* 554 * we should have excluded the trailing slash from 'p' too, 555 * but that's one more allocation. Instead just make sure 556 * nowildcardlen does not exceed real patternlen 557 */ 558if(*nowildcardlen > len) 559*nowildcardlen = len; 560if(*p =='*'&&no_wildcard(p +1)) 561*flags |= EXC_FLAG_ENDSWITH; 562*pattern = p; 563*patternlen = len; 564} 565 566voidadd_exclude(const char*string,const char*base, 567int baselen,struct exclude_list *el,int srcpos) 568{ 569struct exclude *x; 570int patternlen; 571unsigned flags; 572int nowildcardlen; 573 574parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 575if(flags & EXC_FLAG_MUSTBEDIR) { 576FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 577}else{ 578 x =xmalloc(sizeof(*x)); 579 x->pattern = string; 580} 581 x->patternlen = patternlen; 582 x->nowildcardlen = nowildcardlen; 583 x->base = base; 584 x->baselen = baselen; 585 x->flags = flags; 586 x->srcpos = srcpos; 587ALLOC_GROW(el->excludes, el->nr +1, el->alloc); 588 el->excludes[el->nr++] = x; 589 x->el = el; 590} 591 592static void*read_skip_worktree_file_from_index(const struct index_state *istate, 593const char*path,size_t*size, 594struct sha1_stat *sha1_stat) 595{ 596int pos, len; 597unsigned long sz; 598enum object_type type; 599void*data; 600 601 len =strlen(path); 602 pos =index_name_pos(istate, path, len); 603if(pos <0) 604return NULL; 605if(!ce_skip_worktree(istate->cache[pos])) 606return NULL; 607 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz); 608if(!data || type != OBJ_BLOB) { 609free(data); 610return NULL; 611} 612*size =xsize_t(sz); 613if(sha1_stat) { 614memset(&sha1_stat->stat,0,sizeof(sha1_stat->stat)); 615hashcpy(sha1_stat->sha1, istate->cache[pos]->oid.hash); 616} 617return data; 618} 619 620/* 621 * Frees memory within el which was allocated for exclude patterns and 622 * the file buffer. Does not free el itself. 623 */ 624voidclear_exclude_list(struct exclude_list *el) 625{ 626int i; 627 628for(i =0; i < el->nr; i++) 629free(el->excludes[i]); 630free(el->excludes); 631free(el->filebuf); 632 633memset(el,0,sizeof(*el)); 634} 635 636static voidtrim_trailing_spaces(char*buf) 637{ 638char*p, *last_space = NULL; 639 640for(p = buf; *p; p++) 641switch(*p) { 642case' ': 643if(!last_space) 644 last_space = p; 645break; 646case'\\': 647 p++; 648if(!*p) 649return; 650/* fallthrough */ 651default: 652 last_space = NULL; 653} 654 655if(last_space) 656*last_space ='\0'; 657} 658 659/* 660 * Given a subdirectory name and "dir" of the current directory, 661 * search the subdir in "dir" and return it, or create a new one if it 662 * does not exist in "dir". 663 * 664 * If "name" has the trailing slash, it'll be excluded in the search. 665 */ 666static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 667struct untracked_cache_dir *dir, 668const char*name,int len) 669{ 670int first, last; 671struct untracked_cache_dir *d; 672if(!dir) 673return NULL; 674if(len && name[len -1] =='/') 675 len--; 676 first =0; 677 last = dir->dirs_nr; 678while(last > first) { 679int cmp, next = (last + first) >>1; 680 d = dir->dirs[next]; 681 cmp =strncmp(name, d->name, len); 682if(!cmp &&strlen(d->name) > len) 683 cmp = -1; 684if(!cmp) 685return d; 686if(cmp <0) { 687 last = next; 688continue; 689} 690 first = next+1; 691} 692 693 uc->dir_created++; 694FLEX_ALLOC_MEM(d, name, name, len); 695 696ALLOC_GROW(dir->dirs, dir->dirs_nr +1, dir->dirs_alloc); 697memmove(dir->dirs + first +1, dir->dirs + first, 698(dir->dirs_nr - first) *sizeof(*dir->dirs)); 699 dir->dirs_nr++; 700 dir->dirs[first] = d; 701return d; 702} 703 704static voiddo_invalidate_gitignore(struct untracked_cache_dir *dir) 705{ 706int i; 707 dir->valid =0; 708 dir->untracked_nr =0; 709for(i =0; i < dir->dirs_nr; i++) 710do_invalidate_gitignore(dir->dirs[i]); 711} 712 713static voidinvalidate_gitignore(struct untracked_cache *uc, 714struct untracked_cache_dir *dir) 715{ 716 uc->gitignore_invalidated++; 717do_invalidate_gitignore(dir); 718} 719 720static voidinvalidate_directory(struct untracked_cache *uc, 721struct untracked_cache_dir *dir) 722{ 723int i; 724 uc->dir_invalidated++; 725 dir->valid =0; 726 dir->untracked_nr =0; 727for(i =0; i < dir->dirs_nr; i++) 728 dir->dirs[i]->recurse =0; 729} 730 731/* 732 * Given a file with name "fname", read it (either from disk, or from 733 * the index if "check_index" is non-zero), parse it and store the 734 * exclude rules in "el". 735 * 736 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 737 * stat data from disk (only valid if add_excludes returns zero). If 738 * ss_valid is non-zero, "ss" must contain good value as input. 739 */ 740static intadd_excludes(const char*fname,const char*base,int baselen, 741struct exclude_list *el,int check_index, 742struct sha1_stat *sha1_stat) 743{ 744struct stat st; 745int fd, i, lineno =1; 746size_t size =0; 747char*buf, *entry; 748 749 fd =open(fname, O_RDONLY); 750if(fd <0||fstat(fd, &st) <0) { 751if(errno != ENOENT) 752warn_on_inaccessible(fname); 753if(0<= fd) 754close(fd); 755if(!check_index || 756(buf =read_skip_worktree_file_from_index(&the_index, fname, &size, sha1_stat)) == NULL) 757return-1; 758if(size ==0) { 759free(buf); 760return0; 761} 762if(buf[size-1] !='\n') { 763 buf =xrealloc(buf,st_add(size,1)); 764 buf[size++] ='\n'; 765} 766}else{ 767 size =xsize_t(st.st_size); 768if(size ==0) { 769if(sha1_stat) { 770fill_stat_data(&sha1_stat->stat, &st); 771hashcpy(sha1_stat->sha1, EMPTY_BLOB_SHA1_BIN); 772 sha1_stat->valid =1; 773} 774close(fd); 775return0; 776} 777 buf =xmallocz(size); 778if(read_in_full(fd, buf, size) != size) { 779free(buf); 780close(fd); 781return-1; 782} 783 buf[size++] ='\n'; 784close(fd); 785if(sha1_stat) { 786int pos; 787if(sha1_stat->valid && 788!match_stat_data_racy(&the_index, &sha1_stat->stat, &st)) 789;/* no content change, ss->sha1 still good */ 790else if(check_index && 791(pos =index_name_pos(&the_index, fname,strlen(fname))) >=0&& 792!ce_stage(the_index.cache[pos]) && 793ce_uptodate(the_index.cache[pos]) && 794!would_convert_to_git(fname)) 795hashcpy(sha1_stat->sha1, 796 the_index.cache[pos]->oid.hash); 797else 798hash_sha1_file(buf, size,"blob", sha1_stat->sha1); 799fill_stat_data(&sha1_stat->stat, &st); 800 sha1_stat->valid =1; 801} 802} 803 804 el->filebuf = buf; 805 806if(skip_utf8_bom(&buf, size)) 807 size -= buf - el->filebuf; 808 809 entry = buf; 810 811for(i =0; i < size; i++) { 812if(buf[i] =='\n') { 813if(entry != buf + i && entry[0] !='#') { 814 buf[i - (i && buf[i-1] =='\r')] =0; 815trim_trailing_spaces(entry); 816add_exclude(entry, base, baselen, el, lineno); 817} 818 lineno++; 819 entry = buf + i +1; 820} 821} 822return0; 823} 824 825intadd_excludes_from_file_to_list(const char*fname,const char*base, 826int baselen,struct exclude_list *el, 827int check_index) 828{ 829returnadd_excludes(fname, base, baselen, el, check_index, NULL); 830} 831 832struct exclude_list *add_exclude_list(struct dir_struct *dir, 833int group_type,const char*src) 834{ 835struct exclude_list *el; 836struct exclude_list_group *group; 837 838 group = &dir->exclude_list_group[group_type]; 839ALLOC_GROW(group->el, group->nr +1, group->alloc); 840 el = &group->el[group->nr++]; 841memset(el,0,sizeof(*el)); 842 el->src = src; 843return el; 844} 845 846/* 847 * Used to set up core.excludesfile and .git/info/exclude lists. 848 */ 849static voidadd_excludes_from_file_1(struct dir_struct *dir,const char*fname, 850struct sha1_stat *sha1_stat) 851{ 852struct exclude_list *el; 853/* 854 * catch setup_standard_excludes() that's called before 855 * dir->untracked is assigned. That function behaves 856 * differently when dir->untracked is non-NULL. 857 */ 858if(!dir->untracked) 859 dir->unmanaged_exclude_files++; 860 el =add_exclude_list(dir, EXC_FILE, fname); 861if(add_excludes(fname,"",0, el,0, sha1_stat) <0) 862die("cannot use%sas an exclude file", fname); 863} 864 865voidadd_excludes_from_file(struct dir_struct *dir,const char*fname) 866{ 867 dir->unmanaged_exclude_files++;/* see validate_untracked_cache() */ 868add_excludes_from_file_1(dir, fname, NULL); 869} 870 871intmatch_basename(const char*basename,int basenamelen, 872const char*pattern,int prefix,int patternlen, 873unsigned flags) 874{ 875if(prefix == patternlen) { 876if(patternlen == basenamelen && 877!fspathncmp(pattern, basename, basenamelen)) 878return1; 879}else if(flags & EXC_FLAG_ENDSWITH) { 880/* "*literal" matching against "fooliteral" */ 881if(patternlen -1<= basenamelen && 882!fspathncmp(pattern +1, 883 basename + basenamelen - (patternlen -1), 884 patternlen -1)) 885return1; 886}else{ 887if(fnmatch_icase_mem(pattern, patternlen, 888 basename, basenamelen, 8890) ==0) 890return1; 891} 892return0; 893} 894 895intmatch_pathname(const char*pathname,int pathlen, 896const char*base,int baselen, 897const char*pattern,int prefix,int patternlen, 898unsigned flags) 899{ 900const char*name; 901int namelen; 902 903/* 904 * match with FNM_PATHNAME; the pattern has base implicitly 905 * in front of it. 906 */ 907if(*pattern =='/') { 908 pattern++; 909 patternlen--; 910 prefix--; 911} 912 913/* 914 * baselen does not count the trailing slash. base[] may or 915 * may not end with a trailing slash though. 916 */ 917if(pathlen < baselen +1|| 918(baselen && pathname[baselen] !='/') || 919fspathncmp(pathname, base, baselen)) 920return0; 921 922 namelen = baselen ? pathlen - baselen -1: pathlen; 923 name = pathname + pathlen - namelen; 924 925if(prefix) { 926/* 927 * if the non-wildcard part is longer than the 928 * remaining pathname, surely it cannot match. 929 */ 930if(prefix > namelen) 931return0; 932 933if(fspathncmp(pattern, name, prefix)) 934return0; 935 pattern += prefix; 936 patternlen -= prefix; 937 name += prefix; 938 namelen -= prefix; 939 940/* 941 * If the whole pattern did not have a wildcard, 942 * then our prefix match is all we need; we 943 * do not need to call fnmatch at all. 944 */ 945if(!patternlen && !namelen) 946return1; 947} 948 949returnfnmatch_icase_mem(pattern, patternlen, 950 name, namelen, 951 WM_PATHNAME) ==0; 952} 953 954/* 955 * Scan the given exclude list in reverse to see whether pathname 956 * should be ignored. The first match (i.e. the last on the list), if 957 * any, determines the fate. Returns the exclude_list element which 958 * matched, or NULL for undecided. 959 */ 960static struct exclude *last_exclude_matching_from_list(const char*pathname, 961int pathlen, 962const char*basename, 963int*dtype, 964struct exclude_list *el) 965{ 966struct exclude *exc = NULL;/* undecided */ 967int i; 968 969if(!el->nr) 970return NULL;/* undefined */ 971 972for(i = el->nr -1;0<= i; i--) { 973struct exclude *x = el->excludes[i]; 974const char*exclude = x->pattern; 975int prefix = x->nowildcardlen; 976 977if(x->flags & EXC_FLAG_MUSTBEDIR) { 978if(*dtype == DT_UNKNOWN) 979*dtype =get_dtype(NULL, &the_index, pathname, pathlen); 980if(*dtype != DT_DIR) 981continue; 982} 983 984if(x->flags & EXC_FLAG_NODIR) { 985if(match_basename(basename, 986 pathlen - (basename - pathname), 987 exclude, prefix, x->patternlen, 988 x->flags)) { 989 exc = x; 990break; 991} 992continue; 993} 994 995assert(x->baselen ==0|| x->base[x->baselen -1] =='/'); 996if(match_pathname(pathname, pathlen, 997 x->base, x->baselen ? x->baselen -1:0, 998 exclude, prefix, x->patternlen, x->flags)) { 999 exc = x;1000break;1001}1002}1003return exc;1004}10051006/*1007 * Scan the list and let the last match determine the fate.1008 * Return 1 for exclude, 0 for include and -1 for undecided.1009 */1010intis_excluded_from_list(const char*pathname,1011int pathlen,const char*basename,int*dtype,1012struct exclude_list *el)1013{1014struct exclude *exclude;1015 exclude =last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el);1016if(exclude)1017return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1018return-1;/* undecided */1019}10201021static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1022const char*pathname,int pathlen,const char*basename,1023int*dtype_p)1024{1025int i, j;1026struct exclude_list_group *group;1027struct exclude *exclude;1028for(i = EXC_CMDL; i <= EXC_FILE; i++) {1029 group = &dir->exclude_list_group[i];1030for(j = group->nr -1; j >=0; j--) {1031 exclude =last_exclude_matching_from_list(1032 pathname, pathlen, basename, dtype_p,1033&group->el[j]);1034if(exclude)1035return exclude;1036}1037}1038return NULL;1039}10401041/*1042 * Loads the per-directory exclude list for the substring of base1043 * which has a char length of baselen.1044 */1045static voidprep_exclude(struct dir_struct *dir,const char*base,int baselen)1046{1047struct exclude_list_group *group;1048struct exclude_list *el;1049struct exclude_stack *stk = NULL;1050struct untracked_cache_dir *untracked;1051int current;10521053 group = &dir->exclude_list_group[EXC_DIRS];10541055/*1056 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1057 * which originate from directories not in the prefix of the1058 * path being checked.1059 */1060while((stk = dir->exclude_stack) != NULL) {1061if(stk->baselen <= baselen &&1062!strncmp(dir->basebuf.buf, base, stk->baselen))1063break;1064 el = &group->el[dir->exclude_stack->exclude_ix];1065 dir->exclude_stack = stk->prev;1066 dir->exclude = NULL;1067free((char*)el->src);/* see strbuf_detach() below */1068clear_exclude_list(el);1069free(stk);1070 group->nr--;1071}10721073/* Skip traversing into sub directories if the parent is excluded */1074if(dir->exclude)1075return;10761077/*1078 * Lazy initialization. All call sites currently just1079 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1080 * them seems lots of work for little benefit.1081 */1082if(!dir->basebuf.buf)1083strbuf_init(&dir->basebuf, PATH_MAX);10841085/* Read from the parent directories and push them down. */1086 current = stk ? stk->baselen : -1;1087strbuf_setlen(&dir->basebuf, current <0?0: current);1088if(dir->untracked)1089 untracked = stk ? stk->ucd : dir->untracked->root;1090else1091 untracked = NULL;10921093while(current < baselen) {1094const char*cp;1095struct sha1_stat sha1_stat;10961097 stk =xcalloc(1,sizeof(*stk));1098if(current <0) {1099 cp = base;1100 current =0;1101}else{1102 cp =strchr(base + current +1,'/');1103if(!cp)1104die("oops in prep_exclude");1105 cp++;1106 untracked =1107lookup_untracked(dir->untracked, untracked,1108 base + current,1109 cp - base - current);1110}1111 stk->prev = dir->exclude_stack;1112 stk->baselen = cp - base;1113 stk->exclude_ix = group->nr;1114 stk->ucd = untracked;1115 el =add_exclude_list(dir, EXC_DIRS, NULL);1116strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1117assert(stk->baselen == dir->basebuf.len);11181119/* Abort if the directory is excluded */1120if(stk->baselen) {1121int dt = DT_DIR;1122 dir->basebuf.buf[stk->baselen -1] =0;1123 dir->exclude =last_exclude_matching_from_lists(dir,1124 dir->basebuf.buf, stk->baselen -1,1125 dir->basebuf.buf + current, &dt);1126 dir->basebuf.buf[stk->baselen -1] ='/';1127if(dir->exclude &&1128 dir->exclude->flags & EXC_FLAG_NEGATIVE)1129 dir->exclude = NULL;1130if(dir->exclude) {1131 dir->exclude_stack = stk;1132return;1133}1134}11351136/* Try to read per-directory file */1137hashclr(sha1_stat.sha1);1138 sha1_stat.valid =0;1139if(dir->exclude_per_dir &&1140/*1141 * If we know that no files have been added in1142 * this directory (i.e. valid_cached_dir() has1143 * been executed and set untracked->valid) ..1144 */1145(!untracked || !untracked->valid ||1146/*1147 * .. and .gitignore does not exist before1148 * (i.e. null exclude_sha1). Then we can skip1149 * loading .gitignore, which would result in1150 * ENOENT anyway.1151 */1152!is_null_sha1(untracked->exclude_sha1))) {1153/*1154 * dir->basebuf gets reused by the traversal, but we1155 * need fname to remain unchanged to ensure the src1156 * member of each struct exclude correctly1157 * back-references its source file. Other invocations1158 * of add_exclude_list provide stable strings, so we1159 * strbuf_detach() and free() here in the caller.1160 */1161struct strbuf sb = STRBUF_INIT;1162strbuf_addbuf(&sb, &dir->basebuf);1163strbuf_addstr(&sb, dir->exclude_per_dir);1164 el->src =strbuf_detach(&sb, NULL);1165add_excludes(el->src, el->src, stk->baselen, el,1,1166 untracked ? &sha1_stat : NULL);1167}1168/*1169 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1170 * will first be called in valid_cached_dir() then maybe many1171 * times more in last_exclude_matching(). When the cache is1172 * used, last_exclude_matching() will not be called and1173 * reading .gitignore content will be a waste.1174 *1175 * So when it's called by valid_cached_dir() and we can get1176 * .gitignore SHA-1 from the index (i.e. .gitignore is not1177 * modified on work tree), we could delay reading the1178 * .gitignore content until we absolutely need it in1179 * last_exclude_matching(). Be careful about ignore rule1180 * order, though, if you do that.1181 */1182if(untracked &&1183hashcmp(sha1_stat.sha1, untracked->exclude_sha1)) {1184invalidate_gitignore(dir->untracked, untracked);1185hashcpy(untracked->exclude_sha1, sha1_stat.sha1);1186}1187 dir->exclude_stack = stk;1188 current = stk->baselen;1189}1190strbuf_setlen(&dir->basebuf, baselen);1191}11921193/*1194 * Loads the exclude lists for the directory containing pathname, then1195 * scans all exclude lists to determine whether pathname is excluded.1196 * Returns the exclude_list element which matched, or NULL for1197 * undecided.1198 */1199struct exclude *last_exclude_matching(struct dir_struct *dir,1200const char*pathname,1201int*dtype_p)1202{1203int pathlen =strlen(pathname);1204const char*basename =strrchr(pathname,'/');1205 basename = (basename) ? basename+1: pathname;12061207prep_exclude(dir, pathname, basename-pathname);12081209if(dir->exclude)1210return dir->exclude;12111212returnlast_exclude_matching_from_lists(dir, pathname, pathlen,1213 basename, dtype_p);1214}12151216/*1217 * Loads the exclude lists for the directory containing pathname, then1218 * scans all exclude lists to determine whether pathname is excluded.1219 * Returns 1 if true, otherwise 0.1220 */1221intis_excluded(struct dir_struct *dir,const char*pathname,int*dtype_p)1222{1223struct exclude *exclude =1224last_exclude_matching(dir, pathname, dtype_p);1225if(exclude)1226return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1227return0;1228}12291230static struct dir_entry *dir_entry_new(const char*pathname,int len)1231{1232struct dir_entry *ent;12331234FLEX_ALLOC_MEM(ent, name, pathname, len);1235 ent->len = len;1236return ent;1237}12381239static struct dir_entry *dir_add_name(struct dir_struct *dir,const char*pathname,int len)1240{1241if(index_file_exists(&the_index, pathname, len, ignore_case))1242return NULL;12431244ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1245return dir->entries[dir->nr++] =dir_entry_new(pathname, len);1246}12471248struct dir_entry *dir_add_ignored(struct dir_struct *dir,const char*pathname,int len)1249{1250if(!index_name_is_other(&the_index, pathname, len))1251return NULL;12521253ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1254return dir->ignored[dir->ignored_nr++] =dir_entry_new(pathname, len);1255}12561257enum exist_status {1258 index_nonexistent =0,1259 index_directory,1260 index_gitdir1261};12621263/*1264 * Do not use the alphabetically sorted index to look up1265 * the directory name; instead, use the case insensitive1266 * directory hash.1267 */1268static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1269const char*dirname,int len)1270{1271struct cache_entry *ce;12721273if(index_dir_exists(istate, dirname, len))1274return index_directory;12751276 ce =index_file_exists(istate, dirname, len, ignore_case);1277if(ce &&S_ISGITLINK(ce->ce_mode))1278return index_gitdir;12791280return index_nonexistent;1281}12821283/*1284 * The index sorts alphabetically by entry name, which1285 * means that a gitlink sorts as '\0' at the end, while1286 * a directory (which is defined not as an entry, but as1287 * the files it contains) will sort with the '/' at the1288 * end.1289 */1290static enum exist_status directory_exists_in_index(struct index_state *istate,1291const char*dirname,int len)1292{1293int pos;12941295if(ignore_case)1296returndirectory_exists_in_index_icase(istate, dirname, len);12971298 pos =index_name_pos(istate, dirname, len);1299if(pos <0)1300 pos = -pos-1;1301while(pos < istate->cache_nr) {1302const struct cache_entry *ce = istate->cache[pos++];1303unsigned char endchar;13041305if(strncmp(ce->name, dirname, len))1306break;1307 endchar = ce->name[len];1308if(endchar >'/')1309break;1310if(endchar =='/')1311return index_directory;1312if(!endchar &&S_ISGITLINK(ce->ce_mode))1313return index_gitdir;1314}1315return index_nonexistent;1316}13171318/*1319 * When we find a directory when traversing the filesystem, we1320 * have three distinct cases:1321 *1322 * - ignore it1323 * - see it as a directory1324 * - recurse into it1325 *1326 * and which one we choose depends on a combination of existing1327 * git index contents and the flags passed into the directory1328 * traversal routine.1329 *1330 * Case 1: If we *already* have entries in the index under that1331 * directory name, we always recurse into the directory to see1332 * all the files.1333 *1334 * Case 2: If we *already* have that directory name as a gitlink,1335 * we always continue to see it as a gitlink, regardless of whether1336 * there is an actual git directory there or not (it might not1337 * be checked out as a subproject!)1338 *1339 * Case 3: if we didn't have it in the index previously, we1340 * have a few sub-cases:1341 *1342 * (a) if "show_other_directories" is true, we show it as1343 * just a directory, unless "hide_empty_directories" is1344 * also true, in which case we need to check if it contains any1345 * untracked and / or ignored files.1346 * (b) if it looks like a git directory, and we don't have1347 * 'no_gitlinks' set we treat it as a gitlink, and show it1348 * as a directory.1349 * (c) otherwise, we recurse into it.1350 */1351static enum path_treatment treat_directory(struct dir_struct *dir,1352struct untracked_cache_dir *untracked,1353const char*dirname,int len,int baselen,int exclude,1354const struct pathspec *pathspec)1355{1356/* The "len-1" is to strip the final '/' */1357switch(directory_exists_in_index(&the_index, dirname, len-1)) {1358case index_directory:1359return path_recurse;13601361case index_gitdir:1362return path_none;13631364case index_nonexistent:1365if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1366break;1367if(!(dir->flags & DIR_NO_GITLINKS)) {1368unsigned char sha1[20];1369if(resolve_gitlink_ref(dirname,"HEAD", sha1) ==0)1370return path_untracked;1371}1372return path_recurse;1373}13741375/* This is the "show_other_directories" case */13761377if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1378return exclude ? path_excluded : path_untracked;13791380 untracked =lookup_untracked(dir->untracked, untracked,1381 dirname + baselen, len - baselen);1382returnread_directory_recursive(dir, dirname, len,1383 untracked,1, pathspec);1384}13851386/*1387 * This is an inexact early pruning of any recursive directory1388 * reading - if the path cannot possibly be in the pathspec,1389 * return true, and we'll skip it early.1390 */1391static intsimplify_away(const char*path,int pathlen,1392const struct pathspec *pathspec)1393{1394int i;13951396if(!pathspec || !pathspec->nr)1397return0;13981399GUARD_PATHSPEC(pathspec,1400 PATHSPEC_FROMTOP |1401 PATHSPEC_MAXDEPTH |1402 PATHSPEC_LITERAL |1403 PATHSPEC_GLOB |1404 PATHSPEC_ICASE |1405 PATHSPEC_EXCLUDE |1406 PATHSPEC_ATTR);14071408for(i =0; i < pathspec->nr; i++) {1409const struct pathspec_item *item = &pathspec->items[i];1410int len = item->nowildcard_len;14111412if(len > pathlen)1413 len = pathlen;1414if(!ps_strncmp(item, item->match, path, len))1415return0;1416}14171418return1;1419}14201421/*1422 * This function tells us whether an excluded path matches a1423 * list of "interesting" pathspecs. That is, whether a path matched1424 * by any of the pathspecs could possibly be ignored by excluding1425 * the specified path. This can happen if:1426 *1427 * 1. the path is mentioned explicitly in the pathspec1428 *1429 * 2. the path is a directory prefix of some element in the1430 * pathspec1431 */1432static intexclude_matches_pathspec(const char*path,int pathlen,1433const struct pathspec *pathspec)1434{1435int i;14361437if(!pathspec || !pathspec->nr)1438return0;14391440GUARD_PATHSPEC(pathspec,1441 PATHSPEC_FROMTOP |1442 PATHSPEC_MAXDEPTH |1443 PATHSPEC_LITERAL |1444 PATHSPEC_GLOB |1445 PATHSPEC_ICASE |1446 PATHSPEC_EXCLUDE);14471448for(i =0; i < pathspec->nr; i++) {1449const struct pathspec_item *item = &pathspec->items[i];1450int len = item->nowildcard_len;14511452if(len == pathlen &&1453!ps_strncmp(item, item->match, path, pathlen))1454return1;1455if(len > pathlen &&1456 item->match[pathlen] =='/'&&1457!ps_strncmp(item, item->match, path, pathlen))1458return1;1459}1460return0;1461}14621463static intget_index_dtype(struct index_state *istate,1464const char*path,int len)1465{1466int pos;1467const struct cache_entry *ce;14681469 ce =index_file_exists(istate, path, len,0);1470if(ce) {1471if(!ce_uptodate(ce))1472return DT_UNKNOWN;1473if(S_ISGITLINK(ce->ce_mode))1474return DT_DIR;1475/*1476 * Nobody actually cares about the1477 * difference between DT_LNK and DT_REG1478 */1479return DT_REG;1480}14811482/* Try to look it up as a directory */1483 pos =index_name_pos(istate, path, len);1484if(pos >=0)1485return DT_UNKNOWN;1486 pos = -pos-1;1487while(pos < istate->cache_nr) {1488 ce = istate->cache[pos++];1489if(strncmp(ce->name, path, len))1490break;1491if(ce->name[len] >'/')1492break;1493if(ce->name[len] <'/')1494continue;1495if(!ce_uptodate(ce))1496break;/* continue? */1497return DT_DIR;1498}1499return DT_UNKNOWN;1500}15011502static intget_dtype(struct dirent *de,struct index_state *istate,1503const char*path,int len)1504{1505int dtype = de ?DTYPE(de) : DT_UNKNOWN;1506struct stat st;15071508if(dtype != DT_UNKNOWN)1509return dtype;1510 dtype =get_index_dtype(istate, path, len);1511if(dtype != DT_UNKNOWN)1512return dtype;1513if(lstat(path, &st))1514return dtype;1515if(S_ISREG(st.st_mode))1516return DT_REG;1517if(S_ISDIR(st.st_mode))1518return DT_DIR;1519if(S_ISLNK(st.st_mode))1520return DT_LNK;1521return dtype;1522}15231524static enum path_treatment treat_one_path(struct dir_struct *dir,1525struct untracked_cache_dir *untracked,1526struct strbuf *path,1527int baselen,1528const struct pathspec *pathspec,1529int dtype,struct dirent *de)1530{1531int exclude;1532int has_path_in_index = !!index_file_exists(&the_index, path->buf, path->len, ignore_case);15331534if(dtype == DT_UNKNOWN)1535 dtype =get_dtype(de, &the_index, path->buf, path->len);15361537/* Always exclude indexed files */1538if(dtype != DT_DIR && has_path_in_index)1539return path_none;15401541/*1542 * When we are looking at a directory P in the working tree,1543 * there are three cases:1544 *1545 * (1) P exists in the index. Everything inside the directory P in1546 * the working tree needs to go when P is checked out from the1547 * index.1548 *1549 * (2) P does not exist in the index, but there is P/Q in the index.1550 * We know P will stay a directory when we check out the contents1551 * of the index, but we do not know yet if there is a directory1552 * P/Q in the working tree to be killed, so we need to recurse.1553 *1554 * (3) P does not exist in the index, and there is no P/Q in the index1555 * to require P to be a directory, either. Only in this case, we1556 * know that everything inside P will not be killed without1557 * recursing.1558 */1559if((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1560(dtype == DT_DIR) &&1561!has_path_in_index &&1562(directory_exists_in_index(&the_index, path->buf, path->len) == index_nonexistent))1563return path_none;15641565 exclude =is_excluded(dir, path->buf, &dtype);15661567/*1568 * Excluded? If we don't explicitly want to show1569 * ignored files, ignore it1570 */1571if(exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1572return path_excluded;15731574switch(dtype) {1575default:1576return path_none;1577case DT_DIR:1578strbuf_addch(path,'/');1579returntreat_directory(dir, untracked, path->buf, path->len,1580 baselen, exclude, pathspec);1581case DT_REG:1582case DT_LNK:1583return exclude ? path_excluded : path_untracked;1584}1585}15861587static enum path_treatment treat_path_fast(struct dir_struct *dir,1588struct untracked_cache_dir *untracked,1589struct cached_dir *cdir,1590struct strbuf *path,1591int baselen,1592const struct pathspec *pathspec)1593{1594strbuf_setlen(path, baselen);1595if(!cdir->ucd) {1596strbuf_addstr(path, cdir->file);1597return path_untracked;1598}1599strbuf_addstr(path, cdir->ucd->name);1600/* treat_one_path() does this before it calls treat_directory() */1601strbuf_complete(path,'/');1602if(cdir->ucd->check_only)1603/*1604 * check_only is set as a result of treat_directory() getting1605 * to its bottom. Verify again the same set of directories1606 * with check_only set.1607 */1608returnread_directory_recursive(dir, path->buf, path->len,1609 cdir->ucd,1, pathspec);1610/*1611 * We get path_recurse in the first run when1612 * directory_exists_in_index() returns index_nonexistent. We1613 * are sure that new changes in the index does not impact the1614 * outcome. Return now.1615 */1616return path_recurse;1617}16181619static enum path_treatment treat_path(struct dir_struct *dir,1620struct untracked_cache_dir *untracked,1621struct cached_dir *cdir,1622struct strbuf *path,1623int baselen,1624const struct pathspec *pathspec)1625{1626int dtype;1627struct dirent *de = cdir->de;16281629if(!de)1630returntreat_path_fast(dir, untracked, cdir, path,1631 baselen, pathspec);1632if(is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name,".git"))1633return path_none;1634strbuf_setlen(path, baselen);1635strbuf_addstr(path, de->d_name);1636if(simplify_away(path->buf, path->len, pathspec))1637return path_none;16381639 dtype =DTYPE(de);1640returntreat_one_path(dir, untracked, path, baselen, pathspec, dtype, de);1641}16421643static voidadd_untracked(struct untracked_cache_dir *dir,const char*name)1644{1645if(!dir)1646return;1647ALLOC_GROW(dir->untracked, dir->untracked_nr +1,1648 dir->untracked_alloc);1649 dir->untracked[dir->untracked_nr++] =xstrdup(name);1650}16511652static intvalid_cached_dir(struct dir_struct *dir,1653struct untracked_cache_dir *untracked,1654struct strbuf *path,1655int check_only)1656{1657struct stat st;16581659if(!untracked)1660return0;16611662if(stat(path->len ? path->buf :".", &st)) {1663invalidate_directory(dir->untracked, untracked);1664memset(&untracked->stat_data,0,sizeof(untracked->stat_data));1665return0;1666}1667if(!untracked->valid ||1668match_stat_data_racy(&the_index, &untracked->stat_data, &st)) {1669if(untracked->valid)1670invalidate_directory(dir->untracked, untracked);1671fill_stat_data(&untracked->stat_data, &st);1672return0;1673}16741675if(untracked->check_only != !!check_only) {1676invalidate_directory(dir->untracked, untracked);1677return0;1678}16791680/*1681 * prep_exclude will be called eventually on this directory,1682 * but it's called much later in last_exclude_matching(). We1683 * need it now to determine the validity of the cache for this1684 * path. The next calls will be nearly no-op, the way1685 * prep_exclude() is designed.1686 */1687if(path->len && path->buf[path->len -1] !='/') {1688strbuf_addch(path,'/');1689prep_exclude(dir, path->buf, path->len);1690strbuf_setlen(path, path->len -1);1691}else1692prep_exclude(dir, path->buf, path->len);16931694/* hopefully prep_exclude() haven't invalidated this entry... */1695return untracked->valid;1696}16971698static intopen_cached_dir(struct cached_dir *cdir,1699struct dir_struct *dir,1700struct untracked_cache_dir *untracked,1701struct strbuf *path,1702int check_only)1703{1704memset(cdir,0,sizeof(*cdir));1705 cdir->untracked = untracked;1706if(valid_cached_dir(dir, untracked, path, check_only))1707return0;1708 cdir->fdir =opendir(path->len ? path->buf :".");1709if(dir->untracked)1710 dir->untracked->dir_opened++;1711if(!cdir->fdir)1712return-1;1713return0;1714}17151716static intread_cached_dir(struct cached_dir *cdir)1717{1718if(cdir->fdir) {1719 cdir->de =readdir(cdir->fdir);1720if(!cdir->de)1721return-1;1722return0;1723}1724while(cdir->nr_dirs < cdir->untracked->dirs_nr) {1725struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1726if(!d->recurse) {1727 cdir->nr_dirs++;1728continue;1729}1730 cdir->ucd = d;1731 cdir->nr_dirs++;1732return0;1733}1734 cdir->ucd = NULL;1735if(cdir->nr_files < cdir->untracked->untracked_nr) {1736struct untracked_cache_dir *d = cdir->untracked;1737 cdir->file = d->untracked[cdir->nr_files++];1738return0;1739}1740return-1;1741}17421743static voidclose_cached_dir(struct cached_dir *cdir)1744{1745if(cdir->fdir)1746closedir(cdir->fdir);1747/*1748 * We have gone through this directory and found no untracked1749 * entries. Mark it valid.1750 */1751if(cdir->untracked) {1752 cdir->untracked->valid =1;1753 cdir->untracked->recurse =1;1754}1755}17561757/*1758 * Read a directory tree. We currently ignore anything but1759 * directories, regular files and symlinks. That's because git1760 * doesn't handle them at all yet. Maybe that will change some1761 * day.1762 *1763 * Also, we ignore the name ".git" (even if it is not a directory).1764 * That likely will not change.1765 *1766 * Returns the most significant path_treatment value encountered in the scan.1767 */1768static enum path_treatment read_directory_recursive(struct dir_struct *dir,1769const char*base,int baselen,1770struct untracked_cache_dir *untracked,int check_only,1771const struct pathspec *pathspec)1772{1773struct cached_dir cdir;1774enum path_treatment state, subdir_state, dir_state = path_none;1775struct strbuf path = STRBUF_INIT;17761777strbuf_add(&path, base, baselen);17781779if(open_cached_dir(&cdir, dir, untracked, &path, check_only))1780goto out;17811782if(untracked)1783 untracked->check_only = !!check_only;17841785while(!read_cached_dir(&cdir)) {1786/* check how the file or directory should be treated */1787 state =treat_path(dir, untracked, &cdir, &path,1788 baselen, pathspec);17891790if(state > dir_state)1791 dir_state = state;17921793/* recurse into subdir if instructed by treat_path */1794if(state == path_recurse) {1795struct untracked_cache_dir *ud;1796 ud =lookup_untracked(dir->untracked, untracked,1797 path.buf + baselen,1798 path.len - baselen);1799 subdir_state =1800read_directory_recursive(dir, path.buf,1801 path.len, ud,1802 check_only, pathspec);1803if(subdir_state > dir_state)1804 dir_state = subdir_state;1805}18061807if(check_only) {1808/* abort early if maximum state has been reached */1809if(dir_state == path_untracked) {1810if(cdir.fdir)1811add_untracked(untracked, path.buf + baselen);1812break;1813}1814/* skip the dir_add_* part */1815continue;1816}18171818/* add the path to the appropriate result list */1819switch(state) {1820case path_excluded:1821if(dir->flags & DIR_SHOW_IGNORED)1822dir_add_name(dir, path.buf, path.len);1823else if((dir->flags & DIR_SHOW_IGNORED_TOO) ||1824((dir->flags & DIR_COLLECT_IGNORED) &&1825exclude_matches_pathspec(path.buf, path.len,1826 pathspec)))1827dir_add_ignored(dir, path.buf, path.len);1828break;18291830case path_untracked:1831if(dir->flags & DIR_SHOW_IGNORED)1832break;1833dir_add_name(dir, path.buf, path.len);1834if(cdir.fdir)1835add_untracked(untracked, path.buf + baselen);1836break;18371838default:1839break;1840}1841}1842close_cached_dir(&cdir);1843 out:1844strbuf_release(&path);18451846return dir_state;1847}18481849static intcmp_name(const void*p1,const void*p2)1850{1851const struct dir_entry *e1 = *(const struct dir_entry **)p1;1852const struct dir_entry *e2 = *(const struct dir_entry **)p2;18531854returnname_compare(e1->name, e1->len, e2->name, e2->len);1855}18561857static inttreat_leading_path(struct dir_struct *dir,1858const char*path,int len,1859const struct pathspec *pathspec)1860{1861struct strbuf sb = STRBUF_INIT;1862int baselen, rc =0;1863const char*cp;1864int old_flags = dir->flags;18651866while(len && path[len -1] =='/')1867 len--;1868if(!len)1869return1;1870 baselen =0;1871 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1872while(1) {1873 cp = path + baselen + !!baselen;1874 cp =memchr(cp,'/', path + len - cp);1875if(!cp)1876 baselen = len;1877else1878 baselen = cp - path;1879strbuf_setlen(&sb,0);1880strbuf_add(&sb, path, baselen);1881if(!is_directory(sb.buf))1882break;1883if(simplify_away(sb.buf, sb.len, pathspec))1884break;1885if(treat_one_path(dir, NULL, &sb, baselen, pathspec,1886 DT_DIR, NULL) == path_none)1887break;/* do not recurse into it */1888if(len <= baselen) {1889 rc =1;1890break;/* finished checking */1891}1892}1893strbuf_release(&sb);1894 dir->flags = old_flags;1895return rc;1896}18971898static const char*get_ident_string(void)1899{1900static struct strbuf sb = STRBUF_INIT;1901struct utsname uts;19021903if(sb.len)1904return sb.buf;1905if(uname(&uts) <0)1906die_errno(_("failed to get kernel name and information"));1907strbuf_addf(&sb,"Location%s, system%s",get_git_work_tree(),1908 uts.sysname);1909return sb.buf;1910}19111912static intident_in_untracked(const struct untracked_cache *uc)1913{1914/*1915 * Previous git versions may have saved many NUL separated1916 * strings in the "ident" field, but it is insane to manage1917 * many locations, so just take care of the first one.1918 */19191920return!strcmp(uc->ident.buf,get_ident_string());1921}19221923static voidset_untracked_ident(struct untracked_cache *uc)1924{1925strbuf_reset(&uc->ident);1926strbuf_addstr(&uc->ident,get_ident_string());19271928/*1929 * This strbuf used to contain a list of NUL separated1930 * strings, so save NUL too for backward compatibility.1931 */1932strbuf_addch(&uc->ident,0);1933}19341935static voidnew_untracked_cache(struct index_state *istate)1936{1937struct untracked_cache *uc =xcalloc(1,sizeof(*uc));1938strbuf_init(&uc->ident,100);1939 uc->exclude_per_dir =".gitignore";1940/* should be the same flags used by git-status */1941 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;1942set_untracked_ident(uc);1943 istate->untracked = uc;1944 istate->cache_changed |= UNTRACKED_CHANGED;1945}19461947voidadd_untracked_cache(struct index_state *istate)1948{1949if(!istate->untracked) {1950new_untracked_cache(istate);1951}else{1952if(!ident_in_untracked(istate->untracked)) {1953free_untracked_cache(istate->untracked);1954new_untracked_cache(istate);1955}1956}1957}19581959voidremove_untracked_cache(struct index_state *istate)1960{1961if(istate->untracked) {1962free_untracked_cache(istate->untracked);1963 istate->untracked = NULL;1964 istate->cache_changed |= UNTRACKED_CHANGED;1965}1966}19671968static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,1969int base_len,1970const struct pathspec *pathspec)1971{1972struct untracked_cache_dir *root;19731974if(!dir->untracked ||getenv("GIT_DISABLE_UNTRACKED_CACHE"))1975return NULL;19761977/*1978 * We only support $GIT_DIR/info/exclude and core.excludesfile1979 * as the global ignore rule files. Any other additions1980 * (e.g. from command line) invalidate the cache. This1981 * condition also catches running setup_standard_excludes()1982 * before setting dir->untracked!1983 */1984if(dir->unmanaged_exclude_files)1985return NULL;19861987/*1988 * Optimize for the main use case only: whole-tree git1989 * status. More work involved in treat_leading_path() if we1990 * use cache on just a subset of the worktree. pathspec1991 * support could make the matter even worse.1992 */1993if(base_len || (pathspec && pathspec->nr))1994return NULL;19951996/* Different set of flags may produce different results */1997if(dir->flags != dir->untracked->dir_flags ||1998/*1999 * See treat_directory(), case index_nonexistent. Without2000 * this flag, we may need to also cache .git file content2001 * for the resolve_gitlink_ref() call, which we don't.2002 */2003!(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2004/* We don't support collecting ignore files */2005(dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2006 DIR_COLLECT_IGNORED)))2007return NULL;20082009/*2010 * If we use .gitignore in the cache and now you change it to2011 * .gitexclude, everything will go wrong.2012 */2013if(dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2014strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2015return NULL;20162017/*2018 * EXC_CMDL is not considered in the cache. If people set it,2019 * skip the cache.2020 */2021if(dir->exclude_list_group[EXC_CMDL].nr)2022return NULL;20232024if(!ident_in_untracked(dir->untracked)) {2025warning(_("Untracked cache is disabled on this system or location."));2026return NULL;2027}20282029if(!dir->untracked->root) {2030const int len =sizeof(*dir->untracked->root);2031 dir->untracked->root =xmalloc(len);2032memset(dir->untracked->root,0, len);2033}20342035/* Validate $GIT_DIR/info/exclude and core.excludesfile */2036 root = dir->untracked->root;2037if(hashcmp(dir->ss_info_exclude.sha1,2038 dir->untracked->ss_info_exclude.sha1)) {2039invalidate_gitignore(dir->untracked, root);2040 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2041}2042if(hashcmp(dir->ss_excludes_file.sha1,2043 dir->untracked->ss_excludes_file.sha1)) {2044invalidate_gitignore(dir->untracked, root);2045 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2046}20472048/* Make sure this directory is not dropped out at saving phase */2049 root->recurse =1;2050return root;2051}20522053intread_directory(struct dir_struct *dir,const char*path,2054int len,const struct pathspec *pathspec)2055{2056struct untracked_cache_dir *untracked;20572058if(has_symlink_leading_path(path, len))2059return dir->nr;20602061 untracked =validate_untracked_cache(dir, len, pathspec);2062if(!untracked)2063/*2064 * make sure untracked cache code path is disabled,2065 * e.g. prep_exclude()2066 */2067 dir->untracked = NULL;2068if(!len ||treat_leading_path(dir, path, len, pathspec))2069read_directory_recursive(dir, path, len, untracked,0, pathspec);2070QSORT(dir->entries, dir->nr, cmp_name);2071QSORT(dir->ignored, dir->ignored_nr, cmp_name);2072if(dir->untracked) {2073static struct trace_key trace_untracked_stats =TRACE_KEY_INIT(UNTRACKED_STATS);2074trace_printf_key(&trace_untracked_stats,2075"node creation:%u\n"2076"gitignore invalidation:%u\n"2077"directory invalidation:%u\n"2078"opendir:%u\n",2079 dir->untracked->dir_created,2080 dir->untracked->gitignore_invalidated,2081 dir->untracked->dir_invalidated,2082 dir->untracked->dir_opened);2083if(dir->untracked == the_index.untracked &&2084(dir->untracked->dir_opened ||2085 dir->untracked->gitignore_invalidated ||2086 dir->untracked->dir_invalidated))2087 the_index.cache_changed |= UNTRACKED_CHANGED;2088if(dir->untracked != the_index.untracked) {2089free(dir->untracked);2090 dir->untracked = NULL;2091}2092}2093return dir->nr;2094}20952096intfile_exists(const char*f)2097{2098struct stat sb;2099returnlstat(f, &sb) ==0;2100}21012102static intcmp_icase(char a,char b)2103{2104if(a == b)2105return0;2106if(ignore_case)2107returntoupper(a) -toupper(b);2108return a - b;2109}21102111/*2112 * Given two normalized paths (a trailing slash is ok), if subdir is2113 * outside dir, return -1. Otherwise return the offset in subdir that2114 * can be used as relative path to dir.2115 */2116intdir_inside_of(const char*subdir,const char*dir)2117{2118int offset =0;21192120assert(dir && subdir && *dir && *subdir);21212122while(*dir && *subdir && !cmp_icase(*dir, *subdir)) {2123 dir++;2124 subdir++;2125 offset++;2126}21272128/* hel[p]/me vs hel[l]/yeah */2129if(*dir && *subdir)2130return-1;21312132if(!*subdir)2133return!*dir ? offset : -1;/* same dir */21342135/* foo/[b]ar vs foo/[] */2136if(is_dir_sep(dir[-1]))2137returnis_dir_sep(subdir[-1]) ? offset : -1;21382139/* foo[/]bar vs foo[] */2140returnis_dir_sep(*subdir) ? offset +1: -1;2141}21422143intis_inside_dir(const char*dir)2144{2145char*cwd;2146int rc;21472148if(!dir)2149return0;21502151 cwd =xgetcwd();2152 rc = (dir_inside_of(cwd, dir) >=0);2153free(cwd);2154return rc;2155}21562157intis_empty_dir(const char*path)2158{2159DIR*dir =opendir(path);2160struct dirent *e;2161int ret =1;21622163if(!dir)2164return0;21652166while((e =readdir(dir)) != NULL)2167if(!is_dot_or_dotdot(e->d_name)) {2168 ret =0;2169break;2170}21712172closedir(dir);2173return ret;2174}21752176static intremove_dir_recurse(struct strbuf *path,int flag,int*kept_up)2177{2178DIR*dir;2179struct dirent *e;2180int ret =0, original_len = path->len, len, kept_down =0;2181int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2182int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2183unsigned char submodule_head[20];21842185if((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2186!resolve_gitlink_ref(path->buf,"HEAD", submodule_head)) {2187/* Do not descend and nuke a nested git work tree. */2188if(kept_up)2189*kept_up =1;2190return0;2191}21922193 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2194 dir =opendir(path->buf);2195if(!dir) {2196if(errno == ENOENT)2197return keep_toplevel ? -1:0;2198else if(errno == EACCES && !keep_toplevel)2199/*2200 * An empty dir could be removable even if it2201 * is unreadable:2202 */2203returnrmdir(path->buf);2204else2205return-1;2206}2207strbuf_complete(path,'/');22082209 len = path->len;2210while((e =readdir(dir)) != NULL) {2211struct stat st;2212if(is_dot_or_dotdot(e->d_name))2213continue;22142215strbuf_setlen(path, len);2216strbuf_addstr(path, e->d_name);2217if(lstat(path->buf, &st)) {2218if(errno == ENOENT)2219/*2220 * file disappeared, which is what we2221 * wanted anyway2222 */2223continue;2224/* fall thru */2225}else if(S_ISDIR(st.st_mode)) {2226if(!remove_dir_recurse(path, flag, &kept_down))2227continue;/* happy */2228}else if(!only_empty &&2229(!unlink(path->buf) || errno == ENOENT)) {2230continue;/* happy, too */2231}22322233/* path too long, stat fails, or non-directory still exists */2234 ret = -1;2235break;2236}2237closedir(dir);22382239strbuf_setlen(path, original_len);2240if(!ret && !keep_toplevel && !kept_down)2241 ret = (!rmdir(path->buf) || errno == ENOENT) ?0: -1;2242else if(kept_up)2243/*2244 * report the uplevel that it is not an error that we2245 * did not rmdir() our directory.2246 */2247*kept_up = !ret;2248return ret;2249}22502251intremove_dir_recursively(struct strbuf *path,int flag)2252{2253returnremove_dir_recurse(path, flag, NULL);2254}22552256staticGIT_PATH_FUNC(git_path_info_exclude,"info/exclude")22572258voidsetup_standard_excludes(struct dir_struct *dir)2259{2260 dir->exclude_per_dir =".gitignore";22612262/* core.excludefile defaulting to $XDG_HOME/git/ignore */2263if(!excludes_file)2264 excludes_file =xdg_config_home("ignore");2265if(excludes_file && !access_or_warn(excludes_file, R_OK,0))2266add_excludes_from_file_1(dir, excludes_file,2267 dir->untracked ? &dir->ss_excludes_file : NULL);22682269/* per repository user preference */2270if(startup_info->have_repository) {2271const char*path =git_path_info_exclude();2272if(!access_or_warn(path, R_OK,0))2273add_excludes_from_file_1(dir, path,2274 dir->untracked ? &dir->ss_info_exclude : NULL);2275}2276}22772278intremove_path(const char*name)2279{2280char*slash;22812282if(unlink(name) && errno != ENOENT && errno != ENOTDIR)2283return-1;22842285 slash =strrchr(name,'/');2286if(slash) {2287char*dirs =xstrdup(name);2288 slash = dirs + (slash - name);2289do{2290*slash ='\0';2291}while(rmdir(dirs) ==0&& (slash =strrchr(dirs,'/')));2292free(dirs);2293}2294return0;2295}22962297/*2298 * Frees memory within dir which was allocated for exclude lists and2299 * the exclude_stack. Does not free dir itself.2300 */2301voidclear_directory(struct dir_struct *dir)2302{2303int i, j;2304struct exclude_list_group *group;2305struct exclude_list *el;2306struct exclude_stack *stk;23072308for(i = EXC_CMDL; i <= EXC_FILE; i++) {2309 group = &dir->exclude_list_group[i];2310for(j =0; j < group->nr; j++) {2311 el = &group->el[j];2312if(i == EXC_DIRS)2313free((char*)el->src);2314clear_exclude_list(el);2315}2316free(group->el);2317}23182319 stk = dir->exclude_stack;2320while(stk) {2321struct exclude_stack *prev = stk->prev;2322free(stk);2323 stk = prev;2324}2325strbuf_release(&dir->basebuf);2326}23272328struct ondisk_untracked_cache {2329struct stat_data info_exclude_stat;2330struct stat_data excludes_file_stat;2331uint32_t dir_flags;2332unsigned char info_exclude_sha1[20];2333unsigned char excludes_file_sha1[20];2334char exclude_per_dir[FLEX_ARRAY];2335};23362337#define ouc_size(len) (offsetof(struct ondisk_untracked_cache, exclude_per_dir) + len + 1)23382339struct write_data {2340int index;/* number of written untracked_cache_dir */2341struct ewah_bitmap *check_only;/* from untracked_cache_dir */2342struct ewah_bitmap *valid;/* from untracked_cache_dir */2343struct ewah_bitmap *sha1_valid;/* set if exclude_sha1 is not null */2344struct strbuf out;2345struct strbuf sb_stat;2346struct strbuf sb_sha1;2347};23482349static voidstat_data_to_disk(struct stat_data *to,const struct stat_data *from)2350{2351 to->sd_ctime.sec =htonl(from->sd_ctime.sec);2352 to->sd_ctime.nsec =htonl(from->sd_ctime.nsec);2353 to->sd_mtime.sec =htonl(from->sd_mtime.sec);2354 to->sd_mtime.nsec =htonl(from->sd_mtime.nsec);2355 to->sd_dev =htonl(from->sd_dev);2356 to->sd_ino =htonl(from->sd_ino);2357 to->sd_uid =htonl(from->sd_uid);2358 to->sd_gid =htonl(from->sd_gid);2359 to->sd_size =htonl(from->sd_size);2360}23612362static voidwrite_one_dir(struct untracked_cache_dir *untracked,2363struct write_data *wd)2364{2365struct stat_data stat_data;2366struct strbuf *out = &wd->out;2367unsigned char intbuf[16];2368unsigned int intlen, value;2369int i = wd->index++;23702371/*2372 * untracked_nr should be reset whenever valid is clear, but2373 * for safety..2374 */2375if(!untracked->valid) {2376 untracked->untracked_nr =0;2377 untracked->check_only =0;2378}23792380if(untracked->check_only)2381ewah_set(wd->check_only, i);2382if(untracked->valid) {2383ewah_set(wd->valid, i);2384stat_data_to_disk(&stat_data, &untracked->stat_data);2385strbuf_add(&wd->sb_stat, &stat_data,sizeof(stat_data));2386}2387if(!is_null_sha1(untracked->exclude_sha1)) {2388ewah_set(wd->sha1_valid, i);2389strbuf_add(&wd->sb_sha1, untracked->exclude_sha1,20);2390}23912392 intlen =encode_varint(untracked->untracked_nr, intbuf);2393strbuf_add(out, intbuf, intlen);23942395/* skip non-recurse directories */2396for(i =0, value =0; i < untracked->dirs_nr; i++)2397if(untracked->dirs[i]->recurse)2398 value++;2399 intlen =encode_varint(value, intbuf);2400strbuf_add(out, intbuf, intlen);24012402strbuf_add(out, untracked->name,strlen(untracked->name) +1);24032404for(i =0; i < untracked->untracked_nr; i++)2405strbuf_add(out, untracked->untracked[i],2406strlen(untracked->untracked[i]) +1);24072408for(i =0; i < untracked->dirs_nr; i++)2409if(untracked->dirs[i]->recurse)2410write_one_dir(untracked->dirs[i], wd);2411}24122413voidwrite_untracked_extension(struct strbuf *out,struct untracked_cache *untracked)2414{2415struct ondisk_untracked_cache *ouc;2416struct write_data wd;2417unsigned char varbuf[16];2418int varint_len;2419size_t len =strlen(untracked->exclude_per_dir);24202421FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2422stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2423stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2424hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);2425hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.sha1);2426 ouc->dir_flags =htonl(untracked->dir_flags);24272428 varint_len =encode_varint(untracked->ident.len, varbuf);2429strbuf_add(out, varbuf, varint_len);2430strbuf_addbuf(out, &untracked->ident);24312432strbuf_add(out, ouc,ouc_size(len));2433free(ouc);2434 ouc = NULL;24352436if(!untracked->root) {2437 varint_len =encode_varint(0, varbuf);2438strbuf_add(out, varbuf, varint_len);2439return;2440}24412442 wd.index =0;2443 wd.check_only =ewah_new();2444 wd.valid =ewah_new();2445 wd.sha1_valid =ewah_new();2446strbuf_init(&wd.out,1024);2447strbuf_init(&wd.sb_stat,1024);2448strbuf_init(&wd.sb_sha1,1024);2449write_one_dir(untracked->root, &wd);24502451 varint_len =encode_varint(wd.index, varbuf);2452strbuf_add(out, varbuf, varint_len);2453strbuf_addbuf(out, &wd.out);2454ewah_serialize_strbuf(wd.valid, out);2455ewah_serialize_strbuf(wd.check_only, out);2456ewah_serialize_strbuf(wd.sha1_valid, out);2457strbuf_addbuf(out, &wd.sb_stat);2458strbuf_addbuf(out, &wd.sb_sha1);2459strbuf_addch(out,'\0');/* safe guard for string lists */24602461ewah_free(wd.valid);2462ewah_free(wd.check_only);2463ewah_free(wd.sha1_valid);2464strbuf_release(&wd.out);2465strbuf_release(&wd.sb_stat);2466strbuf_release(&wd.sb_sha1);2467}24682469static voidfree_untracked(struct untracked_cache_dir *ucd)2470{2471int i;2472if(!ucd)2473return;2474for(i =0; i < ucd->dirs_nr; i++)2475free_untracked(ucd->dirs[i]);2476for(i =0; i < ucd->untracked_nr; i++)2477free(ucd->untracked[i]);2478free(ucd->untracked);2479free(ucd->dirs);2480free(ucd);2481}24822483voidfree_untracked_cache(struct untracked_cache *uc)2484{2485if(uc)2486free_untracked(uc->root);2487free(uc);2488}24892490struct read_data {2491int index;2492struct untracked_cache_dir **ucd;2493struct ewah_bitmap *check_only;2494struct ewah_bitmap *valid;2495struct ewah_bitmap *sha1_valid;2496const unsigned char*data;2497const unsigned char*end;2498};24992500static voidstat_data_from_disk(struct stat_data *to,const struct stat_data *from)2501{2502 to->sd_ctime.sec =get_be32(&from->sd_ctime.sec);2503 to->sd_ctime.nsec =get_be32(&from->sd_ctime.nsec);2504 to->sd_mtime.sec =get_be32(&from->sd_mtime.sec);2505 to->sd_mtime.nsec =get_be32(&from->sd_mtime.nsec);2506 to->sd_dev =get_be32(&from->sd_dev);2507 to->sd_ino =get_be32(&from->sd_ino);2508 to->sd_uid =get_be32(&from->sd_uid);2509 to->sd_gid =get_be32(&from->sd_gid);2510 to->sd_size =get_be32(&from->sd_size);2511}25122513static intread_one_dir(struct untracked_cache_dir **untracked_,2514struct read_data *rd)2515{2516struct untracked_cache_dir ud, *untracked;2517const unsigned char*next, *data = rd->data, *end = rd->end;2518unsigned int value;2519int i, len;25202521memset(&ud,0,sizeof(ud));25222523 next = data;2524 value =decode_varint(&next);2525if(next > end)2526return-1;2527 ud.recurse =1;2528 ud.untracked_alloc = value;2529 ud.untracked_nr = value;2530if(ud.untracked_nr)2531ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2532 data = next;25332534 next = data;2535 ud.dirs_alloc = ud.dirs_nr =decode_varint(&next);2536if(next > end)2537return-1;2538ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2539 data = next;25402541 len =strlen((const char*)data);2542 next = data + len +1;2543if(next > rd->end)2544return-1;2545*untracked_ = untracked =xmalloc(st_add(sizeof(*untracked), len));2546memcpy(untracked, &ud,sizeof(ud));2547memcpy(untracked->name, data, len +1);2548 data = next;25492550for(i =0; i < untracked->untracked_nr; i++) {2551 len =strlen((const char*)data);2552 next = data + len +1;2553if(next > rd->end)2554return-1;2555 untracked->untracked[i] =xstrdup((const char*)data);2556 data = next;2557}25582559 rd->ucd[rd->index++] = untracked;2560 rd->data = data;25612562for(i =0; i < untracked->dirs_nr; i++) {2563 len =read_one_dir(untracked->dirs + i, rd);2564if(len <0)2565return-1;2566}2567return0;2568}25692570static voidset_check_only(size_t pos,void*cb)2571{2572struct read_data *rd = cb;2573struct untracked_cache_dir *ud = rd->ucd[pos];2574 ud->check_only =1;2575}25762577static voidread_stat(size_t pos,void*cb)2578{2579struct read_data *rd = cb;2580struct untracked_cache_dir *ud = rd->ucd[pos];2581if(rd->data +sizeof(struct stat_data) > rd->end) {2582 rd->data = rd->end +1;2583return;2584}2585stat_data_from_disk(&ud->stat_data, (struct stat_data *)rd->data);2586 rd->data +=sizeof(struct stat_data);2587 ud->valid =1;2588}25892590static voidread_sha1(size_t pos,void*cb)2591{2592struct read_data *rd = cb;2593struct untracked_cache_dir *ud = rd->ucd[pos];2594if(rd->data +20> rd->end) {2595 rd->data = rd->end +1;2596return;2597}2598hashcpy(ud->exclude_sha1, rd->data);2599 rd->data +=20;2600}26012602static voidload_sha1_stat(struct sha1_stat *sha1_stat,2603const struct stat_data *stat,2604const unsigned char*sha1)2605{2606stat_data_from_disk(&sha1_stat->stat, stat);2607hashcpy(sha1_stat->sha1, sha1);2608 sha1_stat->valid =1;2609}26102611struct untracked_cache *read_untracked_extension(const void*data,unsigned long sz)2612{2613const struct ondisk_untracked_cache *ouc;2614struct untracked_cache *uc;2615struct read_data rd;2616const unsigned char*next = data, *end = (const unsigned char*)data + sz;2617const char*ident;2618int ident_len, len;26192620if(sz <=1|| end[-1] !='\0')2621return NULL;2622 end--;26232624 ident_len =decode_varint(&next);2625if(next + ident_len > end)2626return NULL;2627 ident = (const char*)next;2628 next += ident_len;26292630 ouc = (const struct ondisk_untracked_cache *)next;2631if(next +ouc_size(0) > end)2632return NULL;26332634 uc =xcalloc(1,sizeof(*uc));2635strbuf_init(&uc->ident, ident_len);2636strbuf_add(&uc->ident, ident, ident_len);2637load_sha1_stat(&uc->ss_info_exclude, &ouc->info_exclude_stat,2638 ouc->info_exclude_sha1);2639load_sha1_stat(&uc->ss_excludes_file, &ouc->excludes_file_stat,2640 ouc->excludes_file_sha1);2641 uc->dir_flags =get_be32(&ouc->dir_flags);2642 uc->exclude_per_dir =xstrdup(ouc->exclude_per_dir);2643/* NUL after exclude_per_dir is covered by sizeof(*ouc) */2644 next +=ouc_size(strlen(ouc->exclude_per_dir));2645if(next >= end)2646goto done2;26472648 len =decode_varint(&next);2649if(next > end || len ==0)2650goto done2;26512652 rd.valid =ewah_new();2653 rd.check_only =ewah_new();2654 rd.sha1_valid =ewah_new();2655 rd.data = next;2656 rd.end = end;2657 rd.index =0;2658ALLOC_ARRAY(rd.ucd, len);26592660if(read_one_dir(&uc->root, &rd) || rd.index != len)2661goto done;26622663 next = rd.data;2664 len =ewah_read_mmap(rd.valid, next, end - next);2665if(len <0)2666goto done;26672668 next += len;2669 len =ewah_read_mmap(rd.check_only, next, end - next);2670if(len <0)2671goto done;26722673 next += len;2674 len =ewah_read_mmap(rd.sha1_valid, next, end - next);2675if(len <0)2676goto done;26772678ewah_each_bit(rd.check_only, set_check_only, &rd);2679 rd.data = next + len;2680ewah_each_bit(rd.valid, read_stat, &rd);2681ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2682 next = rd.data;26832684done:2685free(rd.ucd);2686ewah_free(rd.valid);2687ewah_free(rd.check_only);2688ewah_free(rd.sha1_valid);2689done2:2690if(next != end) {2691free_untracked_cache(uc);2692 uc = NULL;2693}2694return uc;2695}26962697static voidinvalidate_one_directory(struct untracked_cache *uc,2698struct untracked_cache_dir *ucd)2699{2700 uc->dir_invalidated++;2701 ucd->valid =0;2702 ucd->untracked_nr =0;2703}27042705/*2706 * Normally when an entry is added or removed from a directory,2707 * invalidating that directory is enough. No need to touch its2708 * ancestors. When a directory is shown as "foo/bar/" in git-status2709 * however, deleting or adding an entry may have cascading effect.2710 *2711 * Say the "foo/bar/file" has become untracked, we need to tell the2712 * untracked_cache_dir of "foo" that "bar/" is not an untracked2713 * directory any more (because "bar" is managed by foo as an untracked2714 * "file").2715 *2716 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2717 * was the last untracked entry in the entire "foo", we should show2718 * "foo/" instead. Which means we have to invalidate past "bar" up to2719 * "foo".2720 *2721 * This function traverses all directories from root to leaf. If there2722 * is a chance of one of the above cases happening, we invalidate back2723 * to root. Otherwise we just invalidate the leaf. There may be a more2724 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2725 * detect these cases and avoid unnecessary invalidation, for example,2726 * checking for the untracked entry named "bar/" in "foo", but for now2727 * stick to something safe and simple.2728 */2729static intinvalidate_one_component(struct untracked_cache *uc,2730struct untracked_cache_dir *dir,2731const char*path,int len)2732{2733const char*rest =strchr(path,'/');27342735if(rest) {2736int component_len = rest - path;2737struct untracked_cache_dir *d =2738lookup_untracked(uc, dir, path, component_len);2739int ret =2740invalidate_one_component(uc, d, rest +1,2741 len - (component_len +1));2742if(ret)2743invalidate_one_directory(uc, dir);2744return ret;2745}27462747invalidate_one_directory(uc, dir);2748return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2749}27502751voiduntracked_cache_invalidate_path(struct index_state *istate,2752const char*path)2753{2754if(!istate->untracked || !istate->untracked->root)2755return;2756invalidate_one_component(istate->untracked, istate->untracked->root,2757 path,strlen(path));2758}27592760voiduntracked_cache_remove_from_index(struct index_state *istate,2761const char*path)2762{2763untracked_cache_invalidate_path(istate, path);2764}27652766voiduntracked_cache_add_to_index(struct index_state *istate,2767const char*path)2768{2769untracked_cache_invalidate_path(istate, path);2770}27712772/* Update gitfile and core.worktree setting to connect work tree and git dir */2773voidconnect_work_tree_and_git_dir(const char*work_tree_,const char*git_dir_)2774{2775struct strbuf gitfile_sb = STRBUF_INIT;2776struct strbuf cfg_sb = STRBUF_INIT;2777struct strbuf rel_path = STRBUF_INIT;2778char*git_dir, *work_tree;27792780/* Prepare .git file */2781strbuf_addf(&gitfile_sb,"%s/.git", work_tree_);2782if(safe_create_leading_directories_const(gitfile_sb.buf))2783die(_("could not create directories for%s"), gitfile_sb.buf);27842785/* Prepare config file */2786strbuf_addf(&cfg_sb,"%s/config", git_dir_);2787if(safe_create_leading_directories_const(cfg_sb.buf))2788die(_("could not create directories for%s"), cfg_sb.buf);27892790 git_dir =real_pathdup(git_dir_,1);2791 work_tree =real_pathdup(work_tree_,1);27922793/* Write .git file */2794write_file(gitfile_sb.buf,"gitdir:%s",2795relative_path(git_dir, work_tree, &rel_path));2796/* Update core.worktree setting */2797git_config_set_in_file(cfg_sb.buf,"core.worktree",2798relative_path(work_tree, git_dir, &rel_path));27992800strbuf_release(&gitfile_sb);2801strbuf_release(&cfg_sb);2802strbuf_release(&rel_path);2803free(work_tree);2804free(git_dir);2805}28062807/*2808 * Migrate the git directory of the given path from old_git_dir to new_git_dir.2809 */2810voidrelocate_gitdir(const char*path,const char*old_git_dir,const char*new_git_dir)2811{2812if(rename(old_git_dir, new_git_dir) <0)2813die_errno(_("could not migrate git directory from '%s' to '%s'"),2814 old_git_dir, new_git_dir);28152816connect_work_tree_and_git_dir(path, new_git_dir);2817}