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"config.h" 13#include"dir.h" 14#include"attr.h" 15#include"refs.h" 16#include"wildmatch.h" 17#include"pathspec.h" 18#include"utf8.h" 19#include"varint.h" 20#include"ewah/ewok.h" 21 22/* 23 * Tells read_directory_recursive how a file or directory should be treated. 24 * Values are ordered by significance, e.g. if a directory contains both 25 * excluded and untracked files, it is listed as untracked because 26 * path_untracked > path_excluded. 27 */ 28enum path_treatment { 29 path_none =0, 30 path_recurse, 31 path_excluded, 32 path_untracked 33}; 34 35/* 36 * Support data structure for our opendir/readdir/closedir wrappers 37 */ 38struct cached_dir { 39DIR*fdir; 40struct untracked_cache_dir *untracked; 41int nr_files; 42int nr_dirs; 43 44struct dirent *de; 45const char*file; 46struct untracked_cache_dir *ucd; 47}; 48 49static enum path_treatment read_directory_recursive(struct dir_struct *dir, 50struct index_state *istate,const char*path,int len, 51struct untracked_cache_dir *untracked, 52int check_only,int stop_at_first_file,const struct pathspec *pathspec); 53static intget_dtype(struct dirent *de,struct index_state *istate, 54const char*path,int len); 55 56intcount_slashes(const char*s) 57{ 58int cnt =0; 59while(*s) 60if(*s++ =='/') 61 cnt++; 62return cnt; 63} 64 65intfspathcmp(const char*a,const char*b) 66{ 67return ignore_case ?strcasecmp(a, b) :strcmp(a, b); 68} 69 70intfspathncmp(const char*a,const char*b,size_t count) 71{ 72return ignore_case ?strncasecmp(a, b, count) :strncmp(a, b, count); 73} 74 75intgit_fnmatch(const struct pathspec_item *item, 76const char*pattern,const char*string, 77int prefix) 78{ 79if(prefix >0) { 80if(ps_strncmp(item, pattern, string, prefix)) 81return WM_NOMATCH; 82 pattern += prefix; 83 string += prefix; 84} 85if(item->flags & PATHSPEC_ONESTAR) { 86int pattern_len =strlen(++pattern); 87int string_len =strlen(string); 88return string_len < pattern_len || 89ps_strcmp(item, pattern, 90 string + string_len - pattern_len); 91} 92if(item->magic & PATHSPEC_GLOB) 93returnwildmatch(pattern, string, 94 WM_PATHNAME | 95(item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0)); 96else 97/* wildmatch has not learned no FNM_PATHNAME mode yet */ 98returnwildmatch(pattern, string, 99 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0); 100} 101 102static intfnmatch_icase_mem(const char*pattern,int patternlen, 103const char*string,int stringlen, 104int flags) 105{ 106int match_status; 107struct strbuf pat_buf = STRBUF_INIT; 108struct strbuf str_buf = STRBUF_INIT; 109const char*use_pat = pattern; 110const char*use_str = string; 111 112if(pattern[patternlen]) { 113strbuf_add(&pat_buf, pattern, patternlen); 114 use_pat = pat_buf.buf; 115} 116if(string[stringlen]) { 117strbuf_add(&str_buf, string, stringlen); 118 use_str = str_buf.buf; 119} 120 121if(ignore_case) 122 flags |= WM_CASEFOLD; 123 match_status =wildmatch(use_pat, use_str, flags); 124 125strbuf_release(&pat_buf); 126strbuf_release(&str_buf); 127 128return match_status; 129} 130 131static size_tcommon_prefix_len(const struct pathspec *pathspec) 132{ 133int n; 134size_t max =0; 135 136/* 137 * ":(icase)path" is treated as a pathspec full of 138 * wildcard. In other words, only prefix is considered common 139 * prefix. If the pathspec is abc/foo abc/bar, running in 140 * subdir xyz, the common prefix is still xyz, not xuz/abc as 141 * in non-:(icase). 142 */ 143GUARD_PATHSPEC(pathspec, 144 PATHSPEC_FROMTOP | 145 PATHSPEC_MAXDEPTH | 146 PATHSPEC_LITERAL | 147 PATHSPEC_GLOB | 148 PATHSPEC_ICASE | 149 PATHSPEC_EXCLUDE | 150 PATHSPEC_ATTR); 151 152for(n =0; n < pathspec->nr; n++) { 153size_t i =0, len =0, item_len; 154if(pathspec->items[n].magic & PATHSPEC_EXCLUDE) 155continue; 156if(pathspec->items[n].magic & PATHSPEC_ICASE) 157 item_len = pathspec->items[n].prefix; 158else 159 item_len = pathspec->items[n].nowildcard_len; 160while(i < item_len && (n ==0|| i < max)) { 161char c = pathspec->items[n].match[i]; 162if(c != pathspec->items[0].match[i]) 163break; 164if(c =='/') 165 len = i +1; 166 i++; 167} 168if(n ==0|| len < max) { 169 max = len; 170if(!max) 171break; 172} 173} 174return max; 175} 176 177/* 178 * Returns a copy of the longest leading path common among all 179 * pathspecs. 180 */ 181char*common_prefix(const struct pathspec *pathspec) 182{ 183unsigned long len =common_prefix_len(pathspec); 184 185return len ?xmemdupz(pathspec->items[0].match, len) : NULL; 186} 187 188intfill_directory(struct dir_struct *dir, 189struct index_state *istate, 190const struct pathspec *pathspec) 191{ 192const char*prefix; 193size_t prefix_len; 194 195/* 196 * Calculate common prefix for the pathspec, and 197 * use that to optimize the directory walk 198 */ 199 prefix_len =common_prefix_len(pathspec); 200 prefix = prefix_len ? pathspec->items[0].match :""; 201 202/* Read the directory and prune it */ 203read_directory(dir, istate, prefix, prefix_len, pathspec); 204 205return prefix_len; 206} 207 208intwithin_depth(const char*name,int namelen, 209int depth,int max_depth) 210{ 211const char*cp = name, *cpe = name + namelen; 212 213while(cp < cpe) { 214if(*cp++ !='/') 215continue; 216 depth++; 217if(depth > max_depth) 218return0; 219} 220return1; 221} 222 223#define DO_MATCH_EXCLUDE (1<<0) 224#define DO_MATCH_DIRECTORY (1<<1) 225#define DO_MATCH_SUBMODULE (1<<2) 226 227static intmatch_attrs(const char*name,int namelen, 228const struct pathspec_item *item) 229{ 230int i; 231 232git_check_attr(name, item->attr_check); 233for(i =0; i < item->attr_match_nr; i++) { 234const char*value; 235int matched; 236enum attr_match_mode match_mode; 237 238 value = item->attr_check->items[i].value; 239 match_mode = item->attr_match[i].match_mode; 240 241if(ATTR_TRUE(value)) 242 matched = (match_mode == MATCH_SET); 243else if(ATTR_FALSE(value)) 244 matched = (match_mode == MATCH_UNSET); 245else if(ATTR_UNSET(value)) 246 matched = (match_mode == MATCH_UNSPECIFIED); 247else 248 matched = (match_mode == MATCH_VALUE && 249!strcmp(item->attr_match[i].value, value)); 250if(!matched) 251return0; 252} 253 254return1; 255} 256 257/* 258 * Does 'match' match the given name? 259 * A match is found if 260 * 261 * (1) the 'match' string is leading directory of 'name', or 262 * (2) the 'match' string is a wildcard and matches 'name', or 263 * (3) the 'match' string is exactly the same as 'name'. 264 * 265 * and the return value tells which case it was. 266 * 267 * It returns 0 when there is no match. 268 */ 269static intmatch_pathspec_item(const struct pathspec_item *item,int prefix, 270const char*name,int namelen,unsigned flags) 271{ 272/* name/namelen has prefix cut off by caller */ 273const char*match = item->match + prefix; 274int matchlen = item->len - prefix; 275 276/* 277 * The normal call pattern is: 278 * 1. prefix = common_prefix_len(ps); 279 * 2. prune something, or fill_directory 280 * 3. match_pathspec() 281 * 282 * 'prefix' at #1 may be shorter than the command's prefix and 283 * it's ok for #2 to match extra files. Those extras will be 284 * trimmed at #3. 285 * 286 * Suppose the pathspec is 'foo' and '../bar' running from 287 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 288 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 289 * user does not want XYZ/foo, only the "foo" part should be 290 * case-insensitive. We need to filter out XYZ/foo here. In 291 * other words, we do not trust the caller on comparing the 292 * prefix part when :(icase) is involved. We do exact 293 * comparison ourselves. 294 * 295 * Normally the caller (common_prefix_len() in fact) does 296 * _exact_ matching on name[-prefix+1..-1] and we do not need 297 * to check that part. Be defensive and check it anyway, in 298 * case common_prefix_len is changed, or a new caller is 299 * introduced that does not use common_prefix_len. 300 * 301 * If the penalty turns out too high when prefix is really 302 * long, maybe change it to 303 * strncmp(match, name, item->prefix - prefix) 304 */ 305if(item->prefix && (item->magic & PATHSPEC_ICASE) && 306strncmp(item->match, name - prefix, item->prefix)) 307return0; 308 309if(item->attr_match_nr && !match_attrs(name, namelen, item)) 310return0; 311 312/* If the match was just the prefix, we matched */ 313if(!*match) 314return MATCHED_RECURSIVELY; 315 316if(matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 317if(matchlen == namelen) 318return MATCHED_EXACTLY; 319 320if(match[matchlen-1] =='/'|| name[matchlen] =='/') 321return MATCHED_RECURSIVELY; 322}else if((flags & DO_MATCH_DIRECTORY) && 323 match[matchlen -1] =='/'&& 324 namelen == matchlen -1&& 325!ps_strncmp(item, match, name, namelen)) 326return MATCHED_EXACTLY; 327 328if(item->nowildcard_len < item->len && 329!git_fnmatch(item, match, name, 330 item->nowildcard_len - prefix)) 331return MATCHED_FNMATCH; 332 333/* Perform checks to see if "name" is a super set of the pathspec */ 334if(flags & DO_MATCH_SUBMODULE) { 335/* name is a literal prefix of the pathspec */ 336if((namelen < matchlen) && 337(match[namelen] =='/') && 338!ps_strncmp(item, match, name, namelen)) 339return MATCHED_RECURSIVELY; 340 341/* name" doesn't match up to the first wild character */ 342if(item->nowildcard_len < item->len && 343ps_strncmp(item, match, name, 344 item->nowildcard_len - prefix)) 345return0; 346 347/* 348 * Here is where we would perform a wildmatch to check if 349 * "name" can be matched as a directory (or a prefix) against 350 * the pathspec. Since wildmatch doesn't have this capability 351 * at the present we have to punt and say that it is a match, 352 * potentially returning a false positive 353 * The submodules themselves will be able to perform more 354 * accurate matching to determine if the pathspec matches. 355 */ 356return MATCHED_RECURSIVELY; 357} 358 359return0; 360} 361 362/* 363 * Given a name and a list of pathspecs, returns the nature of the 364 * closest (i.e. most specific) match of the name to any of the 365 * pathspecs. 366 * 367 * The caller typically calls this multiple times with the same 368 * pathspec and seen[] array but with different name/namelen 369 * (e.g. entries from the index) and is interested in seeing if and 370 * how each pathspec matches all the names it calls this function 371 * with. A mark is left in the seen[] array for each pathspec element 372 * indicating the closest type of match that element achieved, so if 373 * seen[n] remains zero after multiple invocations, that means the nth 374 * pathspec did not match any names, which could indicate that the 375 * user mistyped the nth pathspec. 376 */ 377static intdo_match_pathspec(const struct pathspec *ps, 378const char*name,int namelen, 379int prefix,char*seen, 380unsigned flags) 381{ 382int i, retval =0, exclude = flags & DO_MATCH_EXCLUDE; 383 384GUARD_PATHSPEC(ps, 385 PATHSPEC_FROMTOP | 386 PATHSPEC_MAXDEPTH | 387 PATHSPEC_LITERAL | 388 PATHSPEC_GLOB | 389 PATHSPEC_ICASE | 390 PATHSPEC_EXCLUDE | 391 PATHSPEC_ATTR); 392 393if(!ps->nr) { 394if(!ps->recursive || 395!(ps->magic & PATHSPEC_MAXDEPTH) || 396 ps->max_depth == -1) 397return MATCHED_RECURSIVELY; 398 399if(within_depth(name, namelen,0, ps->max_depth)) 400return MATCHED_EXACTLY; 401else 402return0; 403} 404 405 name += prefix; 406 namelen -= prefix; 407 408for(i = ps->nr -1; i >=0; i--) { 409int how; 410 411if((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 412( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 413continue; 414 415if(seen && seen[i] == MATCHED_EXACTLY) 416continue; 417/* 418 * Make exclude patterns optional and never report 419 * "pathspec ':(exclude)foo' matches no files" 420 */ 421if(seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 422 seen[i] = MATCHED_FNMATCH; 423 how =match_pathspec_item(ps->items+i, prefix, name, 424 namelen, flags); 425if(ps->recursive && 426(ps->magic & PATHSPEC_MAXDEPTH) && 427 ps->max_depth != -1&& 428 how && how != MATCHED_FNMATCH) { 429int len = ps->items[i].len; 430if(name[len] =='/') 431 len++; 432if(within_depth(name+len, namelen-len,0, ps->max_depth)) 433 how = MATCHED_EXACTLY; 434else 435 how =0; 436} 437if(how) { 438if(retval < how) 439 retval = how; 440if(seen && seen[i] < how) 441 seen[i] = how; 442} 443} 444return retval; 445} 446 447intmatch_pathspec(const struct pathspec *ps, 448const char*name,int namelen, 449int prefix,char*seen,int is_dir) 450{ 451int positive, negative; 452unsigned flags = is_dir ? DO_MATCH_DIRECTORY :0; 453 positive =do_match_pathspec(ps, name, namelen, 454 prefix, seen, flags); 455if(!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 456return positive; 457 negative =do_match_pathspec(ps, name, namelen, 458 prefix, seen, 459 flags | DO_MATCH_EXCLUDE); 460return negative ?0: positive; 461} 462 463/** 464 * Check if a submodule is a superset of the pathspec 465 */ 466intsubmodule_path_match(const struct pathspec *ps, 467const char*submodule_name, 468char*seen) 469{ 470int matched =do_match_pathspec(ps, submodule_name, 471strlen(submodule_name), 4720, seen, 473 DO_MATCH_DIRECTORY | 474 DO_MATCH_SUBMODULE); 475return matched; 476} 477 478intreport_path_error(const char*ps_matched, 479const struct pathspec *pathspec, 480const char*prefix) 481{ 482/* 483 * Make sure all pathspec matched; otherwise it is an error. 484 */ 485int num, errors =0; 486for(num =0; num < pathspec->nr; num++) { 487int other, found_dup; 488 489if(ps_matched[num]) 490continue; 491/* 492 * The caller might have fed identical pathspec 493 * twice. Do not barf on such a mistake. 494 * FIXME: parse_pathspec should have eliminated 495 * duplicate pathspec. 496 */ 497for(found_dup = other =0; 498!found_dup && other < pathspec->nr; 499 other++) { 500if(other == num || !ps_matched[other]) 501continue; 502if(!strcmp(pathspec->items[other].original, 503 pathspec->items[num].original)) 504/* 505 * Ok, we have a match already. 506 */ 507 found_dup =1; 508} 509if(found_dup) 510continue; 511 512error("pathspec '%s' did not match any file(s) known to git.", 513 pathspec->items[num].original); 514 errors++; 515} 516return errors; 517} 518 519/* 520 * Return the length of the "simple" part of a path match limiter. 521 */ 522intsimple_length(const char*match) 523{ 524int len = -1; 525 526for(;;) { 527unsigned char c = *match++; 528 len++; 529if(c =='\0'||is_glob_special(c)) 530return len; 531} 532} 533 534intno_wildcard(const char*string) 535{ 536return string[simple_length(string)] =='\0'; 537} 538 539voidparse_exclude_pattern(const char**pattern, 540int*patternlen, 541unsigned*flags, 542int*nowildcardlen) 543{ 544const char*p = *pattern; 545size_t i, len; 546 547*flags =0; 548if(*p =='!') { 549*flags |= EXC_FLAG_NEGATIVE; 550 p++; 551} 552 len =strlen(p); 553if(len && p[len -1] =='/') { 554 len--; 555*flags |= EXC_FLAG_MUSTBEDIR; 556} 557for(i =0; i < len; i++) { 558if(p[i] =='/') 559break; 560} 561if(i == len) 562*flags |= EXC_FLAG_NODIR; 563*nowildcardlen =simple_length(p); 564/* 565 * we should have excluded the trailing slash from 'p' too, 566 * but that's one more allocation. Instead just make sure 567 * nowildcardlen does not exceed real patternlen 568 */ 569if(*nowildcardlen > len) 570*nowildcardlen = len; 571if(*p =='*'&&no_wildcard(p +1)) 572*flags |= EXC_FLAG_ENDSWITH; 573*pattern = p; 574*patternlen = len; 575} 576 577voidadd_exclude(const char*string,const char*base, 578int baselen,struct exclude_list *el,int srcpos) 579{ 580struct exclude *x; 581int patternlen; 582unsigned flags; 583int nowildcardlen; 584 585parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 586if(flags & EXC_FLAG_MUSTBEDIR) { 587FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 588}else{ 589 x =xmalloc(sizeof(*x)); 590 x->pattern = string; 591} 592 x->patternlen = patternlen; 593 x->nowildcardlen = nowildcardlen; 594 x->base = base; 595 x->baselen = baselen; 596 x->flags = flags; 597 x->srcpos = srcpos; 598ALLOC_GROW(el->excludes, el->nr +1, el->alloc); 599 el->excludes[el->nr++] = x; 600 x->el = el; 601} 602 603static void*read_skip_worktree_file_from_index(const struct index_state *istate, 604const char*path,size_t*size, 605struct sha1_stat *sha1_stat) 606{ 607int pos, len; 608unsigned long sz; 609enum object_type type; 610void*data; 611 612 len =strlen(path); 613 pos =index_name_pos(istate, path, len); 614if(pos <0) 615return NULL; 616if(!ce_skip_worktree(istate->cache[pos])) 617return NULL; 618 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz); 619if(!data || type != OBJ_BLOB) { 620free(data); 621return NULL; 622} 623*size =xsize_t(sz); 624if(sha1_stat) { 625memset(&sha1_stat->stat,0,sizeof(sha1_stat->stat)); 626hashcpy(sha1_stat->sha1, istate->cache[pos]->oid.hash); 627} 628return data; 629} 630 631/* 632 * Frees memory within el which was allocated for exclude patterns and 633 * the file buffer. Does not free el itself. 634 */ 635voidclear_exclude_list(struct exclude_list *el) 636{ 637int i; 638 639for(i =0; i < el->nr; i++) 640free(el->excludes[i]); 641free(el->excludes); 642free(el->filebuf); 643 644memset(el,0,sizeof(*el)); 645} 646 647static voidtrim_trailing_spaces(char*buf) 648{ 649char*p, *last_space = NULL; 650 651for(p = buf; *p; p++) 652switch(*p) { 653case' ': 654if(!last_space) 655 last_space = p; 656break; 657case'\\': 658 p++; 659if(!*p) 660return; 661/* fallthrough */ 662default: 663 last_space = NULL; 664} 665 666if(last_space) 667*last_space ='\0'; 668} 669 670/* 671 * Given a subdirectory name and "dir" of the current directory, 672 * search the subdir in "dir" and return it, or create a new one if it 673 * does not exist in "dir". 674 * 675 * If "name" has the trailing slash, it'll be excluded in the search. 676 */ 677static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 678struct untracked_cache_dir *dir, 679const char*name,int len) 680{ 681int first, last; 682struct untracked_cache_dir *d; 683if(!dir) 684return NULL; 685if(len && name[len -1] =='/') 686 len--; 687 first =0; 688 last = dir->dirs_nr; 689while(last > first) { 690int cmp, next = (last + first) >>1; 691 d = dir->dirs[next]; 692 cmp =strncmp(name, d->name, len); 693if(!cmp &&strlen(d->name) > len) 694 cmp = -1; 695if(!cmp) 696return d; 697if(cmp <0) { 698 last = next; 699continue; 700} 701 first = next+1; 702} 703 704 uc->dir_created++; 705FLEX_ALLOC_MEM(d, name, name, len); 706 707ALLOC_GROW(dir->dirs, dir->dirs_nr +1, dir->dirs_alloc); 708memmove(dir->dirs + first +1, dir->dirs + first, 709(dir->dirs_nr - first) *sizeof(*dir->dirs)); 710 dir->dirs_nr++; 711 dir->dirs[first] = d; 712return d; 713} 714 715static voiddo_invalidate_gitignore(struct untracked_cache_dir *dir) 716{ 717int i; 718 dir->valid =0; 719 dir->untracked_nr =0; 720for(i =0; i < dir->dirs_nr; i++) 721do_invalidate_gitignore(dir->dirs[i]); 722} 723 724static voidinvalidate_gitignore(struct untracked_cache *uc, 725struct untracked_cache_dir *dir) 726{ 727 uc->gitignore_invalidated++; 728do_invalidate_gitignore(dir); 729} 730 731static voidinvalidate_directory(struct untracked_cache *uc, 732struct untracked_cache_dir *dir) 733{ 734int i; 735 uc->dir_invalidated++; 736 dir->valid =0; 737 dir->untracked_nr =0; 738for(i =0; i < dir->dirs_nr; i++) 739 dir->dirs[i]->recurse =0; 740} 741 742/* 743 * Given a file with name "fname", read it (either from disk, or from 744 * an index if 'istate' is non-null), parse it and store the 745 * exclude rules in "el". 746 * 747 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 748 * stat data from disk (only valid if add_excludes returns zero). If 749 * ss_valid is non-zero, "ss" must contain good value as input. 750 */ 751static intadd_excludes(const char*fname,const char*base,int baselen, 752struct exclude_list *el, 753struct index_state *istate, 754struct sha1_stat *sha1_stat) 755{ 756struct stat st; 757int fd, i, lineno =1; 758size_t size =0; 759char*buf, *entry; 760 761 fd =open(fname, O_RDONLY); 762if(fd <0||fstat(fd, &st) <0) { 763if(fd <0) 764warn_on_fopen_errors(fname); 765else 766close(fd); 767if(!istate || 768(buf =read_skip_worktree_file_from_index(istate, fname, &size, sha1_stat)) == NULL) 769return-1; 770if(size ==0) { 771free(buf); 772return0; 773} 774if(buf[size-1] !='\n') { 775 buf =xrealloc(buf,st_add(size,1)); 776 buf[size++] ='\n'; 777} 778}else{ 779 size =xsize_t(st.st_size); 780if(size ==0) { 781if(sha1_stat) { 782fill_stat_data(&sha1_stat->stat, &st); 783hashcpy(sha1_stat->sha1, EMPTY_BLOB_SHA1_BIN); 784 sha1_stat->valid =1; 785} 786close(fd); 787return0; 788} 789 buf =xmallocz(size); 790if(read_in_full(fd, buf, size) != size) { 791free(buf); 792close(fd); 793return-1; 794} 795 buf[size++] ='\n'; 796close(fd); 797if(sha1_stat) { 798int pos; 799if(sha1_stat->valid && 800!match_stat_data_racy(istate, &sha1_stat->stat, &st)) 801;/* no content change, ss->sha1 still good */ 802else if(istate && 803(pos =index_name_pos(istate, fname,strlen(fname))) >=0&& 804!ce_stage(istate->cache[pos]) && 805ce_uptodate(istate->cache[pos]) && 806!would_convert_to_git(istate, fname)) 807hashcpy(sha1_stat->sha1, 808 istate->cache[pos]->oid.hash); 809else 810hash_sha1_file(buf, size,"blob", sha1_stat->sha1); 811fill_stat_data(&sha1_stat->stat, &st); 812 sha1_stat->valid =1; 813} 814} 815 816 el->filebuf = buf; 817 818if(skip_utf8_bom(&buf, size)) 819 size -= buf - el->filebuf; 820 821 entry = buf; 822 823for(i =0; i < size; i++) { 824if(buf[i] =='\n') { 825if(entry != buf + i && entry[0] !='#') { 826 buf[i - (i && buf[i-1] =='\r')] =0; 827trim_trailing_spaces(entry); 828add_exclude(entry, base, baselen, el, lineno); 829} 830 lineno++; 831 entry = buf + i +1; 832} 833} 834return0; 835} 836 837intadd_excludes_from_file_to_list(const char*fname,const char*base, 838int baselen,struct exclude_list *el, 839struct index_state *istate) 840{ 841returnadd_excludes(fname, base, baselen, el, istate, NULL); 842} 843 844struct exclude_list *add_exclude_list(struct dir_struct *dir, 845int group_type,const char*src) 846{ 847struct exclude_list *el; 848struct exclude_list_group *group; 849 850 group = &dir->exclude_list_group[group_type]; 851ALLOC_GROW(group->el, group->nr +1, group->alloc); 852 el = &group->el[group->nr++]; 853memset(el,0,sizeof(*el)); 854 el->src = src; 855return el; 856} 857 858/* 859 * Used to set up core.excludesfile and .git/info/exclude lists. 860 */ 861static voidadd_excludes_from_file_1(struct dir_struct *dir,const char*fname, 862struct sha1_stat *sha1_stat) 863{ 864struct exclude_list *el; 865/* 866 * catch setup_standard_excludes() that's called before 867 * dir->untracked is assigned. That function behaves 868 * differently when dir->untracked is non-NULL. 869 */ 870if(!dir->untracked) 871 dir->unmanaged_exclude_files++; 872 el =add_exclude_list(dir, EXC_FILE, fname); 873if(add_excludes(fname,"",0, el, NULL, sha1_stat) <0) 874die("cannot use%sas an exclude file", fname); 875} 876 877voidadd_excludes_from_file(struct dir_struct *dir,const char*fname) 878{ 879 dir->unmanaged_exclude_files++;/* see validate_untracked_cache() */ 880add_excludes_from_file_1(dir, fname, NULL); 881} 882 883intmatch_basename(const char*basename,int basenamelen, 884const char*pattern,int prefix,int patternlen, 885unsigned flags) 886{ 887if(prefix == patternlen) { 888if(patternlen == basenamelen && 889!fspathncmp(pattern, basename, basenamelen)) 890return1; 891}else if(flags & EXC_FLAG_ENDSWITH) { 892/* "*literal" matching against "fooliteral" */ 893if(patternlen -1<= basenamelen && 894!fspathncmp(pattern +1, 895 basename + basenamelen - (patternlen -1), 896 patternlen -1)) 897return1; 898}else{ 899if(fnmatch_icase_mem(pattern, patternlen, 900 basename, basenamelen, 9010) ==0) 902return1; 903} 904return0; 905} 906 907intmatch_pathname(const char*pathname,int pathlen, 908const char*base,int baselen, 909const char*pattern,int prefix,int patternlen, 910unsigned flags) 911{ 912const char*name; 913int namelen; 914 915/* 916 * match with FNM_PATHNAME; the pattern has base implicitly 917 * in front of it. 918 */ 919if(*pattern =='/') { 920 pattern++; 921 patternlen--; 922 prefix--; 923} 924 925/* 926 * baselen does not count the trailing slash. base[] may or 927 * may not end with a trailing slash though. 928 */ 929if(pathlen < baselen +1|| 930(baselen && pathname[baselen] !='/') || 931fspathncmp(pathname, base, baselen)) 932return0; 933 934 namelen = baselen ? pathlen - baselen -1: pathlen; 935 name = pathname + pathlen - namelen; 936 937if(prefix) { 938/* 939 * if the non-wildcard part is longer than the 940 * remaining pathname, surely it cannot match. 941 */ 942if(prefix > namelen) 943return0; 944 945if(fspathncmp(pattern, name, prefix)) 946return0; 947 pattern += prefix; 948 patternlen -= prefix; 949 name += prefix; 950 namelen -= prefix; 951 952/* 953 * If the whole pattern did not have a wildcard, 954 * then our prefix match is all we need; we 955 * do not need to call fnmatch at all. 956 */ 957if(!patternlen && !namelen) 958return1; 959} 960 961returnfnmatch_icase_mem(pattern, patternlen, 962 name, namelen, 963 WM_PATHNAME) ==0; 964} 965 966/* 967 * Scan the given exclude list in reverse to see whether pathname 968 * should be ignored. The first match (i.e. the last on the list), if 969 * any, determines the fate. Returns the exclude_list element which 970 * matched, or NULL for undecided. 971 */ 972static struct exclude *last_exclude_matching_from_list(const char*pathname, 973int pathlen, 974const char*basename, 975int*dtype, 976struct exclude_list *el, 977struct index_state *istate) 978{ 979struct exclude *exc = NULL;/* undecided */ 980int i; 981 982if(!el->nr) 983return NULL;/* undefined */ 984 985for(i = el->nr -1;0<= i; i--) { 986struct exclude *x = el->excludes[i]; 987const char*exclude = x->pattern; 988int prefix = x->nowildcardlen; 989 990if(x->flags & EXC_FLAG_MUSTBEDIR) { 991if(*dtype == DT_UNKNOWN) 992*dtype =get_dtype(NULL, istate, pathname, pathlen); 993if(*dtype != DT_DIR) 994continue; 995} 996 997if(x->flags & EXC_FLAG_NODIR) { 998if(match_basename(basename, 999 pathlen - (basename - pathname),1000 exclude, prefix, x->patternlen,1001 x->flags)) {1002 exc = x;1003break;1004}1005continue;1006}10071008assert(x->baselen ==0|| x->base[x->baselen -1] =='/');1009if(match_pathname(pathname, pathlen,1010 x->base, x->baselen ? x->baselen -1:0,1011 exclude, prefix, x->patternlen, x->flags)) {1012 exc = x;1013break;1014}1015}1016return exc;1017}10181019/*1020 * Scan the list and let the last match determine the fate.1021 * Return 1 for exclude, 0 for include and -1 for undecided.1022 */1023intis_excluded_from_list(const char*pathname,1024int pathlen,const char*basename,int*dtype,1025struct exclude_list *el,struct index_state *istate)1026{1027struct exclude *exclude;1028 exclude =last_exclude_matching_from_list(pathname, pathlen, basename,1029 dtype, el, istate);1030if(exclude)1031return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1032return-1;/* undecided */1033}10341035static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1036struct index_state *istate,1037const char*pathname,int pathlen,const char*basename,1038int*dtype_p)1039{1040int i, j;1041struct exclude_list_group *group;1042struct exclude *exclude;1043for(i = EXC_CMDL; i <= EXC_FILE; i++) {1044 group = &dir->exclude_list_group[i];1045for(j = group->nr -1; j >=0; j--) {1046 exclude =last_exclude_matching_from_list(1047 pathname, pathlen, basename, dtype_p,1048&group->el[j], istate);1049if(exclude)1050return exclude;1051}1052}1053return NULL;1054}10551056/*1057 * Loads the per-directory exclude list for the substring of base1058 * which has a char length of baselen.1059 */1060static voidprep_exclude(struct dir_struct *dir,1061struct index_state *istate,1062const char*base,int baselen)1063{1064struct exclude_list_group *group;1065struct exclude_list *el;1066struct exclude_stack *stk = NULL;1067struct untracked_cache_dir *untracked;1068int current;10691070 group = &dir->exclude_list_group[EXC_DIRS];10711072/*1073 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1074 * which originate from directories not in the prefix of the1075 * path being checked.1076 */1077while((stk = dir->exclude_stack) != NULL) {1078if(stk->baselen <= baselen &&1079!strncmp(dir->basebuf.buf, base, stk->baselen))1080break;1081 el = &group->el[dir->exclude_stack->exclude_ix];1082 dir->exclude_stack = stk->prev;1083 dir->exclude = NULL;1084free((char*)el->src);/* see strbuf_detach() below */1085clear_exclude_list(el);1086free(stk);1087 group->nr--;1088}10891090/* Skip traversing into sub directories if the parent is excluded */1091if(dir->exclude)1092return;10931094/*1095 * Lazy initialization. All call sites currently just1096 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1097 * them seems lots of work for little benefit.1098 */1099if(!dir->basebuf.buf)1100strbuf_init(&dir->basebuf, PATH_MAX);11011102/* Read from the parent directories and push them down. */1103 current = stk ? stk->baselen : -1;1104strbuf_setlen(&dir->basebuf, current <0?0: current);1105if(dir->untracked)1106 untracked = stk ? stk->ucd : dir->untracked->root;1107else1108 untracked = NULL;11091110while(current < baselen) {1111const char*cp;1112struct sha1_stat sha1_stat;11131114 stk =xcalloc(1,sizeof(*stk));1115if(current <0) {1116 cp = base;1117 current =0;1118}else{1119 cp =strchr(base + current +1,'/');1120if(!cp)1121die("oops in prep_exclude");1122 cp++;1123 untracked =1124lookup_untracked(dir->untracked, untracked,1125 base + current,1126 cp - base - current);1127}1128 stk->prev = dir->exclude_stack;1129 stk->baselen = cp - base;1130 stk->exclude_ix = group->nr;1131 stk->ucd = untracked;1132 el =add_exclude_list(dir, EXC_DIRS, NULL);1133strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1134assert(stk->baselen == dir->basebuf.len);11351136/* Abort if the directory is excluded */1137if(stk->baselen) {1138int dt = DT_DIR;1139 dir->basebuf.buf[stk->baselen -1] =0;1140 dir->exclude =last_exclude_matching_from_lists(dir,1141 istate,1142 dir->basebuf.buf, stk->baselen -1,1143 dir->basebuf.buf + current, &dt);1144 dir->basebuf.buf[stk->baselen -1] ='/';1145if(dir->exclude &&1146 dir->exclude->flags & EXC_FLAG_NEGATIVE)1147 dir->exclude = NULL;1148if(dir->exclude) {1149 dir->exclude_stack = stk;1150return;1151}1152}11531154/* Try to read per-directory file */1155hashclr(sha1_stat.sha1);1156 sha1_stat.valid =0;1157if(dir->exclude_per_dir &&1158/*1159 * If we know that no files have been added in1160 * this directory (i.e. valid_cached_dir() has1161 * been executed and set untracked->valid) ..1162 */1163(!untracked || !untracked->valid ||1164/*1165 * .. and .gitignore does not exist before1166 * (i.e. null exclude_sha1). Then we can skip1167 * loading .gitignore, which would result in1168 * ENOENT anyway.1169 */1170!is_null_sha1(untracked->exclude_sha1))) {1171/*1172 * dir->basebuf gets reused by the traversal, but we1173 * need fname to remain unchanged to ensure the src1174 * member of each struct exclude correctly1175 * back-references its source file. Other invocations1176 * of add_exclude_list provide stable strings, so we1177 * strbuf_detach() and free() here in the caller.1178 */1179struct strbuf sb = STRBUF_INIT;1180strbuf_addbuf(&sb, &dir->basebuf);1181strbuf_addstr(&sb, dir->exclude_per_dir);1182 el->src =strbuf_detach(&sb, NULL);1183add_excludes(el->src, el->src, stk->baselen, el, istate,1184 untracked ? &sha1_stat : NULL);1185}1186/*1187 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1188 * will first be called in valid_cached_dir() then maybe many1189 * times more in last_exclude_matching(). When the cache is1190 * used, last_exclude_matching() will not be called and1191 * reading .gitignore content will be a waste.1192 *1193 * So when it's called by valid_cached_dir() and we can get1194 * .gitignore SHA-1 from the index (i.e. .gitignore is not1195 * modified on work tree), we could delay reading the1196 * .gitignore content until we absolutely need it in1197 * last_exclude_matching(). Be careful about ignore rule1198 * order, though, if you do that.1199 */1200if(untracked &&1201hashcmp(sha1_stat.sha1, untracked->exclude_sha1)) {1202invalidate_gitignore(dir->untracked, untracked);1203hashcpy(untracked->exclude_sha1, sha1_stat.sha1);1204}1205 dir->exclude_stack = stk;1206 current = stk->baselen;1207}1208strbuf_setlen(&dir->basebuf, baselen);1209}12101211/*1212 * Loads the exclude lists for the directory containing pathname, then1213 * scans all exclude lists to determine whether pathname is excluded.1214 * Returns the exclude_list element which matched, or NULL for1215 * undecided.1216 */1217struct exclude *last_exclude_matching(struct dir_struct *dir,1218struct index_state *istate,1219const char*pathname,1220int*dtype_p)1221{1222int pathlen =strlen(pathname);1223const char*basename =strrchr(pathname,'/');1224 basename = (basename) ? basename+1: pathname;12251226prep_exclude(dir, istate, pathname, basename-pathname);12271228if(dir->exclude)1229return dir->exclude;12301231returnlast_exclude_matching_from_lists(dir, istate, pathname, pathlen,1232 basename, dtype_p);1233}12341235/*1236 * Loads the exclude lists for the directory containing pathname, then1237 * scans all exclude lists to determine whether pathname is excluded.1238 * Returns 1 if true, otherwise 0.1239 */1240intis_excluded(struct dir_struct *dir,struct index_state *istate,1241const char*pathname,int*dtype_p)1242{1243struct exclude *exclude =1244last_exclude_matching(dir, istate, pathname, dtype_p);1245if(exclude)1246return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1247return0;1248}12491250static struct dir_entry *dir_entry_new(const char*pathname,int len)1251{1252struct dir_entry *ent;12531254FLEX_ALLOC_MEM(ent, name, pathname, len);1255 ent->len = len;1256return ent;1257}12581259static struct dir_entry *dir_add_name(struct dir_struct *dir,1260struct index_state *istate,1261const char*pathname,int len)1262{1263if(index_file_exists(istate, pathname, len, ignore_case))1264return NULL;12651266ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1267return dir->entries[dir->nr++] =dir_entry_new(pathname, len);1268}12691270struct dir_entry *dir_add_ignored(struct dir_struct *dir,1271struct index_state *istate,1272const char*pathname,int len)1273{1274if(!index_name_is_other(istate, pathname, len))1275return NULL;12761277ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1278return dir->ignored[dir->ignored_nr++] =dir_entry_new(pathname, len);1279}12801281enum exist_status {1282 index_nonexistent =0,1283 index_directory,1284 index_gitdir1285};12861287/*1288 * Do not use the alphabetically sorted index to look up1289 * the directory name; instead, use the case insensitive1290 * directory hash.1291 */1292static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1293const char*dirname,int len)1294{1295struct cache_entry *ce;12961297if(index_dir_exists(istate, dirname, len))1298return index_directory;12991300 ce =index_file_exists(istate, dirname, len, ignore_case);1301if(ce &&S_ISGITLINK(ce->ce_mode))1302return index_gitdir;13031304return index_nonexistent;1305}13061307/*1308 * The index sorts alphabetically by entry name, which1309 * means that a gitlink sorts as '\0' at the end, while1310 * a directory (which is defined not as an entry, but as1311 * the files it contains) will sort with the '/' at the1312 * end.1313 */1314static enum exist_status directory_exists_in_index(struct index_state *istate,1315const char*dirname,int len)1316{1317int pos;13181319if(ignore_case)1320returndirectory_exists_in_index_icase(istate, dirname, len);13211322 pos =index_name_pos(istate, dirname, len);1323if(pos <0)1324 pos = -pos-1;1325while(pos < istate->cache_nr) {1326const struct cache_entry *ce = istate->cache[pos++];1327unsigned char endchar;13281329if(strncmp(ce->name, dirname, len))1330break;1331 endchar = ce->name[len];1332if(endchar >'/')1333break;1334if(endchar =='/')1335return index_directory;1336if(!endchar &&S_ISGITLINK(ce->ce_mode))1337return index_gitdir;1338}1339return index_nonexistent;1340}13411342/*1343 * When we find a directory when traversing the filesystem, we1344 * have three distinct cases:1345 *1346 * - ignore it1347 * - see it as a directory1348 * - recurse into it1349 *1350 * and which one we choose depends on a combination of existing1351 * git index contents and the flags passed into the directory1352 * traversal routine.1353 *1354 * Case 1: If we *already* have entries in the index under that1355 * directory name, we always recurse into the directory to see1356 * all the files.1357 *1358 * Case 2: If we *already* have that directory name as a gitlink,1359 * we always continue to see it as a gitlink, regardless of whether1360 * there is an actual git directory there or not (it might not1361 * be checked out as a subproject!)1362 *1363 * Case 3: if we didn't have it in the index previously, we1364 * have a few sub-cases:1365 *1366 * (a) if "show_other_directories" is true, we show it as1367 * just a directory, unless "hide_empty_directories" is1368 * also true, in which case we need to check if it contains any1369 * untracked and / or ignored files.1370 * (b) if it looks like a git directory, and we don't have1371 * 'no_gitlinks' set we treat it as a gitlink, and show it1372 * as a directory.1373 * (c) otherwise, we recurse into it.1374 */1375static enum path_treatment treat_directory(struct dir_struct *dir,1376struct index_state *istate,1377struct untracked_cache_dir *untracked,1378const char*dirname,int len,int baselen,int exclude,1379const struct pathspec *pathspec)1380{1381/* The "len-1" is to strip the final '/' */1382switch(directory_exists_in_index(istate, dirname, len-1)) {1383case index_directory:1384return path_recurse;13851386case index_gitdir:1387return path_none;13881389case index_nonexistent:1390if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1391break;1392if(exclude &&1393(dir->flags & DIR_SHOW_IGNORED_TOO) &&1394(dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING)) {13951396/*1397 * This is an excluded directory and we are1398 * showing ignored paths that match an exclude1399 * pattern. (e.g. show directory as ignored1400 * only if it matches an exclude pattern).1401 * This path will either be 'path_excluded`1402 * (if we are showing empty directories or if1403 * the directory is not empty), or will be1404 * 'path_none' (empty directory, and we are1405 * not showing empty directories).1406 */1407if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1408return path_excluded;14091410if(read_directory_recursive(dir, istate, dirname, len,1411 untracked,1,1, pathspec) == path_excluded)1412return path_excluded;14131414return path_none;1415}1416if(!(dir->flags & DIR_NO_GITLINKS)) {1417struct object_id oid;1418if(resolve_gitlink_ref(dirname,"HEAD", &oid) ==0)1419return exclude ? path_excluded : path_untracked;1420}1421return path_recurse;1422}14231424/* This is the "show_other_directories" case */14251426if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1427return exclude ? path_excluded : path_untracked;14281429 untracked =lookup_untracked(dir->untracked, untracked,1430 dirname + baselen, len - baselen);14311432/*1433 * If this is an excluded directory, then we only need to check if1434 * the directory contains any files.1435 */1436returnread_directory_recursive(dir, istate, dirname, len,1437 untracked,1, exclude, pathspec);1438}14391440/*1441 * This is an inexact early pruning of any recursive directory1442 * reading - if the path cannot possibly be in the pathspec,1443 * return true, and we'll skip it early.1444 */1445static intsimplify_away(const char*path,int pathlen,1446const struct pathspec *pathspec)1447{1448int i;14491450if(!pathspec || !pathspec->nr)1451return0;14521453GUARD_PATHSPEC(pathspec,1454 PATHSPEC_FROMTOP |1455 PATHSPEC_MAXDEPTH |1456 PATHSPEC_LITERAL |1457 PATHSPEC_GLOB |1458 PATHSPEC_ICASE |1459 PATHSPEC_EXCLUDE |1460 PATHSPEC_ATTR);14611462for(i =0; i < pathspec->nr; i++) {1463const struct pathspec_item *item = &pathspec->items[i];1464int len = item->nowildcard_len;14651466if(len > pathlen)1467 len = pathlen;1468if(!ps_strncmp(item, item->match, path, len))1469return0;1470}14711472return1;1473}14741475/*1476 * This function tells us whether an excluded path matches a1477 * list of "interesting" pathspecs. That is, whether a path matched1478 * by any of the pathspecs could possibly be ignored by excluding1479 * the specified path. This can happen if:1480 *1481 * 1. the path is mentioned explicitly in the pathspec1482 *1483 * 2. the path is a directory prefix of some element in the1484 * pathspec1485 */1486static intexclude_matches_pathspec(const char*path,int pathlen,1487const struct pathspec *pathspec)1488{1489int i;14901491if(!pathspec || !pathspec->nr)1492return0;14931494GUARD_PATHSPEC(pathspec,1495 PATHSPEC_FROMTOP |1496 PATHSPEC_MAXDEPTH |1497 PATHSPEC_LITERAL |1498 PATHSPEC_GLOB |1499 PATHSPEC_ICASE |1500 PATHSPEC_EXCLUDE);15011502for(i =0; i < pathspec->nr; i++) {1503const struct pathspec_item *item = &pathspec->items[i];1504int len = item->nowildcard_len;15051506if(len == pathlen &&1507!ps_strncmp(item, item->match, path, pathlen))1508return1;1509if(len > pathlen &&1510 item->match[pathlen] =='/'&&1511!ps_strncmp(item, item->match, path, pathlen))1512return1;1513}1514return0;1515}15161517static intget_index_dtype(struct index_state *istate,1518const char*path,int len)1519{1520int pos;1521const struct cache_entry *ce;15221523 ce =index_file_exists(istate, path, len,0);1524if(ce) {1525if(!ce_uptodate(ce))1526return DT_UNKNOWN;1527if(S_ISGITLINK(ce->ce_mode))1528return DT_DIR;1529/*1530 * Nobody actually cares about the1531 * difference between DT_LNK and DT_REG1532 */1533return DT_REG;1534}15351536/* Try to look it up as a directory */1537 pos =index_name_pos(istate, path, len);1538if(pos >=0)1539return DT_UNKNOWN;1540 pos = -pos-1;1541while(pos < istate->cache_nr) {1542 ce = istate->cache[pos++];1543if(strncmp(ce->name, path, len))1544break;1545if(ce->name[len] >'/')1546break;1547if(ce->name[len] <'/')1548continue;1549if(!ce_uptodate(ce))1550break;/* continue? */1551return DT_DIR;1552}1553return DT_UNKNOWN;1554}15551556static intget_dtype(struct dirent *de,struct index_state *istate,1557const char*path,int len)1558{1559int dtype = de ?DTYPE(de) : DT_UNKNOWN;1560struct stat st;15611562if(dtype != DT_UNKNOWN)1563return dtype;1564 dtype =get_index_dtype(istate, path, len);1565if(dtype != DT_UNKNOWN)1566return dtype;1567if(lstat(path, &st))1568return dtype;1569if(S_ISREG(st.st_mode))1570return DT_REG;1571if(S_ISDIR(st.st_mode))1572return DT_DIR;1573if(S_ISLNK(st.st_mode))1574return DT_LNK;1575return dtype;1576}15771578static enum path_treatment treat_one_path(struct dir_struct *dir,1579struct untracked_cache_dir *untracked,1580struct index_state *istate,1581struct strbuf *path,1582int baselen,1583const struct pathspec *pathspec,1584int dtype,struct dirent *de)1585{1586int exclude;1587int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);1588enum path_treatment path_treatment;15891590if(dtype == DT_UNKNOWN)1591 dtype =get_dtype(de, istate, path->buf, path->len);15921593/* Always exclude indexed files */1594if(dtype != DT_DIR && has_path_in_index)1595return path_none;15961597/*1598 * When we are looking at a directory P in the working tree,1599 * there are three cases:1600 *1601 * (1) P exists in the index. Everything inside the directory P in1602 * the working tree needs to go when P is checked out from the1603 * index.1604 *1605 * (2) P does not exist in the index, but there is P/Q in the index.1606 * We know P will stay a directory when we check out the contents1607 * of the index, but we do not know yet if there is a directory1608 * P/Q in the working tree to be killed, so we need to recurse.1609 *1610 * (3) P does not exist in the index, and there is no P/Q in the index1611 * to require P to be a directory, either. Only in this case, we1612 * know that everything inside P will not be killed without1613 * recursing.1614 */1615if((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1616(dtype == DT_DIR) &&1617!has_path_in_index &&1618(directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))1619return path_none;16201621 exclude =is_excluded(dir, istate, path->buf, &dtype);16221623/*1624 * Excluded? If we don't explicitly want to show1625 * ignored files, ignore it1626 */1627if(exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1628return path_excluded;16291630switch(dtype) {1631default:1632return path_none;1633case DT_DIR:1634strbuf_addch(path,'/');1635 path_treatment =treat_directory(dir, istate, untracked,1636 path->buf, path->len,1637 baselen, exclude, pathspec);1638/*1639 * If 1) we only want to return directories that1640 * match an exclude pattern and 2) this directory does1641 * not match an exclude pattern but all of its1642 * contents are excluded, then indicate that we should1643 * recurse into this directory (instead of marking the1644 * directory itself as an ignored path).1645 */1646if(!exclude &&1647 path_treatment == path_excluded &&1648(dir->flags & DIR_SHOW_IGNORED_TOO) &&1649(dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING))1650return path_recurse;1651return path_treatment;1652case DT_REG:1653case DT_LNK:1654return exclude ? path_excluded : path_untracked;1655}1656}16571658static enum path_treatment treat_path_fast(struct dir_struct *dir,1659struct untracked_cache_dir *untracked,1660struct cached_dir *cdir,1661struct index_state *istate,1662struct strbuf *path,1663int baselen,1664const struct pathspec *pathspec)1665{1666strbuf_setlen(path, baselen);1667if(!cdir->ucd) {1668strbuf_addstr(path, cdir->file);1669return path_untracked;1670}1671strbuf_addstr(path, cdir->ucd->name);1672/* treat_one_path() does this before it calls treat_directory() */1673strbuf_complete(path,'/');1674if(cdir->ucd->check_only)1675/*1676 * check_only is set as a result of treat_directory() getting1677 * to its bottom. Verify again the same set of directories1678 * with check_only set.1679 */1680returnread_directory_recursive(dir, istate, path->buf, path->len,1681 cdir->ucd,1,0, pathspec);1682/*1683 * We get path_recurse in the first run when1684 * directory_exists_in_index() returns index_nonexistent. We1685 * are sure that new changes in the index does not impact the1686 * outcome. Return now.1687 */1688return path_recurse;1689}16901691static enum path_treatment treat_path(struct dir_struct *dir,1692struct untracked_cache_dir *untracked,1693struct cached_dir *cdir,1694struct index_state *istate,1695struct strbuf *path,1696int baselen,1697const struct pathspec *pathspec)1698{1699int dtype;1700struct dirent *de = cdir->de;17011702if(!de)1703returntreat_path_fast(dir, untracked, cdir, istate, path,1704 baselen, pathspec);1705if(is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name,".git"))1706return path_none;1707strbuf_setlen(path, baselen);1708strbuf_addstr(path, de->d_name);1709if(simplify_away(path->buf, path->len, pathspec))1710return path_none;17111712 dtype =DTYPE(de);1713returntreat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1714}17151716static voidadd_untracked(struct untracked_cache_dir *dir,const char*name)1717{1718if(!dir)1719return;1720ALLOC_GROW(dir->untracked, dir->untracked_nr +1,1721 dir->untracked_alloc);1722 dir->untracked[dir->untracked_nr++] =xstrdup(name);1723}17241725static intvalid_cached_dir(struct dir_struct *dir,1726struct untracked_cache_dir *untracked,1727struct index_state *istate,1728struct strbuf *path,1729int check_only)1730{1731struct stat st;17321733if(!untracked)1734return0;17351736if(stat(path->len ? path->buf :".", &st)) {1737invalidate_directory(dir->untracked, untracked);1738memset(&untracked->stat_data,0,sizeof(untracked->stat_data));1739return0;1740}1741if(!untracked->valid ||1742match_stat_data_racy(istate, &untracked->stat_data, &st)) {1743if(untracked->valid)1744invalidate_directory(dir->untracked, untracked);1745fill_stat_data(&untracked->stat_data, &st);1746return0;1747}17481749if(untracked->check_only != !!check_only) {1750invalidate_directory(dir->untracked, untracked);1751return0;1752}17531754/*1755 * prep_exclude will be called eventually on this directory,1756 * but it's called much later in last_exclude_matching(). We1757 * need it now to determine the validity of the cache for this1758 * path. The next calls will be nearly no-op, the way1759 * prep_exclude() is designed.1760 */1761if(path->len && path->buf[path->len -1] !='/') {1762strbuf_addch(path,'/');1763prep_exclude(dir, istate, path->buf, path->len);1764strbuf_setlen(path, path->len -1);1765}else1766prep_exclude(dir, istate, path->buf, path->len);17671768/* hopefully prep_exclude() haven't invalidated this entry... */1769return untracked->valid;1770}17711772static intopen_cached_dir(struct cached_dir *cdir,1773struct dir_struct *dir,1774struct untracked_cache_dir *untracked,1775struct index_state *istate,1776struct strbuf *path,1777int check_only)1778{1779memset(cdir,0,sizeof(*cdir));1780 cdir->untracked = untracked;1781if(valid_cached_dir(dir, untracked, istate, path, check_only))1782return0;1783 cdir->fdir =opendir(path->len ? path->buf :".");1784if(dir->untracked)1785 dir->untracked->dir_opened++;1786if(!cdir->fdir)1787return-1;1788return0;1789}17901791static intread_cached_dir(struct cached_dir *cdir)1792{1793if(cdir->fdir) {1794 cdir->de =readdir(cdir->fdir);1795if(!cdir->de)1796return-1;1797return0;1798}1799while(cdir->nr_dirs < cdir->untracked->dirs_nr) {1800struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1801if(!d->recurse) {1802 cdir->nr_dirs++;1803continue;1804}1805 cdir->ucd = d;1806 cdir->nr_dirs++;1807return0;1808}1809 cdir->ucd = NULL;1810if(cdir->nr_files < cdir->untracked->untracked_nr) {1811struct untracked_cache_dir *d = cdir->untracked;1812 cdir->file = d->untracked[cdir->nr_files++];1813return0;1814}1815return-1;1816}18171818static voidclose_cached_dir(struct cached_dir *cdir)1819{1820if(cdir->fdir)1821closedir(cdir->fdir);1822/*1823 * We have gone through this directory and found no untracked1824 * entries. Mark it valid.1825 */1826if(cdir->untracked) {1827 cdir->untracked->valid =1;1828 cdir->untracked->recurse =1;1829}1830}18311832/*1833 * Read a directory tree. We currently ignore anything but1834 * directories, regular files and symlinks. That's because git1835 * doesn't handle them at all yet. Maybe that will change some1836 * day.1837 *1838 * Also, we ignore the name ".git" (even if it is not a directory).1839 * That likely will not change.1840 *1841 * If 'stop_at_first_file' is specified, 'path_excluded' is returned1842 * to signal that a file was found. This is the least significant value that1843 * indicates that a file was encountered that does not depend on the order of1844 * whether an untracked or exluded path was encountered first.1845 *1846 * Returns the most significant path_treatment value encountered in the scan.1847 * If 'stop_at_first_file' is specified, `path_excluded` is the most1848 * significant path_treatment value that will be returned.1849 */18501851static enum path_treatment read_directory_recursive(struct dir_struct *dir,1852struct index_state *istate,const char*base,int baselen,1853struct untracked_cache_dir *untracked,int check_only,1854int stop_at_first_file,const struct pathspec *pathspec)1855{1856struct cached_dir cdir;1857enum path_treatment state, subdir_state, dir_state = path_none;1858struct strbuf path = STRBUF_INIT;18591860strbuf_add(&path, base, baselen);18611862if(open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1863goto out;18641865if(untracked)1866 untracked->check_only = !!check_only;18671868while(!read_cached_dir(&cdir)) {1869/* check how the file or directory should be treated */1870 state =treat_path(dir, untracked, &cdir, istate, &path,1871 baselen, pathspec);18721873if(state > dir_state)1874 dir_state = state;18751876/* recurse into subdir if instructed by treat_path */1877if((state == path_recurse) ||1878((state == path_untracked) &&1879(dir->flags & DIR_SHOW_IGNORED_TOO) &&1880(get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {1881struct untracked_cache_dir *ud;1882 ud =lookup_untracked(dir->untracked, untracked,1883 path.buf + baselen,1884 path.len - baselen);1885 subdir_state =1886read_directory_recursive(dir, istate, path.buf,1887 path.len, ud,1888 check_only, stop_at_first_file, pathspec);1889if(subdir_state > dir_state)1890 dir_state = subdir_state;1891}18921893if(check_only) {1894if(stop_at_first_file) {1895/*1896 * If stopping at first file, then1897 * signal that a file was found by1898 * returning `path_excluded`. This is1899 * to return a consistent value1900 * regardless of whether an ignored or1901 * excluded file happened to be1902 * encountered 1st.1903 *1904 * In current usage, the1905 * `stop_at_first_file` is passed when1906 * an ancestor directory has matched1907 * an exclude pattern, so any found1908 * files will be excluded.1909 */1910if(dir_state >= path_excluded) {1911 dir_state = path_excluded;1912break;1913}1914}19151916/* abort early if maximum state has been reached */1917if(dir_state == path_untracked) {1918if(cdir.fdir)1919add_untracked(untracked, path.buf + baselen);1920break;1921}1922/* skip the dir_add_* part */1923continue;1924}19251926/* add the path to the appropriate result list */1927switch(state) {1928case path_excluded:1929if(dir->flags & DIR_SHOW_IGNORED)1930dir_add_name(dir, istate, path.buf, path.len);1931else if((dir->flags & DIR_SHOW_IGNORED_TOO) ||1932((dir->flags & DIR_COLLECT_IGNORED) &&1933exclude_matches_pathspec(path.buf, path.len,1934 pathspec)))1935dir_add_ignored(dir, istate, path.buf, path.len);1936break;19371938case path_untracked:1939if(dir->flags & DIR_SHOW_IGNORED)1940break;1941dir_add_name(dir, istate, path.buf, path.len);1942if(cdir.fdir)1943add_untracked(untracked, path.buf + baselen);1944break;19451946default:1947break;1948}1949}1950close_cached_dir(&cdir);1951 out:1952strbuf_release(&path);19531954return dir_state;1955}19561957intcmp_dir_entry(const void*p1,const void*p2)1958{1959const struct dir_entry *e1 = *(const struct dir_entry **)p1;1960const struct dir_entry *e2 = *(const struct dir_entry **)p2;19611962returnname_compare(e1->name, e1->len, e2->name, e2->len);1963}19641965/* check if *out lexically strictly contains *in */1966intcheck_dir_entry_contains(const struct dir_entry *out,const struct dir_entry *in)1967{1968return(out->len < in->len) &&1969(out->name[out->len -1] =='/') &&1970!memcmp(out->name, in->name, out->len);1971}19721973static inttreat_leading_path(struct dir_struct *dir,1974struct index_state *istate,1975const char*path,int len,1976const struct pathspec *pathspec)1977{1978struct strbuf sb = STRBUF_INIT;1979int baselen, rc =0;1980const char*cp;1981int old_flags = dir->flags;19821983while(len && path[len -1] =='/')1984 len--;1985if(!len)1986return1;1987 baselen =0;1988 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1989while(1) {1990 cp = path + baselen + !!baselen;1991 cp =memchr(cp,'/', path + len - cp);1992if(!cp)1993 baselen = len;1994else1995 baselen = cp - path;1996strbuf_setlen(&sb,0);1997strbuf_add(&sb, path, baselen);1998if(!is_directory(sb.buf))1999break;2000if(simplify_away(sb.buf, sb.len, pathspec))2001break;2002if(treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,2003 DT_DIR, NULL) == path_none)2004break;/* do not recurse into it */2005if(len <= baselen) {2006 rc =1;2007break;/* finished checking */2008}2009}2010strbuf_release(&sb);2011 dir->flags = old_flags;2012return rc;2013}20142015static const char*get_ident_string(void)2016{2017static struct strbuf sb = STRBUF_INIT;2018struct utsname uts;20192020if(sb.len)2021return sb.buf;2022if(uname(&uts) <0)2023die_errno(_("failed to get kernel name and information"));2024strbuf_addf(&sb,"Location%s, system%s",get_git_work_tree(),2025 uts.sysname);2026return sb.buf;2027}20282029static intident_in_untracked(const struct untracked_cache *uc)2030{2031/*2032 * Previous git versions may have saved many NUL separated2033 * strings in the "ident" field, but it is insane to manage2034 * many locations, so just take care of the first one.2035 */20362037return!strcmp(uc->ident.buf,get_ident_string());2038}20392040static voidset_untracked_ident(struct untracked_cache *uc)2041{2042strbuf_reset(&uc->ident);2043strbuf_addstr(&uc->ident,get_ident_string());20442045/*2046 * This strbuf used to contain a list of NUL separated2047 * strings, so save NUL too for backward compatibility.2048 */2049strbuf_addch(&uc->ident,0);2050}20512052static voidnew_untracked_cache(struct index_state *istate)2053{2054struct untracked_cache *uc =xcalloc(1,sizeof(*uc));2055strbuf_init(&uc->ident,100);2056 uc->exclude_per_dir =".gitignore";2057/* should be the same flags used by git-status */2058 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;2059set_untracked_ident(uc);2060 istate->untracked = uc;2061 istate->cache_changed |= UNTRACKED_CHANGED;2062}20632064voidadd_untracked_cache(struct index_state *istate)2065{2066if(!istate->untracked) {2067new_untracked_cache(istate);2068}else{2069if(!ident_in_untracked(istate->untracked)) {2070free_untracked_cache(istate->untracked);2071new_untracked_cache(istate);2072}2073}2074}20752076voidremove_untracked_cache(struct index_state *istate)2077{2078if(istate->untracked) {2079free_untracked_cache(istate->untracked);2080 istate->untracked = NULL;2081 istate->cache_changed |= UNTRACKED_CHANGED;2082}2083}20842085static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,2086int base_len,2087const struct pathspec *pathspec)2088{2089struct untracked_cache_dir *root;20902091if(!dir->untracked ||getenv("GIT_DISABLE_UNTRACKED_CACHE"))2092return NULL;20932094/*2095 * We only support $GIT_DIR/info/exclude and core.excludesfile2096 * as the global ignore rule files. Any other additions2097 * (e.g. from command line) invalidate the cache. This2098 * condition also catches running setup_standard_excludes()2099 * before setting dir->untracked!2100 */2101if(dir->unmanaged_exclude_files)2102return NULL;21032104/*2105 * Optimize for the main use case only: whole-tree git2106 * status. More work involved in treat_leading_path() if we2107 * use cache on just a subset of the worktree. pathspec2108 * support could make the matter even worse.2109 */2110if(base_len || (pathspec && pathspec->nr))2111return NULL;21122113/* Different set of flags may produce different results */2114if(dir->flags != dir->untracked->dir_flags ||2115/*2116 * See treat_directory(), case index_nonexistent. Without2117 * this flag, we may need to also cache .git file content2118 * for the resolve_gitlink_ref() call, which we don't.2119 */2120!(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2121/* We don't support collecting ignore files */2122(dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2123 DIR_COLLECT_IGNORED)))2124return NULL;21252126/*2127 * If we use .gitignore in the cache and now you change it to2128 * .gitexclude, everything will go wrong.2129 */2130if(dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2131strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2132return NULL;21332134/*2135 * EXC_CMDL is not considered in the cache. If people set it,2136 * skip the cache.2137 */2138if(dir->exclude_list_group[EXC_CMDL].nr)2139return NULL;21402141if(!ident_in_untracked(dir->untracked)) {2142warning(_("Untracked cache is disabled on this system or location."));2143return NULL;2144}21452146if(!dir->untracked->root) {2147const int len =sizeof(*dir->untracked->root);2148 dir->untracked->root =xmalloc(len);2149memset(dir->untracked->root,0, len);2150}21512152/* Validate $GIT_DIR/info/exclude and core.excludesfile */2153 root = dir->untracked->root;2154if(hashcmp(dir->ss_info_exclude.sha1,2155 dir->untracked->ss_info_exclude.sha1)) {2156invalidate_gitignore(dir->untracked, root);2157 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2158}2159if(hashcmp(dir->ss_excludes_file.sha1,2160 dir->untracked->ss_excludes_file.sha1)) {2161invalidate_gitignore(dir->untracked, root);2162 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2163}21642165/* Make sure this directory is not dropped out at saving phase */2166 root->recurse =1;2167return root;2168}21692170intread_directory(struct dir_struct *dir,struct index_state *istate,2171const char*path,int len,const struct pathspec *pathspec)2172{2173struct untracked_cache_dir *untracked;21742175if(has_symlink_leading_path(path, len))2176return dir->nr;21772178 untracked =validate_untracked_cache(dir, len, pathspec);2179if(!untracked)2180/*2181 * make sure untracked cache code path is disabled,2182 * e.g. prep_exclude()2183 */2184 dir->untracked = NULL;2185if(!len ||treat_leading_path(dir, istate, path, len, pathspec))2186read_directory_recursive(dir, istate, path, len, untracked,0,0, pathspec);2187QSORT(dir->entries, dir->nr, cmp_dir_entry);2188QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);21892190/*2191 * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will2192 * also pick up untracked contents of untracked dirs; by default2193 * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.2194 */2195if((dir->flags & DIR_SHOW_IGNORED_TOO) &&2196!(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {2197int i, j;21982199/* remove from dir->entries untracked contents of untracked dirs */2200for(i = j =0; j < dir->nr; j++) {2201if(i &&2202check_dir_entry_contains(dir->entries[i -1], dir->entries[j])) {2203FREE_AND_NULL(dir->entries[j]);2204}else{2205 dir->entries[i++] = dir->entries[j];2206}2207}22082209 dir->nr = i;2210}22112212if(dir->untracked) {2213static struct trace_key trace_untracked_stats =TRACE_KEY_INIT(UNTRACKED_STATS);2214trace_printf_key(&trace_untracked_stats,2215"node creation:%u\n"2216"gitignore invalidation:%u\n"2217"directory invalidation:%u\n"2218"opendir:%u\n",2219 dir->untracked->dir_created,2220 dir->untracked->gitignore_invalidated,2221 dir->untracked->dir_invalidated,2222 dir->untracked->dir_opened);2223if(dir->untracked == istate->untracked &&2224(dir->untracked->dir_opened ||2225 dir->untracked->gitignore_invalidated ||2226 dir->untracked->dir_invalidated))2227 istate->cache_changed |= UNTRACKED_CHANGED;2228if(dir->untracked != istate->untracked) {2229FREE_AND_NULL(dir->untracked);2230}2231}2232return dir->nr;2233}22342235intfile_exists(const char*f)2236{2237struct stat sb;2238returnlstat(f, &sb) ==0;2239}22402241static intcmp_icase(char a,char b)2242{2243if(a == b)2244return0;2245if(ignore_case)2246returntoupper(a) -toupper(b);2247return a - b;2248}22492250/*2251 * Given two normalized paths (a trailing slash is ok), if subdir is2252 * outside dir, return -1. Otherwise return the offset in subdir that2253 * can be used as relative path to dir.2254 */2255intdir_inside_of(const char*subdir,const char*dir)2256{2257int offset =0;22582259assert(dir && subdir && *dir && *subdir);22602261while(*dir && *subdir && !cmp_icase(*dir, *subdir)) {2262 dir++;2263 subdir++;2264 offset++;2265}22662267/* hel[p]/me vs hel[l]/yeah */2268if(*dir && *subdir)2269return-1;22702271if(!*subdir)2272return!*dir ? offset : -1;/* same dir */22732274/* foo/[b]ar vs foo/[] */2275if(is_dir_sep(dir[-1]))2276returnis_dir_sep(subdir[-1]) ? offset : -1;22772278/* foo[/]bar vs foo[] */2279returnis_dir_sep(*subdir) ? offset +1: -1;2280}22812282intis_inside_dir(const char*dir)2283{2284char*cwd;2285int rc;22862287if(!dir)2288return0;22892290 cwd =xgetcwd();2291 rc = (dir_inside_of(cwd, dir) >=0);2292free(cwd);2293return rc;2294}22952296intis_empty_dir(const char*path)2297{2298DIR*dir =opendir(path);2299struct dirent *e;2300int ret =1;23012302if(!dir)2303return0;23042305while((e =readdir(dir)) != NULL)2306if(!is_dot_or_dotdot(e->d_name)) {2307 ret =0;2308break;2309}23102311closedir(dir);2312return ret;2313}23142315static intremove_dir_recurse(struct strbuf *path,int flag,int*kept_up)2316{2317DIR*dir;2318struct dirent *e;2319int ret =0, original_len = path->len, len, kept_down =0;2320int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2321int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2322struct object_id submodule_head;23232324if((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2325!resolve_gitlink_ref(path->buf,"HEAD", &submodule_head)) {2326/* Do not descend and nuke a nested git work tree. */2327if(kept_up)2328*kept_up =1;2329return0;2330}23312332 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2333 dir =opendir(path->buf);2334if(!dir) {2335if(errno == ENOENT)2336return keep_toplevel ? -1:0;2337else if(errno == EACCES && !keep_toplevel)2338/*2339 * An empty dir could be removable even if it2340 * is unreadable:2341 */2342returnrmdir(path->buf);2343else2344return-1;2345}2346strbuf_complete(path,'/');23472348 len = path->len;2349while((e =readdir(dir)) != NULL) {2350struct stat st;2351if(is_dot_or_dotdot(e->d_name))2352continue;23532354strbuf_setlen(path, len);2355strbuf_addstr(path, e->d_name);2356if(lstat(path->buf, &st)) {2357if(errno == ENOENT)2358/*2359 * file disappeared, which is what we2360 * wanted anyway2361 */2362continue;2363/* fall thru */2364}else if(S_ISDIR(st.st_mode)) {2365if(!remove_dir_recurse(path, flag, &kept_down))2366continue;/* happy */2367}else if(!only_empty &&2368(!unlink(path->buf) || errno == ENOENT)) {2369continue;/* happy, too */2370}23712372/* path too long, stat fails, or non-directory still exists */2373 ret = -1;2374break;2375}2376closedir(dir);23772378strbuf_setlen(path, original_len);2379if(!ret && !keep_toplevel && !kept_down)2380 ret = (!rmdir(path->buf) || errno == ENOENT) ?0: -1;2381else if(kept_up)2382/*2383 * report the uplevel that it is not an error that we2384 * did not rmdir() our directory.2385 */2386*kept_up = !ret;2387return ret;2388}23892390intremove_dir_recursively(struct strbuf *path,int flag)2391{2392returnremove_dir_recurse(path, flag, NULL);2393}23942395staticGIT_PATH_FUNC(git_path_info_exclude,"info/exclude")23962397voidsetup_standard_excludes(struct dir_struct *dir)2398{2399 dir->exclude_per_dir =".gitignore";24002401/* core.excludefile defaulting to $XDG_HOME/git/ignore */2402if(!excludes_file)2403 excludes_file =xdg_config_home("ignore");2404if(excludes_file && !access_or_warn(excludes_file, R_OK,0))2405add_excludes_from_file_1(dir, excludes_file,2406 dir->untracked ? &dir->ss_excludes_file : NULL);24072408/* per repository user preference */2409if(startup_info->have_repository) {2410const char*path =git_path_info_exclude();2411if(!access_or_warn(path, R_OK,0))2412add_excludes_from_file_1(dir, path,2413 dir->untracked ? &dir->ss_info_exclude : NULL);2414}2415}24162417intremove_path(const char*name)2418{2419char*slash;24202421if(unlink(name) && !is_missing_file_error(errno))2422return-1;24232424 slash =strrchr(name,'/');2425if(slash) {2426char*dirs =xstrdup(name);2427 slash = dirs + (slash - name);2428do{2429*slash ='\0';2430}while(rmdir(dirs) ==0&& (slash =strrchr(dirs,'/')));2431free(dirs);2432}2433return0;2434}24352436/*2437 * Frees memory within dir which was allocated for exclude lists and2438 * the exclude_stack. Does not free dir itself.2439 */2440voidclear_directory(struct dir_struct *dir)2441{2442int i, j;2443struct exclude_list_group *group;2444struct exclude_list *el;2445struct exclude_stack *stk;24462447for(i = EXC_CMDL; i <= EXC_FILE; i++) {2448 group = &dir->exclude_list_group[i];2449for(j =0; j < group->nr; j++) {2450 el = &group->el[j];2451if(i == EXC_DIRS)2452free((char*)el->src);2453clear_exclude_list(el);2454}2455free(group->el);2456}24572458 stk = dir->exclude_stack;2459while(stk) {2460struct exclude_stack *prev = stk->prev;2461free(stk);2462 stk = prev;2463}2464strbuf_release(&dir->basebuf);2465}24662467struct ondisk_untracked_cache {2468struct stat_data info_exclude_stat;2469struct stat_data excludes_file_stat;2470uint32_t dir_flags;2471unsigned char info_exclude_sha1[20];2472unsigned char excludes_file_sha1[20];2473char exclude_per_dir[FLEX_ARRAY];2474};24752476#define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)2477#define ouc_size(len) (ouc_offset(exclude_per_dir) + len + 1)24782479struct write_data {2480int index;/* number of written untracked_cache_dir */2481struct ewah_bitmap *check_only;/* from untracked_cache_dir */2482struct ewah_bitmap *valid;/* from untracked_cache_dir */2483struct ewah_bitmap *sha1_valid;/* set if exclude_sha1 is not null */2484struct strbuf out;2485struct strbuf sb_stat;2486struct strbuf sb_sha1;2487};24882489static voidstat_data_to_disk(struct stat_data *to,const struct stat_data *from)2490{2491 to->sd_ctime.sec =htonl(from->sd_ctime.sec);2492 to->sd_ctime.nsec =htonl(from->sd_ctime.nsec);2493 to->sd_mtime.sec =htonl(from->sd_mtime.sec);2494 to->sd_mtime.nsec =htonl(from->sd_mtime.nsec);2495 to->sd_dev =htonl(from->sd_dev);2496 to->sd_ino =htonl(from->sd_ino);2497 to->sd_uid =htonl(from->sd_uid);2498 to->sd_gid =htonl(from->sd_gid);2499 to->sd_size =htonl(from->sd_size);2500}25012502static voidwrite_one_dir(struct untracked_cache_dir *untracked,2503struct write_data *wd)2504{2505struct stat_data stat_data;2506struct strbuf *out = &wd->out;2507unsigned char intbuf[16];2508unsigned int intlen, value;2509int i = wd->index++;25102511/*2512 * untracked_nr should be reset whenever valid is clear, but2513 * for safety..2514 */2515if(!untracked->valid) {2516 untracked->untracked_nr =0;2517 untracked->check_only =0;2518}25192520if(untracked->check_only)2521ewah_set(wd->check_only, i);2522if(untracked->valid) {2523ewah_set(wd->valid, i);2524stat_data_to_disk(&stat_data, &untracked->stat_data);2525strbuf_add(&wd->sb_stat, &stat_data,sizeof(stat_data));2526}2527if(!is_null_sha1(untracked->exclude_sha1)) {2528ewah_set(wd->sha1_valid, i);2529strbuf_add(&wd->sb_sha1, untracked->exclude_sha1,20);2530}25312532 intlen =encode_varint(untracked->untracked_nr, intbuf);2533strbuf_add(out, intbuf, intlen);25342535/* skip non-recurse directories */2536for(i =0, value =0; i < untracked->dirs_nr; i++)2537if(untracked->dirs[i]->recurse)2538 value++;2539 intlen =encode_varint(value, intbuf);2540strbuf_add(out, intbuf, intlen);25412542strbuf_add(out, untracked->name,strlen(untracked->name) +1);25432544for(i =0; i < untracked->untracked_nr; i++)2545strbuf_add(out, untracked->untracked[i],2546strlen(untracked->untracked[i]) +1);25472548for(i =0; i < untracked->dirs_nr; i++)2549if(untracked->dirs[i]->recurse)2550write_one_dir(untracked->dirs[i], wd);2551}25522553voidwrite_untracked_extension(struct strbuf *out,struct untracked_cache *untracked)2554{2555struct ondisk_untracked_cache *ouc;2556struct write_data wd;2557unsigned char varbuf[16];2558int varint_len;2559size_t len =strlen(untracked->exclude_per_dir);25602561FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2562stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2563stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2564hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);2565hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.sha1);2566 ouc->dir_flags =htonl(untracked->dir_flags);25672568 varint_len =encode_varint(untracked->ident.len, varbuf);2569strbuf_add(out, varbuf, varint_len);2570strbuf_addbuf(out, &untracked->ident);25712572strbuf_add(out, ouc,ouc_size(len));2573FREE_AND_NULL(ouc);25742575if(!untracked->root) {2576 varint_len =encode_varint(0, varbuf);2577strbuf_add(out, varbuf, varint_len);2578return;2579}25802581 wd.index =0;2582 wd.check_only =ewah_new();2583 wd.valid =ewah_new();2584 wd.sha1_valid =ewah_new();2585strbuf_init(&wd.out,1024);2586strbuf_init(&wd.sb_stat,1024);2587strbuf_init(&wd.sb_sha1,1024);2588write_one_dir(untracked->root, &wd);25892590 varint_len =encode_varint(wd.index, varbuf);2591strbuf_add(out, varbuf, varint_len);2592strbuf_addbuf(out, &wd.out);2593ewah_serialize_strbuf(wd.valid, out);2594ewah_serialize_strbuf(wd.check_only, out);2595ewah_serialize_strbuf(wd.sha1_valid, out);2596strbuf_addbuf(out, &wd.sb_stat);2597strbuf_addbuf(out, &wd.sb_sha1);2598strbuf_addch(out,'\0');/* safe guard for string lists */25992600ewah_free(wd.valid);2601ewah_free(wd.check_only);2602ewah_free(wd.sha1_valid);2603strbuf_release(&wd.out);2604strbuf_release(&wd.sb_stat);2605strbuf_release(&wd.sb_sha1);2606}26072608static voidfree_untracked(struct untracked_cache_dir *ucd)2609{2610int i;2611if(!ucd)2612return;2613for(i =0; i < ucd->dirs_nr; i++)2614free_untracked(ucd->dirs[i]);2615for(i =0; i < ucd->untracked_nr; i++)2616free(ucd->untracked[i]);2617free(ucd->untracked);2618free(ucd->dirs);2619free(ucd);2620}26212622voidfree_untracked_cache(struct untracked_cache *uc)2623{2624if(uc)2625free_untracked(uc->root);2626free(uc);2627}26282629struct read_data {2630int index;2631struct untracked_cache_dir **ucd;2632struct ewah_bitmap *check_only;2633struct ewah_bitmap *valid;2634struct ewah_bitmap *sha1_valid;2635const unsigned char*data;2636const unsigned char*end;2637};26382639static voidstat_data_from_disk(struct stat_data *to,const unsigned char*data)2640{2641memcpy(to, data,sizeof(*to));2642 to->sd_ctime.sec =ntohl(to->sd_ctime.sec);2643 to->sd_ctime.nsec =ntohl(to->sd_ctime.nsec);2644 to->sd_mtime.sec =ntohl(to->sd_mtime.sec);2645 to->sd_mtime.nsec =ntohl(to->sd_mtime.nsec);2646 to->sd_dev =ntohl(to->sd_dev);2647 to->sd_ino =ntohl(to->sd_ino);2648 to->sd_uid =ntohl(to->sd_uid);2649 to->sd_gid =ntohl(to->sd_gid);2650 to->sd_size =ntohl(to->sd_size);2651}26522653static intread_one_dir(struct untracked_cache_dir **untracked_,2654struct read_data *rd)2655{2656struct untracked_cache_dir ud, *untracked;2657const unsigned char*next, *data = rd->data, *end = rd->end;2658unsigned int value;2659int i, len;26602661memset(&ud,0,sizeof(ud));26622663 next = data;2664 value =decode_varint(&next);2665if(next > end)2666return-1;2667 ud.recurse =1;2668 ud.untracked_alloc = value;2669 ud.untracked_nr = value;2670if(ud.untracked_nr)2671ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2672 data = next;26732674 next = data;2675 ud.dirs_alloc = ud.dirs_nr =decode_varint(&next);2676if(next > end)2677return-1;2678ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2679 data = next;26802681 len =strlen((const char*)data);2682 next = data + len +1;2683if(next > rd->end)2684return-1;2685*untracked_ = untracked =xmalloc(st_add(sizeof(*untracked), len));2686memcpy(untracked, &ud,sizeof(ud));2687memcpy(untracked->name, data, len +1);2688 data = next;26892690for(i =0; i < untracked->untracked_nr; i++) {2691 len =strlen((const char*)data);2692 next = data + len +1;2693if(next > rd->end)2694return-1;2695 untracked->untracked[i] =xstrdup((const char*)data);2696 data = next;2697}26982699 rd->ucd[rd->index++] = untracked;2700 rd->data = data;27012702for(i =0; i < untracked->dirs_nr; i++) {2703 len =read_one_dir(untracked->dirs + i, rd);2704if(len <0)2705return-1;2706}2707return0;2708}27092710static voidset_check_only(size_t pos,void*cb)2711{2712struct read_data *rd = cb;2713struct untracked_cache_dir *ud = rd->ucd[pos];2714 ud->check_only =1;2715}27162717static voidread_stat(size_t pos,void*cb)2718{2719struct read_data *rd = cb;2720struct untracked_cache_dir *ud = rd->ucd[pos];2721if(rd->data +sizeof(struct stat_data) > rd->end) {2722 rd->data = rd->end +1;2723return;2724}2725stat_data_from_disk(&ud->stat_data, rd->data);2726 rd->data +=sizeof(struct stat_data);2727 ud->valid =1;2728}27292730static voidread_sha1(size_t pos,void*cb)2731{2732struct read_data *rd = cb;2733struct untracked_cache_dir *ud = rd->ucd[pos];2734if(rd->data +20> rd->end) {2735 rd->data = rd->end +1;2736return;2737}2738hashcpy(ud->exclude_sha1, rd->data);2739 rd->data +=20;2740}27412742static voidload_sha1_stat(struct sha1_stat *sha1_stat,2743const unsigned char*data,2744const unsigned char*sha1)2745{2746stat_data_from_disk(&sha1_stat->stat, data);2747hashcpy(sha1_stat->sha1, sha1);2748 sha1_stat->valid =1;2749}27502751struct untracked_cache *read_untracked_extension(const void*data,unsigned long sz)2752{2753struct untracked_cache *uc;2754struct read_data rd;2755const unsigned char*next = data, *end = (const unsigned char*)data + sz;2756const char*ident;2757int ident_len, len;2758const char*exclude_per_dir;27592760if(sz <=1|| end[-1] !='\0')2761return NULL;2762 end--;27632764 ident_len =decode_varint(&next);2765if(next + ident_len > end)2766return NULL;2767 ident = (const char*)next;2768 next += ident_len;27692770if(next +ouc_size(0) > end)2771return NULL;27722773 uc =xcalloc(1,sizeof(*uc));2774strbuf_init(&uc->ident, ident_len);2775strbuf_add(&uc->ident, ident, ident_len);2776load_sha1_stat(&uc->ss_info_exclude,2777 next +ouc_offset(info_exclude_stat),2778 next +ouc_offset(info_exclude_sha1));2779load_sha1_stat(&uc->ss_excludes_file,2780 next +ouc_offset(excludes_file_stat),2781 next +ouc_offset(excludes_file_sha1));2782 uc->dir_flags =get_be32(next +ouc_offset(dir_flags));2783 exclude_per_dir = (const char*)next +ouc_offset(exclude_per_dir);2784 uc->exclude_per_dir =xstrdup(exclude_per_dir);2785/* NUL after exclude_per_dir is covered by sizeof(*ouc) */2786 next +=ouc_size(strlen(exclude_per_dir));2787if(next >= end)2788goto done2;27892790 len =decode_varint(&next);2791if(next > end || len ==0)2792goto done2;27932794 rd.valid =ewah_new();2795 rd.check_only =ewah_new();2796 rd.sha1_valid =ewah_new();2797 rd.data = next;2798 rd.end = end;2799 rd.index =0;2800ALLOC_ARRAY(rd.ucd, len);28012802if(read_one_dir(&uc->root, &rd) || rd.index != len)2803goto done;28042805 next = rd.data;2806 len =ewah_read_mmap(rd.valid, next, end - next);2807if(len <0)2808goto done;28092810 next += len;2811 len =ewah_read_mmap(rd.check_only, next, end - next);2812if(len <0)2813goto done;28142815 next += len;2816 len =ewah_read_mmap(rd.sha1_valid, next, end - next);2817if(len <0)2818goto done;28192820ewah_each_bit(rd.check_only, set_check_only, &rd);2821 rd.data = next + len;2822ewah_each_bit(rd.valid, read_stat, &rd);2823ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2824 next = rd.data;28252826done:2827free(rd.ucd);2828ewah_free(rd.valid);2829ewah_free(rd.check_only);2830ewah_free(rd.sha1_valid);2831done2:2832if(next != end) {2833free_untracked_cache(uc);2834 uc = NULL;2835}2836return uc;2837}28382839static voidinvalidate_one_directory(struct untracked_cache *uc,2840struct untracked_cache_dir *ucd)2841{2842 uc->dir_invalidated++;2843 ucd->valid =0;2844 ucd->untracked_nr =0;2845}28462847/*2848 * Normally when an entry is added or removed from a directory,2849 * invalidating that directory is enough. No need to touch its2850 * ancestors. When a directory is shown as "foo/bar/" in git-status2851 * however, deleting or adding an entry may have cascading effect.2852 *2853 * Say the "foo/bar/file" has become untracked, we need to tell the2854 * untracked_cache_dir of "foo" that "bar/" is not an untracked2855 * directory any more (because "bar" is managed by foo as an untracked2856 * "file").2857 *2858 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2859 * was the last untracked entry in the entire "foo", we should show2860 * "foo/" instead. Which means we have to invalidate past "bar" up to2861 * "foo".2862 *2863 * This function traverses all directories from root to leaf. If there2864 * is a chance of one of the above cases happening, we invalidate back2865 * to root. Otherwise we just invalidate the leaf. There may be a more2866 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2867 * detect these cases and avoid unnecessary invalidation, for example,2868 * checking for the untracked entry named "bar/" in "foo", but for now2869 * stick to something safe and simple.2870 */2871static intinvalidate_one_component(struct untracked_cache *uc,2872struct untracked_cache_dir *dir,2873const char*path,int len)2874{2875const char*rest =strchr(path,'/');28762877if(rest) {2878int component_len = rest - path;2879struct untracked_cache_dir *d =2880lookup_untracked(uc, dir, path, component_len);2881int ret =2882invalidate_one_component(uc, d, rest +1,2883 len - (component_len +1));2884if(ret)2885invalidate_one_directory(uc, dir);2886return ret;2887}28882889invalidate_one_directory(uc, dir);2890return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2891}28922893voiduntracked_cache_invalidate_path(struct index_state *istate,2894const char*path)2895{2896if(!istate->untracked || !istate->untracked->root)2897return;2898invalidate_one_component(istate->untracked, istate->untracked->root,2899 path,strlen(path));2900}29012902voiduntracked_cache_remove_from_index(struct index_state *istate,2903const char*path)2904{2905untracked_cache_invalidate_path(istate, path);2906}29072908voiduntracked_cache_add_to_index(struct index_state *istate,2909const char*path)2910{2911untracked_cache_invalidate_path(istate, path);2912}29132914/* Update gitfile and core.worktree setting to connect work tree and git dir */2915voidconnect_work_tree_and_git_dir(const char*work_tree_,const char*git_dir_)2916{2917struct strbuf gitfile_sb = STRBUF_INIT;2918struct strbuf cfg_sb = STRBUF_INIT;2919struct strbuf rel_path = STRBUF_INIT;2920char*git_dir, *work_tree;29212922/* Prepare .git file */2923strbuf_addf(&gitfile_sb,"%s/.git", work_tree_);2924if(safe_create_leading_directories_const(gitfile_sb.buf))2925die(_("could not create directories for%s"), gitfile_sb.buf);29262927/* Prepare config file */2928strbuf_addf(&cfg_sb,"%s/config", git_dir_);2929if(safe_create_leading_directories_const(cfg_sb.buf))2930die(_("could not create directories for%s"), cfg_sb.buf);29312932 git_dir =real_pathdup(git_dir_,1);2933 work_tree =real_pathdup(work_tree_,1);29342935/* Write .git file */2936write_file(gitfile_sb.buf,"gitdir:%s",2937relative_path(git_dir, work_tree, &rel_path));2938/* Update core.worktree setting */2939git_config_set_in_file(cfg_sb.buf,"core.worktree",2940relative_path(work_tree, git_dir, &rel_path));29412942strbuf_release(&gitfile_sb);2943strbuf_release(&cfg_sb);2944strbuf_release(&rel_path);2945free(work_tree);2946free(git_dir);2947}29482949/*2950 * Migrate the git directory of the given path from old_git_dir to new_git_dir.2951 */2952voidrelocate_gitdir(const char*path,const char*old_git_dir,const char*new_git_dir)2953{2954if(rename(old_git_dir, new_git_dir) <0)2955die_errno(_("could not migrate git directory from '%s' to '%s'"),2956 old_git_dir, new_git_dir);29572958connect_work_tree_and_git_dir(path, new_git_dir);2959}