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#include"cache.h" 11#include"config.h" 12#include"dir.h" 13#include"object-store.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#include"fsmonitor.h" 22#include"submodule-config.h" 23 24/* 25 * Tells read_directory_recursive how a file or directory should be treated. 26 * Values are ordered by significance, e.g. if a directory contains both 27 * excluded and untracked files, it is listed as untracked because 28 * path_untracked > path_excluded. 29 */ 30enum path_treatment { 31 path_none =0, 32 path_recurse, 33 path_excluded, 34 path_untracked 35}; 36 37/* 38 * Support data structure for our opendir/readdir/closedir wrappers 39 */ 40struct cached_dir { 41DIR*fdir; 42struct untracked_cache_dir *untracked; 43int nr_files; 44int nr_dirs; 45 46struct dirent *de; 47const char*file; 48struct untracked_cache_dir *ucd; 49}; 50 51static enum path_treatment read_directory_recursive(struct dir_struct *dir, 52struct index_state *istate,const char*path,int len, 53struct untracked_cache_dir *untracked, 54int check_only,int stop_at_first_file,const struct pathspec *pathspec); 55static intget_dtype(struct dirent *de,struct index_state *istate, 56const char*path,int len); 57 58intcount_slashes(const char*s) 59{ 60int cnt =0; 61while(*s) 62if(*s++ =='/') 63 cnt++; 64return cnt; 65} 66 67intfspathcmp(const char*a,const char*b) 68{ 69return ignore_case ?strcasecmp(a, b) :strcmp(a, b); 70} 71 72intfspathncmp(const char*a,const char*b,size_t count) 73{ 74return ignore_case ?strncasecmp(a, b, count) :strncmp(a, b, count); 75} 76 77intgit_fnmatch(const struct pathspec_item *item, 78const char*pattern,const char*string, 79int prefix) 80{ 81if(prefix >0) { 82if(ps_strncmp(item, pattern, string, prefix)) 83return WM_NOMATCH; 84 pattern += prefix; 85 string += prefix; 86} 87if(item->flags & PATHSPEC_ONESTAR) { 88int pattern_len =strlen(++pattern); 89int string_len =strlen(string); 90return string_len < pattern_len || 91ps_strcmp(item, pattern, 92 string + string_len - pattern_len); 93} 94if(item->magic & PATHSPEC_GLOB) 95returnwildmatch(pattern, string, 96 WM_PATHNAME | 97(item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0)); 98else 99/* wildmatch has not learned no FNM_PATHNAME mode yet */ 100returnwildmatch(pattern, string, 101 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0); 102} 103 104static intfnmatch_icase_mem(const char*pattern,int patternlen, 105const char*string,int stringlen, 106int flags) 107{ 108int match_status; 109struct strbuf pat_buf = STRBUF_INIT; 110struct strbuf str_buf = STRBUF_INIT; 111const char*use_pat = pattern; 112const char*use_str = string; 113 114if(pattern[patternlen]) { 115strbuf_add(&pat_buf, pattern, patternlen); 116 use_pat = pat_buf.buf; 117} 118if(string[stringlen]) { 119strbuf_add(&str_buf, string, stringlen); 120 use_str = str_buf.buf; 121} 122 123if(ignore_case) 124 flags |= WM_CASEFOLD; 125 match_status =wildmatch(use_pat, use_str, flags); 126 127strbuf_release(&pat_buf); 128strbuf_release(&str_buf); 129 130return match_status; 131} 132 133static size_tcommon_prefix_len(const struct pathspec *pathspec) 134{ 135int n; 136size_t max =0; 137 138/* 139 * ":(icase)path" is treated as a pathspec full of 140 * wildcard. In other words, only prefix is considered common 141 * prefix. If the pathspec is abc/foo abc/bar, running in 142 * subdir xyz, the common prefix is still xyz, not xuz/abc as 143 * in non-:(icase). 144 */ 145GUARD_PATHSPEC(pathspec, 146 PATHSPEC_FROMTOP | 147 PATHSPEC_MAXDEPTH | 148 PATHSPEC_LITERAL | 149 PATHSPEC_GLOB | 150 PATHSPEC_ICASE | 151 PATHSPEC_EXCLUDE | 152 PATHSPEC_ATTR); 153 154for(n =0; n < pathspec->nr; n++) { 155size_t i =0, len =0, item_len; 156if(pathspec->items[n].magic & PATHSPEC_EXCLUDE) 157continue; 158if(pathspec->items[n].magic & PATHSPEC_ICASE) 159 item_len = pathspec->items[n].prefix; 160else 161 item_len = pathspec->items[n].nowildcard_len; 162while(i < item_len && (n ==0|| i < max)) { 163char c = pathspec->items[n].match[i]; 164if(c != pathspec->items[0].match[i]) 165break; 166if(c =='/') 167 len = i +1; 168 i++; 169} 170if(n ==0|| len < max) { 171 max = len; 172if(!max) 173break; 174} 175} 176return max; 177} 178 179/* 180 * Returns a copy of the longest leading path common among all 181 * pathspecs. 182 */ 183char*common_prefix(const struct pathspec *pathspec) 184{ 185unsigned long len =common_prefix_len(pathspec); 186 187return len ?xmemdupz(pathspec->items[0].match, len) : NULL; 188} 189 190intfill_directory(struct dir_struct *dir, 191struct index_state *istate, 192const struct pathspec *pathspec) 193{ 194const char*prefix; 195size_t prefix_len; 196 197/* 198 * Calculate common prefix for the pathspec, and 199 * use that to optimize the directory walk 200 */ 201 prefix_len =common_prefix_len(pathspec); 202 prefix = prefix_len ? pathspec->items[0].match :""; 203 204/* Read the directory and prune it */ 205read_directory(dir, istate, prefix, prefix_len, pathspec); 206 207return prefix_len; 208} 209 210intwithin_depth(const char*name,int namelen, 211int depth,int max_depth) 212{ 213const char*cp = name, *cpe = name + namelen; 214 215while(cp < cpe) { 216if(*cp++ !='/') 217continue; 218 depth++; 219if(depth > max_depth) 220return0; 221} 222return1; 223} 224 225/* 226 * Read the contents of the blob with the given OID into a buffer. 227 * Append a trailing LF to the end if the last line doesn't have one. 228 * 229 * Returns: 230 * -1 when the OID is invalid or unknown or does not refer to a blob. 231 * 0 when the blob is empty. 232 * 1 along with { data, size } of the (possibly augmented) buffer 233 * when successful. 234 * 235 * Optionally updates the given oid_stat with the given OID (when valid). 236 */ 237static intdo_read_blob(const struct object_id *oid,struct oid_stat *oid_stat, 238size_t*size_out,char**data_out) 239{ 240enum object_type type; 241unsigned long sz; 242char*data; 243 244*size_out =0; 245*data_out = NULL; 246 247 data =read_object_file(oid, &type, &sz); 248if(!data || type != OBJ_BLOB) { 249free(data); 250return-1; 251} 252 253if(oid_stat) { 254memset(&oid_stat->stat,0,sizeof(oid_stat->stat)); 255oidcpy(&oid_stat->oid, oid); 256} 257 258if(sz ==0) { 259free(data); 260return0; 261} 262 263if(data[sz -1] !='\n') { 264 data =xrealloc(data,st_add(sz,1)); 265 data[sz++] ='\n'; 266} 267 268*size_out =xsize_t(sz); 269*data_out = data; 270 271return1; 272} 273 274#define DO_MATCH_EXCLUDE (1<<0) 275#define DO_MATCH_DIRECTORY (1<<1) 276#define DO_MATCH_SUBMODULE (1<<2) 277 278/* 279 * Does 'match' match the given name? 280 * A match is found if 281 * 282 * (1) the 'match' string is leading directory of 'name', or 283 * (2) the 'match' string is a wildcard and matches 'name', or 284 * (3) the 'match' string is exactly the same as 'name'. 285 * 286 * and the return value tells which case it was. 287 * 288 * It returns 0 when there is no match. 289 */ 290static intmatch_pathspec_item(const struct index_state *istate, 291const struct pathspec_item *item,int prefix, 292const char*name,int namelen,unsigned flags) 293{ 294/* name/namelen has prefix cut off by caller */ 295const char*match = item->match + prefix; 296int matchlen = item->len - prefix; 297 298/* 299 * The normal call pattern is: 300 * 1. prefix = common_prefix_len(ps); 301 * 2. prune something, or fill_directory 302 * 3. match_pathspec() 303 * 304 * 'prefix' at #1 may be shorter than the command's prefix and 305 * it's ok for #2 to match extra files. Those extras will be 306 * trimmed at #3. 307 * 308 * Suppose the pathspec is 'foo' and '../bar' running from 309 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 310 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 311 * user does not want XYZ/foo, only the "foo" part should be 312 * case-insensitive. We need to filter out XYZ/foo here. In 313 * other words, we do not trust the caller on comparing the 314 * prefix part when :(icase) is involved. We do exact 315 * comparison ourselves. 316 * 317 * Normally the caller (common_prefix_len() in fact) does 318 * _exact_ matching on name[-prefix+1..-1] and we do not need 319 * to check that part. Be defensive and check it anyway, in 320 * case common_prefix_len is changed, or a new caller is 321 * introduced that does not use common_prefix_len. 322 * 323 * If the penalty turns out too high when prefix is really 324 * long, maybe change it to 325 * strncmp(match, name, item->prefix - prefix) 326 */ 327if(item->prefix && (item->magic & PATHSPEC_ICASE) && 328strncmp(item->match, name - prefix, item->prefix)) 329return0; 330 331if(item->attr_match_nr && 332!match_pathspec_attrs(istate, name, namelen, item)) 333return0; 334 335/* If the match was just the prefix, we matched */ 336if(!*match) 337return MATCHED_RECURSIVELY; 338 339if(matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 340if(matchlen == namelen) 341return MATCHED_EXACTLY; 342 343if(match[matchlen-1] =='/'|| name[matchlen] =='/') 344return MATCHED_RECURSIVELY; 345}else if((flags & DO_MATCH_DIRECTORY) && 346 match[matchlen -1] =='/'&& 347 namelen == matchlen -1&& 348!ps_strncmp(item, match, name, namelen)) 349return MATCHED_EXACTLY; 350 351if(item->nowildcard_len < item->len && 352!git_fnmatch(item, match, name, 353 item->nowildcard_len - prefix)) 354return MATCHED_FNMATCH; 355 356/* Perform checks to see if "name" is a super set of the pathspec */ 357if(flags & DO_MATCH_SUBMODULE) { 358/* name is a literal prefix of the pathspec */ 359if((namelen < matchlen) && 360(match[namelen] =='/') && 361!ps_strncmp(item, match, name, namelen)) 362return MATCHED_RECURSIVELY; 363 364/* name" doesn't match up to the first wild character */ 365if(item->nowildcard_len < item->len && 366ps_strncmp(item, match, name, 367 item->nowildcard_len - prefix)) 368return0; 369 370/* 371 * Here is where we would perform a wildmatch to check if 372 * "name" can be matched as a directory (or a prefix) against 373 * the pathspec. Since wildmatch doesn't have this capability 374 * at the present we have to punt and say that it is a match, 375 * potentially returning a false positive 376 * The submodules themselves will be able to perform more 377 * accurate matching to determine if the pathspec matches. 378 */ 379return MATCHED_RECURSIVELY; 380} 381 382return0; 383} 384 385/* 386 * Given a name and a list of pathspecs, returns the nature of the 387 * closest (i.e. most specific) match of the name to any of the 388 * pathspecs. 389 * 390 * The caller typically calls this multiple times with the same 391 * pathspec and seen[] array but with different name/namelen 392 * (e.g. entries from the index) and is interested in seeing if and 393 * how each pathspec matches all the names it calls this function 394 * with. A mark is left in the seen[] array for each pathspec element 395 * indicating the closest type of match that element achieved, so if 396 * seen[n] remains zero after multiple invocations, that means the nth 397 * pathspec did not match any names, which could indicate that the 398 * user mistyped the nth pathspec. 399 */ 400static intdo_match_pathspec(const struct index_state *istate, 401const struct pathspec *ps, 402const char*name,int namelen, 403int prefix,char*seen, 404unsigned flags) 405{ 406int i, retval =0, exclude = flags & DO_MATCH_EXCLUDE; 407 408GUARD_PATHSPEC(ps, 409 PATHSPEC_FROMTOP | 410 PATHSPEC_MAXDEPTH | 411 PATHSPEC_LITERAL | 412 PATHSPEC_GLOB | 413 PATHSPEC_ICASE | 414 PATHSPEC_EXCLUDE | 415 PATHSPEC_ATTR); 416 417if(!ps->nr) { 418if(!ps->recursive || 419!(ps->magic & PATHSPEC_MAXDEPTH) || 420 ps->max_depth == -1) 421return MATCHED_RECURSIVELY; 422 423if(within_depth(name, namelen,0, ps->max_depth)) 424return MATCHED_EXACTLY; 425else 426return0; 427} 428 429 name += prefix; 430 namelen -= prefix; 431 432for(i = ps->nr -1; i >=0; i--) { 433int how; 434 435if((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 436( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 437continue; 438 439if(seen && seen[i] == MATCHED_EXACTLY) 440continue; 441/* 442 * Make exclude patterns optional and never report 443 * "pathspec ':(exclude)foo' matches no files" 444 */ 445if(seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 446 seen[i] = MATCHED_FNMATCH; 447 how =match_pathspec_item(istate, ps->items+i, prefix, name, 448 namelen, flags); 449if(ps->recursive && 450(ps->magic & PATHSPEC_MAXDEPTH) && 451 ps->max_depth != -1&& 452 how && how != MATCHED_FNMATCH) { 453int len = ps->items[i].len; 454if(name[len] =='/') 455 len++; 456if(within_depth(name+len, namelen-len,0, ps->max_depth)) 457 how = MATCHED_EXACTLY; 458else 459 how =0; 460} 461if(how) { 462if(retval < how) 463 retval = how; 464if(seen && seen[i] < how) 465 seen[i] = how; 466} 467} 468return retval; 469} 470 471intmatch_pathspec(const struct index_state *istate, 472const struct pathspec *ps, 473const char*name,int namelen, 474int prefix,char*seen,int is_dir) 475{ 476int positive, negative; 477unsigned flags = is_dir ? DO_MATCH_DIRECTORY :0; 478 positive =do_match_pathspec(istate, ps, name, namelen, 479 prefix, seen, flags); 480if(!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 481return positive; 482 negative =do_match_pathspec(istate, ps, name, namelen, 483 prefix, seen, 484 flags | DO_MATCH_EXCLUDE); 485return negative ?0: positive; 486} 487 488/** 489 * Check if a submodule is a superset of the pathspec 490 */ 491intsubmodule_path_match(const struct index_state *istate, 492const struct pathspec *ps, 493const char*submodule_name, 494char*seen) 495{ 496int matched =do_match_pathspec(istate, ps, submodule_name, 497strlen(submodule_name), 4980, seen, 499 DO_MATCH_DIRECTORY | 500 DO_MATCH_SUBMODULE); 501return matched; 502} 503 504intreport_path_error(const char*ps_matched, 505const struct pathspec *pathspec) 506{ 507/* 508 * Make sure all pathspec matched; otherwise it is an error. 509 */ 510int num, errors =0; 511for(num =0; num < pathspec->nr; num++) { 512int other, found_dup; 513 514if(ps_matched[num]) 515continue; 516/* 517 * The caller might have fed identical pathspec 518 * twice. Do not barf on such a mistake. 519 * FIXME: parse_pathspec should have eliminated 520 * duplicate pathspec. 521 */ 522for(found_dup = other =0; 523!found_dup && other < pathspec->nr; 524 other++) { 525if(other == num || !ps_matched[other]) 526continue; 527if(!strcmp(pathspec->items[other].original, 528 pathspec->items[num].original)) 529/* 530 * Ok, we have a match already. 531 */ 532 found_dup =1; 533} 534if(found_dup) 535continue; 536 537error(_("pathspec '%s' did not match any file(s) known to git"), 538 pathspec->items[num].original); 539 errors++; 540} 541return errors; 542} 543 544/* 545 * Return the length of the "simple" part of a path match limiter. 546 */ 547intsimple_length(const char*match) 548{ 549int len = -1; 550 551for(;;) { 552unsigned char c = *match++; 553 len++; 554if(c =='\0'||is_glob_special(c)) 555return len; 556} 557} 558 559intno_wildcard(const char*string) 560{ 561return string[simple_length(string)] =='\0'; 562} 563 564voidparse_path_pattern(const char**pattern, 565int*patternlen, 566unsigned*flags, 567int*nowildcardlen) 568{ 569const char*p = *pattern; 570size_t i, len; 571 572*flags =0; 573if(*p =='!') { 574*flags |= PATTERN_FLAG_NEGATIVE; 575 p++; 576} 577 len =strlen(p); 578if(len && p[len -1] =='/') { 579 len--; 580*flags |= PATTERN_FLAG_MUSTBEDIR; 581} 582for(i =0; i < len; i++) { 583if(p[i] =='/') 584break; 585} 586if(i == len) 587*flags |= PATTERN_FLAG_NODIR; 588*nowildcardlen =simple_length(p); 589/* 590 * we should have excluded the trailing slash from 'p' too, 591 * but that's one more allocation. Instead just make sure 592 * nowildcardlen does not exceed real patternlen 593 */ 594if(*nowildcardlen > len) 595*nowildcardlen = len; 596if(*p =='*'&&no_wildcard(p +1)) 597*flags |= PATTERN_FLAG_ENDSWITH; 598*pattern = p; 599*patternlen = len; 600} 601 602voidadd_pattern(const char*string,const char*base, 603int baselen,struct pattern_list *pl,int srcpos) 604{ 605struct path_pattern *pattern; 606int patternlen; 607unsigned flags; 608int nowildcardlen; 609 610parse_path_pattern(&string, &patternlen, &flags, &nowildcardlen); 611if(flags & PATTERN_FLAG_MUSTBEDIR) { 612FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen); 613}else{ 614 pattern =xmalloc(sizeof(*pattern)); 615 pattern->pattern = string; 616} 617 pattern->patternlen = patternlen; 618 pattern->nowildcardlen = nowildcardlen; 619 pattern->base = base; 620 pattern->baselen = baselen; 621 pattern->flags = flags; 622 pattern->srcpos = srcpos; 623ALLOC_GROW(pl->patterns, pl->nr +1, pl->alloc); 624 pl->patterns[pl->nr++] = pattern; 625 pattern->pl = pl; 626} 627 628static intread_skip_worktree_file_from_index(const struct index_state *istate, 629const char*path, 630size_t*size_out,char**data_out, 631struct oid_stat *oid_stat) 632{ 633int pos, len; 634 635 len =strlen(path); 636 pos =index_name_pos(istate, path, len); 637if(pos <0) 638return-1; 639if(!ce_skip_worktree(istate->cache[pos])) 640return-1; 641 642returndo_read_blob(&istate->cache[pos]->oid, oid_stat, size_out, data_out); 643} 644 645/* 646 * Frees memory within pl which was allocated for exclude patterns and 647 * the file buffer. Does not free pl itself. 648 */ 649voidclear_pattern_list(struct pattern_list *pl) 650{ 651int i; 652 653for(i =0; i < pl->nr; i++) 654free(pl->patterns[i]); 655free(pl->patterns); 656free(pl->filebuf); 657 658memset(pl,0,sizeof(*pl)); 659} 660 661static voidtrim_trailing_spaces(char*buf) 662{ 663char*p, *last_space = NULL; 664 665for(p = buf; *p; p++) 666switch(*p) { 667case' ': 668if(!last_space) 669 last_space = p; 670break; 671case'\\': 672 p++; 673if(!*p) 674return; 675/* fallthrough */ 676default: 677 last_space = NULL; 678} 679 680if(last_space) 681*last_space ='\0'; 682} 683 684/* 685 * Given a subdirectory name and "dir" of the current directory, 686 * search the subdir in "dir" and return it, or create a new one if it 687 * does not exist in "dir". 688 * 689 * If "name" has the trailing slash, it'll be excluded in the search. 690 */ 691static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 692struct untracked_cache_dir *dir, 693const char*name,int len) 694{ 695int first, last; 696struct untracked_cache_dir *d; 697if(!dir) 698return NULL; 699if(len && name[len -1] =='/') 700 len--; 701 first =0; 702 last = dir->dirs_nr; 703while(last > first) { 704int cmp, next = first + ((last - first) >>1); 705 d = dir->dirs[next]; 706 cmp =strncmp(name, d->name, len); 707if(!cmp &&strlen(d->name) > len) 708 cmp = -1; 709if(!cmp) 710return d; 711if(cmp <0) { 712 last = next; 713continue; 714} 715 first = next+1; 716} 717 718 uc->dir_created++; 719FLEX_ALLOC_MEM(d, name, name, len); 720 721ALLOC_GROW(dir->dirs, dir->dirs_nr +1, dir->dirs_alloc); 722MOVE_ARRAY(dir->dirs + first +1, dir->dirs + first, 723 dir->dirs_nr - first); 724 dir->dirs_nr++; 725 dir->dirs[first] = d; 726return d; 727} 728 729static voiddo_invalidate_gitignore(struct untracked_cache_dir *dir) 730{ 731int i; 732 dir->valid =0; 733 dir->untracked_nr =0; 734for(i =0; i < dir->dirs_nr; i++) 735do_invalidate_gitignore(dir->dirs[i]); 736} 737 738static voidinvalidate_gitignore(struct untracked_cache *uc, 739struct untracked_cache_dir *dir) 740{ 741 uc->gitignore_invalidated++; 742do_invalidate_gitignore(dir); 743} 744 745static voidinvalidate_directory(struct untracked_cache *uc, 746struct untracked_cache_dir *dir) 747{ 748int i; 749 750/* 751 * Invalidation increment here is just roughly correct. If 752 * untracked_nr or any of dirs[].recurse is non-zero, we 753 * should increment dir_invalidated too. But that's more 754 * expensive to do. 755 */ 756if(dir->valid) 757 uc->dir_invalidated++; 758 759 dir->valid =0; 760 dir->untracked_nr =0; 761for(i =0; i < dir->dirs_nr; i++) 762 dir->dirs[i]->recurse =0; 763} 764 765static intadd_patterns_from_buffer(char*buf,size_t size, 766const char*base,int baselen, 767struct pattern_list *pl); 768 769/* 770 * Given a file with name "fname", read it (either from disk, or from 771 * an index if 'istate' is non-null), parse it and store the 772 * exclude rules in "pl". 773 * 774 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 775 * stat data from disk (only valid if add_patterns returns zero). If 776 * ss_valid is non-zero, "ss" must contain good value as input. 777 */ 778static intadd_patterns(const char*fname,const char*base,int baselen, 779struct pattern_list *pl,struct index_state *istate, 780struct oid_stat *oid_stat) 781{ 782struct stat st; 783int r; 784int fd; 785size_t size =0; 786char*buf; 787 788 fd =open(fname, O_RDONLY); 789if(fd <0||fstat(fd, &st) <0) { 790if(fd <0) 791warn_on_fopen_errors(fname); 792else 793close(fd); 794if(!istate) 795return-1; 796 r =read_skip_worktree_file_from_index(istate, fname, 797&size, &buf, 798 oid_stat); 799if(r !=1) 800return r; 801}else{ 802 size =xsize_t(st.st_size); 803if(size ==0) { 804if(oid_stat) { 805fill_stat_data(&oid_stat->stat, &st); 806oidcpy(&oid_stat->oid, the_hash_algo->empty_blob); 807 oid_stat->valid =1; 808} 809close(fd); 810return0; 811} 812 buf =xmallocz(size); 813if(read_in_full(fd, buf, size) != size) { 814free(buf); 815close(fd); 816return-1; 817} 818 buf[size++] ='\n'; 819close(fd); 820if(oid_stat) { 821int pos; 822if(oid_stat->valid && 823!match_stat_data_racy(istate, &oid_stat->stat, &st)) 824;/* no content change, ss->sha1 still good */ 825else if(istate && 826(pos =index_name_pos(istate, fname,strlen(fname))) >=0&& 827!ce_stage(istate->cache[pos]) && 828ce_uptodate(istate->cache[pos]) && 829!would_convert_to_git(istate, fname)) 830oidcpy(&oid_stat->oid, 831&istate->cache[pos]->oid); 832else 833hash_object_file(buf, size,"blob", 834&oid_stat->oid); 835fill_stat_data(&oid_stat->stat, &st); 836 oid_stat->valid =1; 837} 838} 839 840add_patterns_from_buffer(buf, size, base, baselen, pl); 841return0; 842} 843 844static intadd_patterns_from_buffer(char*buf,size_t size, 845const char*base,int baselen, 846struct pattern_list *pl) 847{ 848int i, lineno =1; 849char*entry; 850 851 pl->filebuf = buf; 852 853if(skip_utf8_bom(&buf, size)) 854 size -= buf - pl->filebuf; 855 856 entry = buf; 857 858for(i =0; i < size; i++) { 859if(buf[i] =='\n') { 860if(entry != buf + i && entry[0] !='#') { 861 buf[i - (i && buf[i-1] =='\r')] =0; 862trim_trailing_spaces(entry); 863add_pattern(entry, base, baselen, pl, lineno); 864} 865 lineno++; 866 entry = buf + i +1; 867} 868} 869return0; 870} 871 872intadd_patterns_from_file_to_list(const char*fname,const char*base, 873int baselen,struct pattern_list *pl, 874struct index_state *istate) 875{ 876returnadd_patterns(fname, base, baselen, pl, istate, NULL); 877} 878 879intadd_patterns_from_blob_to_list( 880struct object_id *oid, 881const char*base,int baselen, 882struct pattern_list *pl) 883{ 884char*buf; 885size_t size; 886int r; 887 888 r =do_read_blob(oid, NULL, &size, &buf); 889if(r !=1) 890return r; 891 892add_patterns_from_buffer(buf, size, base, baselen, pl); 893return0; 894} 895 896struct pattern_list *add_pattern_list(struct dir_struct *dir, 897int group_type,const char*src) 898{ 899struct pattern_list *pl; 900struct exclude_list_group *group; 901 902 group = &dir->exclude_list_group[group_type]; 903ALLOC_GROW(group->pl, group->nr +1, group->alloc); 904 pl = &group->pl[group->nr++]; 905memset(pl,0,sizeof(*pl)); 906 pl->src = src; 907return pl; 908} 909 910/* 911 * Used to set up core.excludesfile and .git/info/exclude lists. 912 */ 913static voidadd_patterns_from_file_1(struct dir_struct *dir,const char*fname, 914struct oid_stat *oid_stat) 915{ 916struct pattern_list *pl; 917/* 918 * catch setup_standard_excludes() that's called before 919 * dir->untracked is assigned. That function behaves 920 * differently when dir->untracked is non-NULL. 921 */ 922if(!dir->untracked) 923 dir->unmanaged_exclude_files++; 924 pl =add_pattern_list(dir, EXC_FILE, fname); 925if(add_patterns(fname,"",0, pl, NULL, oid_stat) <0) 926die(_("cannot use%sas an exclude file"), fname); 927} 928 929voidadd_patterns_from_file(struct dir_struct *dir,const char*fname) 930{ 931 dir->unmanaged_exclude_files++;/* see validate_untracked_cache() */ 932add_patterns_from_file_1(dir, fname, NULL); 933} 934 935intmatch_basename(const char*basename,int basenamelen, 936const char*pattern,int prefix,int patternlen, 937unsigned flags) 938{ 939if(prefix == patternlen) { 940if(patternlen == basenamelen && 941!fspathncmp(pattern, basename, basenamelen)) 942return1; 943}else if(flags & PATTERN_FLAG_ENDSWITH) { 944/* "*literal" matching against "fooliteral" */ 945if(patternlen -1<= basenamelen && 946!fspathncmp(pattern +1, 947 basename + basenamelen - (patternlen -1), 948 patternlen -1)) 949return1; 950}else{ 951if(fnmatch_icase_mem(pattern, patternlen, 952 basename, basenamelen, 9530) ==0) 954return1; 955} 956return0; 957} 958 959intmatch_pathname(const char*pathname,int pathlen, 960const char*base,int baselen, 961const char*pattern,int prefix,int patternlen, 962unsigned flags) 963{ 964const char*name; 965int namelen; 966 967/* 968 * match with FNM_PATHNAME; the pattern has base implicitly 969 * in front of it. 970 */ 971if(*pattern =='/') { 972 pattern++; 973 patternlen--; 974 prefix--; 975} 976 977/* 978 * baselen does not count the trailing slash. base[] may or 979 * may not end with a trailing slash though. 980 */ 981if(pathlen < baselen +1|| 982(baselen && pathname[baselen] !='/') || 983fspathncmp(pathname, base, baselen)) 984return0; 985 986 namelen = baselen ? pathlen - baselen -1: pathlen; 987 name = pathname + pathlen - namelen; 988 989if(prefix) { 990/* 991 * if the non-wildcard part is longer than the 992 * remaining pathname, surely it cannot match. 993 */ 994if(prefix > namelen) 995return0; 996 997if(fspathncmp(pattern, name, prefix)) 998return0; 999 pattern += prefix;1000 patternlen -= prefix;1001 name += prefix;1002 namelen -= prefix;10031004/*1005 * If the whole pattern did not have a wildcard,1006 * then our prefix match is all we need; we1007 * do not need to call fnmatch at all.1008 */1009if(!patternlen && !namelen)1010return1;1011}10121013returnfnmatch_icase_mem(pattern, patternlen,1014 name, namelen,1015 WM_PATHNAME) ==0;1016}10171018/*1019 * Scan the given exclude list in reverse to see whether pathname1020 * should be ignored. The first match (i.e. the last on the list), if1021 * any, determines the fate. Returns the exclude_list element which1022 * matched, or NULL for undecided.1023 */1024static struct path_pattern *last_matching_pattern_from_list(const char*pathname,1025int pathlen,1026const char*basename,1027int*dtype,1028struct pattern_list *pl,1029struct index_state *istate)1030{1031struct path_pattern *res = NULL;/* undecided */1032int i;10331034if(!pl->nr)1035return NULL;/* undefined */10361037for(i = pl->nr -1;0<= i; i--) {1038struct path_pattern *pattern = pl->patterns[i];1039const char*exclude = pattern->pattern;1040int prefix = pattern->nowildcardlen;10411042if(pattern->flags & PATTERN_FLAG_MUSTBEDIR) {1043if(*dtype == DT_UNKNOWN)1044*dtype =get_dtype(NULL, istate, pathname, pathlen);1045if(*dtype != DT_DIR)1046continue;1047}10481049if(pattern->flags & PATTERN_FLAG_NODIR) {1050if(match_basename(basename,1051 pathlen - (basename - pathname),1052 exclude, prefix, pattern->patternlen,1053 pattern->flags)) {1054 res = pattern;1055break;1056}1057continue;1058}10591060assert(pattern->baselen ==0||1061 pattern->base[pattern->baselen -1] =='/');1062if(match_pathname(pathname, pathlen,1063 pattern->base,1064 pattern->baselen ? pattern->baselen -1:0,1065 exclude, prefix, pattern->patternlen,1066 pattern->flags)) {1067 res = pattern;1068break;1069}1070}1071return res;1072}10731074/*1075 * Scan the list of patterns to determine if the ordered list1076 * of patterns matches on 'pathname'.1077 *1078 * Return 1 for a match, 0 for not matched and -1 for undecided.1079 */1080enum pattern_match_result path_matches_pattern_list(1081const char*pathname,int pathlen,1082const char*basename,int*dtype,1083struct pattern_list *pl,1084struct index_state *istate)1085{1086struct path_pattern *pattern;1087 pattern =last_matching_pattern_from_list(pathname, pathlen, basename,1088 dtype, pl, istate);1089if(pattern) {1090if(pattern->flags & PATTERN_FLAG_NEGATIVE)1091return NOT_MATCHED;1092else1093return MATCHED;1094}10951096return UNDECIDED;1097}10981099static struct path_pattern *last_matching_pattern_from_lists(1100struct dir_struct *dir,struct index_state *istate,1101const char*pathname,int pathlen,1102const char*basename,int*dtype_p)1103{1104int i, j;1105struct exclude_list_group *group;1106struct path_pattern *pattern;1107for(i = EXC_CMDL; i <= EXC_FILE; i++) {1108 group = &dir->exclude_list_group[i];1109for(j = group->nr -1; j >=0; j--) {1110 pattern =last_matching_pattern_from_list(1111 pathname, pathlen, basename, dtype_p,1112&group->pl[j], istate);1113if(pattern)1114return pattern;1115}1116}1117return NULL;1118}11191120/*1121 * Loads the per-directory exclude list for the substring of base1122 * which has a char length of baselen.1123 */1124static voidprep_exclude(struct dir_struct *dir,1125struct index_state *istate,1126const char*base,int baselen)1127{1128struct exclude_list_group *group;1129struct pattern_list *pl;1130struct exclude_stack *stk = NULL;1131struct untracked_cache_dir *untracked;1132int current;11331134 group = &dir->exclude_list_group[EXC_DIRS];11351136/*1137 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1138 * which originate from directories not in the prefix of the1139 * path being checked.1140 */1141while((stk = dir->exclude_stack) != NULL) {1142if(stk->baselen <= baselen &&1143!strncmp(dir->basebuf.buf, base, stk->baselen))1144break;1145 pl = &group->pl[dir->exclude_stack->exclude_ix];1146 dir->exclude_stack = stk->prev;1147 dir->pattern = NULL;1148free((char*)pl->src);/* see strbuf_detach() below */1149clear_pattern_list(pl);1150free(stk);1151 group->nr--;1152}11531154/* Skip traversing into sub directories if the parent is excluded */1155if(dir->pattern)1156return;11571158/*1159 * Lazy initialization. All call sites currently just1160 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1161 * them seems lots of work for little benefit.1162 */1163if(!dir->basebuf.buf)1164strbuf_init(&dir->basebuf, PATH_MAX);11651166/* Read from the parent directories and push them down. */1167 current = stk ? stk->baselen : -1;1168strbuf_setlen(&dir->basebuf, current <0?0: current);1169if(dir->untracked)1170 untracked = stk ? stk->ucd : dir->untracked->root;1171else1172 untracked = NULL;11731174while(current < baselen) {1175const char*cp;1176struct oid_stat oid_stat;11771178 stk =xcalloc(1,sizeof(*stk));1179if(current <0) {1180 cp = base;1181 current =0;1182}else{1183 cp =strchr(base + current +1,'/');1184if(!cp)1185die("oops in prep_exclude");1186 cp++;1187 untracked =1188lookup_untracked(dir->untracked, untracked,1189 base + current,1190 cp - base - current);1191}1192 stk->prev = dir->exclude_stack;1193 stk->baselen = cp - base;1194 stk->exclude_ix = group->nr;1195 stk->ucd = untracked;1196 pl =add_pattern_list(dir, EXC_DIRS, NULL);1197strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1198assert(stk->baselen == dir->basebuf.len);11991200/* Abort if the directory is excluded */1201if(stk->baselen) {1202int dt = DT_DIR;1203 dir->basebuf.buf[stk->baselen -1] =0;1204 dir->pattern =last_matching_pattern_from_lists(dir,1205 istate,1206 dir->basebuf.buf, stk->baselen -1,1207 dir->basebuf.buf + current, &dt);1208 dir->basebuf.buf[stk->baselen -1] ='/';1209if(dir->pattern &&1210 dir->pattern->flags & PATTERN_FLAG_NEGATIVE)1211 dir->pattern = NULL;1212if(dir->pattern) {1213 dir->exclude_stack = stk;1214return;1215}1216}12171218/* Try to read per-directory file */1219oidclr(&oid_stat.oid);1220 oid_stat.valid =0;1221if(dir->exclude_per_dir &&1222/*1223 * If we know that no files have been added in1224 * this directory (i.e. valid_cached_dir() has1225 * been executed and set untracked->valid) ..1226 */1227(!untracked || !untracked->valid ||1228/*1229 * .. and .gitignore does not exist before1230 * (i.e. null exclude_oid). Then we can skip1231 * loading .gitignore, which would result in1232 * ENOENT anyway.1233 */1234!is_null_oid(&untracked->exclude_oid))) {1235/*1236 * dir->basebuf gets reused by the traversal, but we1237 * need fname to remain unchanged to ensure the src1238 * member of each struct path_pattern correctly1239 * back-references its source file. Other invocations1240 * of add_pattern_list provide stable strings, so we1241 * strbuf_detach() and free() here in the caller.1242 */1243struct strbuf sb = STRBUF_INIT;1244strbuf_addbuf(&sb, &dir->basebuf);1245strbuf_addstr(&sb, dir->exclude_per_dir);1246 pl->src =strbuf_detach(&sb, NULL);1247add_patterns(pl->src, pl->src, stk->baselen, pl, istate,1248 untracked ? &oid_stat : NULL);1249}1250/*1251 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1252 * will first be called in valid_cached_dir() then maybe many1253 * times more in last_matching_pattern(). When the cache is1254 * used, last_matching_pattern() will not be called and1255 * reading .gitignore content will be a waste.1256 *1257 * So when it's called by valid_cached_dir() and we can get1258 * .gitignore SHA-1 from the index (i.e. .gitignore is not1259 * modified on work tree), we could delay reading the1260 * .gitignore content until we absolutely need it in1261 * last_matching_pattern(). Be careful about ignore rule1262 * order, though, if you do that.1263 */1264if(untracked &&1265!oideq(&oid_stat.oid, &untracked->exclude_oid)) {1266invalidate_gitignore(dir->untracked, untracked);1267oidcpy(&untracked->exclude_oid, &oid_stat.oid);1268}1269 dir->exclude_stack = stk;1270 current = stk->baselen;1271}1272strbuf_setlen(&dir->basebuf, baselen);1273}12741275/*1276 * Loads the exclude lists for the directory containing pathname, then1277 * scans all exclude lists to determine whether pathname is excluded.1278 * Returns the exclude_list element which matched, or NULL for1279 * undecided.1280 */1281struct path_pattern *last_matching_pattern(struct dir_struct *dir,1282struct index_state *istate,1283const char*pathname,1284int*dtype_p)1285{1286int pathlen =strlen(pathname);1287const char*basename =strrchr(pathname,'/');1288 basename = (basename) ? basename+1: pathname;12891290prep_exclude(dir, istate, pathname, basename-pathname);12911292if(dir->pattern)1293return dir->pattern;12941295returnlast_matching_pattern_from_lists(dir, istate, pathname, pathlen,1296 basename, dtype_p);1297}12981299/*1300 * Loads the exclude lists for the directory containing pathname, then1301 * scans all exclude lists to determine whether pathname is excluded.1302 * Returns 1 if true, otherwise 0.1303 */1304intis_excluded(struct dir_struct *dir,struct index_state *istate,1305const char*pathname,int*dtype_p)1306{1307struct path_pattern *pattern =1308last_matching_pattern(dir, istate, pathname, dtype_p);1309if(pattern)1310return pattern->flags & PATTERN_FLAG_NEGATIVE ?0:1;1311return0;1312}13131314static struct dir_entry *dir_entry_new(const char*pathname,int len)1315{1316struct dir_entry *ent;13171318FLEX_ALLOC_MEM(ent, name, pathname, len);1319 ent->len = len;1320return ent;1321}13221323static struct dir_entry *dir_add_name(struct dir_struct *dir,1324struct index_state *istate,1325const char*pathname,int len)1326{1327if(index_file_exists(istate, pathname, len, ignore_case))1328return NULL;13291330ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1331return dir->entries[dir->nr++] =dir_entry_new(pathname, len);1332}13331334struct dir_entry *dir_add_ignored(struct dir_struct *dir,1335struct index_state *istate,1336const char*pathname,int len)1337{1338if(!index_name_is_other(istate, pathname, len))1339return NULL;13401341ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1342return dir->ignored[dir->ignored_nr++] =dir_entry_new(pathname, len);1343}13441345enum exist_status {1346 index_nonexistent =0,1347 index_directory,1348 index_gitdir1349};13501351/*1352 * Do not use the alphabetically sorted index to look up1353 * the directory name; instead, use the case insensitive1354 * directory hash.1355 */1356static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1357const char*dirname,int len)1358{1359struct cache_entry *ce;13601361if(index_dir_exists(istate, dirname, len))1362return index_directory;13631364 ce =index_file_exists(istate, dirname, len, ignore_case);1365if(ce &&S_ISGITLINK(ce->ce_mode))1366return index_gitdir;13671368return index_nonexistent;1369}13701371/*1372 * The index sorts alphabetically by entry name, which1373 * means that a gitlink sorts as '\0' at the end, while1374 * a directory (which is defined not as an entry, but as1375 * the files it contains) will sort with the '/' at the1376 * end.1377 */1378static enum exist_status directory_exists_in_index(struct index_state *istate,1379const char*dirname,int len)1380{1381int pos;13821383if(ignore_case)1384returndirectory_exists_in_index_icase(istate, dirname, len);13851386 pos =index_name_pos(istate, dirname, len);1387if(pos <0)1388 pos = -pos-1;1389while(pos < istate->cache_nr) {1390const struct cache_entry *ce = istate->cache[pos++];1391unsigned char endchar;13921393if(strncmp(ce->name, dirname, len))1394break;1395 endchar = ce->name[len];1396if(endchar >'/')1397break;1398if(endchar =='/')1399return index_directory;1400if(!endchar &&S_ISGITLINK(ce->ce_mode))1401return index_gitdir;1402}1403return index_nonexistent;1404}14051406/*1407 * When we find a directory when traversing the filesystem, we1408 * have three distinct cases:1409 *1410 * - ignore it1411 * - see it as a directory1412 * - recurse into it1413 *1414 * and which one we choose depends on a combination of existing1415 * git index contents and the flags passed into the directory1416 * traversal routine.1417 *1418 * Case 1: If we *already* have entries in the index under that1419 * directory name, we always recurse into the directory to see1420 * all the files.1421 *1422 * Case 2: If we *already* have that directory name as a gitlink,1423 * we always continue to see it as a gitlink, regardless of whether1424 * there is an actual git directory there or not (it might not1425 * be checked out as a subproject!)1426 *1427 * Case 3: if we didn't have it in the index previously, we1428 * have a few sub-cases:1429 *1430 * (a) if "show_other_directories" is true, we show it as1431 * just a directory, unless "hide_empty_directories" is1432 * also true, in which case we need to check if it contains any1433 * untracked and / or ignored files.1434 * (b) if it looks like a git directory, and we don't have1435 * 'no_gitlinks' set we treat it as a gitlink, and show it1436 * as a directory.1437 * (c) otherwise, we recurse into it.1438 */1439static enum path_treatment treat_directory(struct dir_struct *dir,1440struct index_state *istate,1441struct untracked_cache_dir *untracked,1442const char*dirname,int len,int baselen,int exclude,1443const struct pathspec *pathspec)1444{1445/* The "len-1" is to strip the final '/' */1446switch(directory_exists_in_index(istate, dirname, len-1)) {1447case index_directory:1448return path_recurse;14491450case index_gitdir:1451return path_none;14521453case index_nonexistent:1454if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1455break;1456if(exclude &&1457(dir->flags & DIR_SHOW_IGNORED_TOO) &&1458(dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING)) {14591460/*1461 * This is an excluded directory and we are1462 * showing ignored paths that match an exclude1463 * pattern. (e.g. show directory as ignored1464 * only if it matches an exclude pattern).1465 * This path will either be 'path_excluded`1466 * (if we are showing empty directories or if1467 * the directory is not empty), or will be1468 * 'path_none' (empty directory, and we are1469 * not showing empty directories).1470 */1471if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1472return path_excluded;14731474if(read_directory_recursive(dir, istate, dirname, len,1475 untracked,1,1, pathspec) == path_excluded)1476return path_excluded;14771478return path_none;1479}1480if(!(dir->flags & DIR_NO_GITLINKS)) {1481struct strbuf sb = STRBUF_INIT;1482strbuf_addstr(&sb, dirname);1483if(is_nonbare_repository_dir(&sb))1484return exclude ? path_excluded : path_untracked;1485strbuf_release(&sb);1486}1487return path_recurse;1488}14891490/* This is the "show_other_directories" case */14911492if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1493return exclude ? path_excluded : path_untracked;14941495 untracked =lookup_untracked(dir->untracked, untracked,1496 dirname + baselen, len - baselen);14971498/*1499 * If this is an excluded directory, then we only need to check if1500 * the directory contains any files.1501 */1502returnread_directory_recursive(dir, istate, dirname, len,1503 untracked,1, exclude, pathspec);1504}15051506/*1507 * This is an inexact early pruning of any recursive directory1508 * reading - if the path cannot possibly be in the pathspec,1509 * return true, and we'll skip it early.1510 */1511static intsimplify_away(const char*path,int pathlen,1512const struct pathspec *pathspec)1513{1514int i;15151516if(!pathspec || !pathspec->nr)1517return0;15181519GUARD_PATHSPEC(pathspec,1520 PATHSPEC_FROMTOP |1521 PATHSPEC_MAXDEPTH |1522 PATHSPEC_LITERAL |1523 PATHSPEC_GLOB |1524 PATHSPEC_ICASE |1525 PATHSPEC_EXCLUDE |1526 PATHSPEC_ATTR);15271528for(i =0; i < pathspec->nr; i++) {1529const struct pathspec_item *item = &pathspec->items[i];1530int len = item->nowildcard_len;15311532if(len > pathlen)1533 len = pathlen;1534if(!ps_strncmp(item, item->match, path, len))1535return0;1536}15371538return1;1539}15401541/*1542 * This function tells us whether an excluded path matches a1543 * list of "interesting" pathspecs. That is, whether a path matched1544 * by any of the pathspecs could possibly be ignored by excluding1545 * the specified path. This can happen if:1546 *1547 * 1. the path is mentioned explicitly in the pathspec1548 *1549 * 2. the path is a directory prefix of some element in the1550 * pathspec1551 */1552static intexclude_matches_pathspec(const char*path,int pathlen,1553const struct pathspec *pathspec)1554{1555int i;15561557if(!pathspec || !pathspec->nr)1558return0;15591560GUARD_PATHSPEC(pathspec,1561 PATHSPEC_FROMTOP |1562 PATHSPEC_MAXDEPTH |1563 PATHSPEC_LITERAL |1564 PATHSPEC_GLOB |1565 PATHSPEC_ICASE |1566 PATHSPEC_EXCLUDE);15671568for(i =0; i < pathspec->nr; i++) {1569const struct pathspec_item *item = &pathspec->items[i];1570int len = item->nowildcard_len;15711572if(len == pathlen &&1573!ps_strncmp(item, item->match, path, pathlen))1574return1;1575if(len > pathlen &&1576 item->match[pathlen] =='/'&&1577!ps_strncmp(item, item->match, path, pathlen))1578return1;1579}1580return0;1581}15821583static intget_index_dtype(struct index_state *istate,1584const char*path,int len)1585{1586int pos;1587const struct cache_entry *ce;15881589 ce =index_file_exists(istate, path, len,0);1590if(ce) {1591if(!ce_uptodate(ce))1592return DT_UNKNOWN;1593if(S_ISGITLINK(ce->ce_mode))1594return DT_DIR;1595/*1596 * Nobody actually cares about the1597 * difference between DT_LNK and DT_REG1598 */1599return DT_REG;1600}16011602/* Try to look it up as a directory */1603 pos =index_name_pos(istate, path, len);1604if(pos >=0)1605return DT_UNKNOWN;1606 pos = -pos-1;1607while(pos < istate->cache_nr) {1608 ce = istate->cache[pos++];1609if(strncmp(ce->name, path, len))1610break;1611if(ce->name[len] >'/')1612break;1613if(ce->name[len] <'/')1614continue;1615if(!ce_uptodate(ce))1616break;/* continue? */1617return DT_DIR;1618}1619return DT_UNKNOWN;1620}16211622static intget_dtype(struct dirent *de,struct index_state *istate,1623const char*path,int len)1624{1625int dtype = de ?DTYPE(de) : DT_UNKNOWN;1626struct stat st;16271628if(dtype != DT_UNKNOWN)1629return dtype;1630 dtype =get_index_dtype(istate, path, len);1631if(dtype != DT_UNKNOWN)1632return dtype;1633if(lstat(path, &st))1634return dtype;1635if(S_ISREG(st.st_mode))1636return DT_REG;1637if(S_ISDIR(st.st_mode))1638return DT_DIR;1639if(S_ISLNK(st.st_mode))1640return DT_LNK;1641return dtype;1642}16431644static enum path_treatment treat_one_path(struct dir_struct *dir,1645struct untracked_cache_dir *untracked,1646struct index_state *istate,1647struct strbuf *path,1648int baselen,1649const struct pathspec *pathspec,1650int dtype,struct dirent *de)1651{1652int exclude;1653int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);1654enum path_treatment path_treatment;16551656if(dtype == DT_UNKNOWN)1657 dtype =get_dtype(de, istate, path->buf, path->len);16581659/* Always exclude indexed files */1660if(dtype != DT_DIR && has_path_in_index)1661return path_none;16621663/*1664 * When we are looking at a directory P in the working tree,1665 * there are three cases:1666 *1667 * (1) P exists in the index. Everything inside the directory P in1668 * the working tree needs to go when P is checked out from the1669 * index.1670 *1671 * (2) P does not exist in the index, but there is P/Q in the index.1672 * We know P will stay a directory when we check out the contents1673 * of the index, but we do not know yet if there is a directory1674 * P/Q in the working tree to be killed, so we need to recurse.1675 *1676 * (3) P does not exist in the index, and there is no P/Q in the index1677 * to require P to be a directory, either. Only in this case, we1678 * know that everything inside P will not be killed without1679 * recursing.1680 */1681if((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1682(dtype == DT_DIR) &&1683!has_path_in_index &&1684(directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))1685return path_none;16861687 exclude =is_excluded(dir, istate, path->buf, &dtype);16881689/*1690 * Excluded? If we don't explicitly want to show1691 * ignored files, ignore it1692 */1693if(exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1694return path_excluded;16951696switch(dtype) {1697default:1698return path_none;1699case DT_DIR:1700strbuf_addch(path,'/');1701 path_treatment =treat_directory(dir, istate, untracked,1702 path->buf, path->len,1703 baselen, exclude, pathspec);1704/*1705 * If 1) we only want to return directories that1706 * match an exclude pattern and 2) this directory does1707 * not match an exclude pattern but all of its1708 * contents are excluded, then indicate that we should1709 * recurse into this directory (instead of marking the1710 * directory itself as an ignored path).1711 */1712if(!exclude &&1713 path_treatment == path_excluded &&1714(dir->flags & DIR_SHOW_IGNORED_TOO) &&1715(dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING))1716return path_recurse;1717return path_treatment;1718case DT_REG:1719case DT_LNK:1720return exclude ? path_excluded : path_untracked;1721}1722}17231724static enum path_treatment treat_path_fast(struct dir_struct *dir,1725struct untracked_cache_dir *untracked,1726struct cached_dir *cdir,1727struct index_state *istate,1728struct strbuf *path,1729int baselen,1730const struct pathspec *pathspec)1731{1732strbuf_setlen(path, baselen);1733if(!cdir->ucd) {1734strbuf_addstr(path, cdir->file);1735return path_untracked;1736}1737strbuf_addstr(path, cdir->ucd->name);1738/* treat_one_path() does this before it calls treat_directory() */1739strbuf_complete(path,'/');1740if(cdir->ucd->check_only)1741/*1742 * check_only is set as a result of treat_directory() getting1743 * to its bottom. Verify again the same set of directories1744 * with check_only set.1745 */1746returnread_directory_recursive(dir, istate, path->buf, path->len,1747 cdir->ucd,1,0, pathspec);1748/*1749 * We get path_recurse in the first run when1750 * directory_exists_in_index() returns index_nonexistent. We1751 * are sure that new changes in the index does not impact the1752 * outcome. Return now.1753 */1754return path_recurse;1755}17561757static enum path_treatment treat_path(struct dir_struct *dir,1758struct untracked_cache_dir *untracked,1759struct cached_dir *cdir,1760struct index_state *istate,1761struct strbuf *path,1762int baselen,1763const struct pathspec *pathspec)1764{1765int dtype;1766struct dirent *de = cdir->de;17671768if(!de)1769returntreat_path_fast(dir, untracked, cdir, istate, path,1770 baselen, pathspec);1771if(is_dot_or_dotdot(de->d_name) || !fspathcmp(de->d_name,".git"))1772return path_none;1773strbuf_setlen(path, baselen);1774strbuf_addstr(path, de->d_name);1775if(simplify_away(path->buf, path->len, pathspec))1776return path_none;17771778 dtype =DTYPE(de);1779returntreat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1780}17811782static voidadd_untracked(struct untracked_cache_dir *dir,const char*name)1783{1784if(!dir)1785return;1786ALLOC_GROW(dir->untracked, dir->untracked_nr +1,1787 dir->untracked_alloc);1788 dir->untracked[dir->untracked_nr++] =xstrdup(name);1789}17901791static intvalid_cached_dir(struct dir_struct *dir,1792struct untracked_cache_dir *untracked,1793struct index_state *istate,1794struct strbuf *path,1795int check_only)1796{1797struct stat st;17981799if(!untracked)1800return0;18011802/*1803 * With fsmonitor, we can trust the untracked cache's valid field.1804 */1805refresh_fsmonitor(istate);1806if(!(dir->untracked->use_fsmonitor && untracked->valid)) {1807if(lstat(path->len ? path->buf :".", &st)) {1808memset(&untracked->stat_data,0,sizeof(untracked->stat_data));1809return0;1810}1811if(!untracked->valid ||1812match_stat_data_racy(istate, &untracked->stat_data, &st)) {1813fill_stat_data(&untracked->stat_data, &st);1814return0;1815}1816}18171818if(untracked->check_only != !!check_only)1819return0;18201821/*1822 * prep_exclude will be called eventually on this directory,1823 * but it's called much later in last_matching_pattern(). We1824 * need it now to determine the validity of the cache for this1825 * path. The next calls will be nearly no-op, the way1826 * prep_exclude() is designed.1827 */1828if(path->len && path->buf[path->len -1] !='/') {1829strbuf_addch(path,'/');1830prep_exclude(dir, istate, path->buf, path->len);1831strbuf_setlen(path, path->len -1);1832}else1833prep_exclude(dir, istate, path->buf, path->len);18341835/* hopefully prep_exclude() haven't invalidated this entry... */1836return untracked->valid;1837}18381839static intopen_cached_dir(struct cached_dir *cdir,1840struct dir_struct *dir,1841struct untracked_cache_dir *untracked,1842struct index_state *istate,1843struct strbuf *path,1844int check_only)1845{1846const char*c_path;18471848memset(cdir,0,sizeof(*cdir));1849 cdir->untracked = untracked;1850if(valid_cached_dir(dir, untracked, istate, path, check_only))1851return0;1852 c_path = path->len ? path->buf :".";1853 cdir->fdir =opendir(c_path);1854if(!cdir->fdir)1855warning_errno(_("could not open directory '%s'"), c_path);1856if(dir->untracked) {1857invalidate_directory(dir->untracked, untracked);1858 dir->untracked->dir_opened++;1859}1860if(!cdir->fdir)1861return-1;1862return0;1863}18641865static intread_cached_dir(struct cached_dir *cdir)1866{1867if(cdir->fdir) {1868 cdir->de =readdir(cdir->fdir);1869if(!cdir->de)1870return-1;1871return0;1872}1873while(cdir->nr_dirs < cdir->untracked->dirs_nr) {1874struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1875if(!d->recurse) {1876 cdir->nr_dirs++;1877continue;1878}1879 cdir->ucd = d;1880 cdir->nr_dirs++;1881return0;1882}1883 cdir->ucd = NULL;1884if(cdir->nr_files < cdir->untracked->untracked_nr) {1885struct untracked_cache_dir *d = cdir->untracked;1886 cdir->file = d->untracked[cdir->nr_files++];1887return0;1888}1889return-1;1890}18911892static voidclose_cached_dir(struct cached_dir *cdir)1893{1894if(cdir->fdir)1895closedir(cdir->fdir);1896/*1897 * We have gone through this directory and found no untracked1898 * entries. Mark it valid.1899 */1900if(cdir->untracked) {1901 cdir->untracked->valid =1;1902 cdir->untracked->recurse =1;1903}1904}19051906/*1907 * Read a directory tree. We currently ignore anything but1908 * directories, regular files and symlinks. That's because git1909 * doesn't handle them at all yet. Maybe that will change some1910 * day.1911 *1912 * Also, we ignore the name ".git" (even if it is not a directory).1913 * That likely will not change.1914 *1915 * If 'stop_at_first_file' is specified, 'path_excluded' is returned1916 * to signal that a file was found. This is the least significant value that1917 * indicates that a file was encountered that does not depend on the order of1918 * whether an untracked or exluded path was encountered first.1919 *1920 * Returns the most significant path_treatment value encountered in the scan.1921 * If 'stop_at_first_file' is specified, `path_excluded` is the most1922 * significant path_treatment value that will be returned.1923 */19241925static enum path_treatment read_directory_recursive(struct dir_struct *dir,1926struct index_state *istate,const char*base,int baselen,1927struct untracked_cache_dir *untracked,int check_only,1928int stop_at_first_file,const struct pathspec *pathspec)1929{1930struct cached_dir cdir;1931enum path_treatment state, subdir_state, dir_state = path_none;1932struct strbuf path = STRBUF_INIT;19331934strbuf_add(&path, base, baselen);19351936if(open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1937goto out;19381939if(untracked)1940 untracked->check_only = !!check_only;19411942while(!read_cached_dir(&cdir)) {1943/* check how the file or directory should be treated */1944 state =treat_path(dir, untracked, &cdir, istate, &path,1945 baselen, pathspec);19461947if(state > dir_state)1948 dir_state = state;19491950/* recurse into subdir if instructed by treat_path */1951if((state == path_recurse) ||1952((state == path_untracked) &&1953(dir->flags & DIR_SHOW_IGNORED_TOO) &&1954(get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {1955struct untracked_cache_dir *ud;1956 ud =lookup_untracked(dir->untracked, untracked,1957 path.buf + baselen,1958 path.len - baselen);1959 subdir_state =1960read_directory_recursive(dir, istate, path.buf,1961 path.len, ud,1962 check_only, stop_at_first_file, pathspec);1963if(subdir_state > dir_state)1964 dir_state = subdir_state;1965}19661967if(check_only) {1968if(stop_at_first_file) {1969/*1970 * If stopping at first file, then1971 * signal that a file was found by1972 * returning `path_excluded`. This is1973 * to return a consistent value1974 * regardless of whether an ignored or1975 * excluded file happened to be1976 * encountered 1st.1977 *1978 * In current usage, the1979 * `stop_at_first_file` is passed when1980 * an ancestor directory has matched1981 * an exclude pattern, so any found1982 * files will be excluded.1983 */1984if(dir_state >= path_excluded) {1985 dir_state = path_excluded;1986break;1987}1988}19891990/* abort early if maximum state has been reached */1991if(dir_state == path_untracked) {1992if(cdir.fdir)1993add_untracked(untracked, path.buf + baselen);1994break;1995}1996/* skip the dir_add_* part */1997continue;1998}19992000/* add the path to the appropriate result list */2001switch(state) {2002case path_excluded:2003if(dir->flags & DIR_SHOW_IGNORED)2004dir_add_name(dir, istate, path.buf, path.len);2005else if((dir->flags & DIR_SHOW_IGNORED_TOO) ||2006((dir->flags & DIR_COLLECT_IGNORED) &&2007exclude_matches_pathspec(path.buf, path.len,2008 pathspec)))2009dir_add_ignored(dir, istate, path.buf, path.len);2010break;20112012case path_untracked:2013if(dir->flags & DIR_SHOW_IGNORED)2014break;2015dir_add_name(dir, istate, path.buf, path.len);2016if(cdir.fdir)2017add_untracked(untracked, path.buf + baselen);2018break;20192020default:2021break;2022}2023}2024close_cached_dir(&cdir);2025 out:2026strbuf_release(&path);20272028return dir_state;2029}20302031intcmp_dir_entry(const void*p1,const void*p2)2032{2033const struct dir_entry *e1 = *(const struct dir_entry **)p1;2034const struct dir_entry *e2 = *(const struct dir_entry **)p2;20352036returnname_compare(e1->name, e1->len, e2->name, e2->len);2037}20382039/* check if *out lexically strictly contains *in */2040intcheck_dir_entry_contains(const struct dir_entry *out,const struct dir_entry *in)2041{2042return(out->len < in->len) &&2043(out->name[out->len -1] =='/') &&2044!memcmp(out->name, in->name, out->len);2045}20462047static inttreat_leading_path(struct dir_struct *dir,2048struct index_state *istate,2049const char*path,int len,2050const struct pathspec *pathspec)2051{2052struct strbuf sb = STRBUF_INIT;2053int baselen, rc =0;2054const char*cp;2055int old_flags = dir->flags;20562057while(len && path[len -1] =='/')2058 len--;2059if(!len)2060return1;2061 baselen =0;2062 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;2063while(1) {2064 cp = path + baselen + !!baselen;2065 cp =memchr(cp,'/', path + len - cp);2066if(!cp)2067 baselen = len;2068else2069 baselen = cp - path;2070strbuf_setlen(&sb,0);2071strbuf_add(&sb, path, baselen);2072if(!is_directory(sb.buf))2073break;2074if(simplify_away(sb.buf, sb.len, pathspec))2075break;2076if(treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,2077 DT_DIR, NULL) == path_none)2078break;/* do not recurse into it */2079if(len <= baselen) {2080 rc =1;2081break;/* finished checking */2082}2083}2084strbuf_release(&sb);2085 dir->flags = old_flags;2086return rc;2087}20882089static const char*get_ident_string(void)2090{2091static struct strbuf sb = STRBUF_INIT;2092struct utsname uts;20932094if(sb.len)2095return sb.buf;2096if(uname(&uts) <0)2097die_errno(_("failed to get kernel name and information"));2098strbuf_addf(&sb,"Location%s, system%s",get_git_work_tree(),2099 uts.sysname);2100return sb.buf;2101}21022103static intident_in_untracked(const struct untracked_cache *uc)2104{2105/*2106 * Previous git versions may have saved many NUL separated2107 * strings in the "ident" field, but it is insane to manage2108 * many locations, so just take care of the first one.2109 */21102111return!strcmp(uc->ident.buf,get_ident_string());2112}21132114static voidset_untracked_ident(struct untracked_cache *uc)2115{2116strbuf_reset(&uc->ident);2117strbuf_addstr(&uc->ident,get_ident_string());21182119/*2120 * This strbuf used to contain a list of NUL separated2121 * strings, so save NUL too for backward compatibility.2122 */2123strbuf_addch(&uc->ident,0);2124}21252126static voidnew_untracked_cache(struct index_state *istate)2127{2128struct untracked_cache *uc =xcalloc(1,sizeof(*uc));2129strbuf_init(&uc->ident,100);2130 uc->exclude_per_dir =".gitignore";2131/* should be the same flags used by git-status */2132 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;2133set_untracked_ident(uc);2134 istate->untracked = uc;2135 istate->cache_changed |= UNTRACKED_CHANGED;2136}21372138voidadd_untracked_cache(struct index_state *istate)2139{2140if(!istate->untracked) {2141new_untracked_cache(istate);2142}else{2143if(!ident_in_untracked(istate->untracked)) {2144free_untracked_cache(istate->untracked);2145new_untracked_cache(istate);2146}2147}2148}21492150voidremove_untracked_cache(struct index_state *istate)2151{2152if(istate->untracked) {2153free_untracked_cache(istate->untracked);2154 istate->untracked = NULL;2155 istate->cache_changed |= UNTRACKED_CHANGED;2156}2157}21582159static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,2160int base_len,2161const struct pathspec *pathspec)2162{2163struct untracked_cache_dir *root;2164static int untracked_cache_disabled = -1;21652166if(!dir->untracked)2167return NULL;2168if(untracked_cache_disabled <0)2169 untracked_cache_disabled =git_env_bool("GIT_DISABLE_UNTRACKED_CACHE",0);2170if(untracked_cache_disabled)2171return NULL;21722173/*2174 * We only support $GIT_DIR/info/exclude and core.excludesfile2175 * as the global ignore rule files. Any other additions2176 * (e.g. from command line) invalidate the cache. This2177 * condition also catches running setup_standard_excludes()2178 * before setting dir->untracked!2179 */2180if(dir->unmanaged_exclude_files)2181return NULL;21822183/*2184 * Optimize for the main use case only: whole-tree git2185 * status. More work involved in treat_leading_path() if we2186 * use cache on just a subset of the worktree. pathspec2187 * support could make the matter even worse.2188 */2189if(base_len || (pathspec && pathspec->nr))2190return NULL;21912192/* Different set of flags may produce different results */2193if(dir->flags != dir->untracked->dir_flags ||2194/*2195 * See treat_directory(), case index_nonexistent. Without2196 * this flag, we may need to also cache .git file content2197 * for the resolve_gitlink_ref() call, which we don't.2198 */2199!(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2200/* We don't support collecting ignore files */2201(dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2202 DIR_COLLECT_IGNORED)))2203return NULL;22042205/*2206 * If we use .gitignore in the cache and now you change it to2207 * .gitexclude, everything will go wrong.2208 */2209if(dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2210strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2211return NULL;22122213/*2214 * EXC_CMDL is not considered in the cache. If people set it,2215 * skip the cache.2216 */2217if(dir->exclude_list_group[EXC_CMDL].nr)2218return NULL;22192220if(!ident_in_untracked(dir->untracked)) {2221warning(_("untracked cache is disabled on this system or location"));2222return NULL;2223}22242225if(!dir->untracked->root) {2226const int len =sizeof(*dir->untracked->root);2227 dir->untracked->root =xmalloc(len);2228memset(dir->untracked->root,0, len);2229}22302231/* Validate $GIT_DIR/info/exclude and core.excludesfile */2232 root = dir->untracked->root;2233if(!oideq(&dir->ss_info_exclude.oid,2234&dir->untracked->ss_info_exclude.oid)) {2235invalidate_gitignore(dir->untracked, root);2236 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2237}2238if(!oideq(&dir->ss_excludes_file.oid,2239&dir->untracked->ss_excludes_file.oid)) {2240invalidate_gitignore(dir->untracked, root);2241 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2242}22432244/* Make sure this directory is not dropped out at saving phase */2245 root->recurse =1;2246return root;2247}22482249intread_directory(struct dir_struct *dir,struct index_state *istate,2250const char*path,int len,const struct pathspec *pathspec)2251{2252struct untracked_cache_dir *untracked;22532254trace_performance_enter();22552256if(has_symlink_leading_path(path, len)) {2257trace_performance_leave("read directory %.*s", len, path);2258return dir->nr;2259}22602261 untracked =validate_untracked_cache(dir, len, pathspec);2262if(!untracked)2263/*2264 * make sure untracked cache code path is disabled,2265 * e.g. prep_exclude()2266 */2267 dir->untracked = NULL;2268if(!len ||treat_leading_path(dir, istate, path, len, pathspec))2269read_directory_recursive(dir, istate, path, len, untracked,0,0, pathspec);2270QSORT(dir->entries, dir->nr, cmp_dir_entry);2271QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);22722273/*2274 * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will2275 * also pick up untracked contents of untracked dirs; by default2276 * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.2277 */2278if((dir->flags & DIR_SHOW_IGNORED_TOO) &&2279!(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {2280int i, j;22812282/* remove from dir->entries untracked contents of untracked dirs */2283for(i = j =0; j < dir->nr; j++) {2284if(i &&2285check_dir_entry_contains(dir->entries[i -1], dir->entries[j])) {2286FREE_AND_NULL(dir->entries[j]);2287}else{2288 dir->entries[i++] = dir->entries[j];2289}2290}22912292 dir->nr = i;2293}22942295trace_performance_leave("read directory %.*s", len, path);2296if(dir->untracked) {2297static int force_untracked_cache = -1;2298static struct trace_key trace_untracked_stats =TRACE_KEY_INIT(UNTRACKED_STATS);22992300if(force_untracked_cache <0)2301 force_untracked_cache =2302git_env_bool("GIT_FORCE_UNTRACKED_CACHE",0);2303trace_printf_key(&trace_untracked_stats,2304"node creation:%u\n"2305"gitignore invalidation:%u\n"2306"directory invalidation:%u\n"2307"opendir:%u\n",2308 dir->untracked->dir_created,2309 dir->untracked->gitignore_invalidated,2310 dir->untracked->dir_invalidated,2311 dir->untracked->dir_opened);2312if(force_untracked_cache &&2313 dir->untracked == istate->untracked &&2314(dir->untracked->dir_opened ||2315 dir->untracked->gitignore_invalidated ||2316 dir->untracked->dir_invalidated))2317 istate->cache_changed |= UNTRACKED_CHANGED;2318if(dir->untracked != istate->untracked) {2319FREE_AND_NULL(dir->untracked);2320}2321}2322return dir->nr;2323}23242325intfile_exists(const char*f)2326{2327struct stat sb;2328returnlstat(f, &sb) ==0;2329}23302331intrepo_file_exists(struct repository *repo,const char*path)2332{2333if(repo != the_repository)2334BUG("do not know how to check file existence in arbitrary repo");23352336returnfile_exists(path);2337}23382339static intcmp_icase(char a,char b)2340{2341if(a == b)2342return0;2343if(ignore_case)2344returntoupper(a) -toupper(b);2345return a - b;2346}23472348/*2349 * Given two normalized paths (a trailing slash is ok), if subdir is2350 * outside dir, return -1. Otherwise return the offset in subdir that2351 * can be used as relative path to dir.2352 */2353intdir_inside_of(const char*subdir,const char*dir)2354{2355int offset =0;23562357assert(dir && subdir && *dir && *subdir);23582359while(*dir && *subdir && !cmp_icase(*dir, *subdir)) {2360 dir++;2361 subdir++;2362 offset++;2363}23642365/* hel[p]/me vs hel[l]/yeah */2366if(*dir && *subdir)2367return-1;23682369if(!*subdir)2370return!*dir ? offset : -1;/* same dir */23712372/* foo/[b]ar vs foo/[] */2373if(is_dir_sep(dir[-1]))2374returnis_dir_sep(subdir[-1]) ? offset : -1;23752376/* foo[/]bar vs foo[] */2377returnis_dir_sep(*subdir) ? offset +1: -1;2378}23792380intis_inside_dir(const char*dir)2381{2382char*cwd;2383int rc;23842385if(!dir)2386return0;23872388 cwd =xgetcwd();2389 rc = (dir_inside_of(cwd, dir) >=0);2390free(cwd);2391return rc;2392}23932394intis_empty_dir(const char*path)2395{2396DIR*dir =opendir(path);2397struct dirent *e;2398int ret =1;23992400if(!dir)2401return0;24022403while((e =readdir(dir)) != NULL)2404if(!is_dot_or_dotdot(e->d_name)) {2405 ret =0;2406break;2407}24082409closedir(dir);2410return ret;2411}24122413static intremove_dir_recurse(struct strbuf *path,int flag,int*kept_up)2414{2415DIR*dir;2416struct dirent *e;2417int ret =0, original_len = path->len, len, kept_down =0;2418int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2419int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2420struct object_id submodule_head;24212422if((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2423!resolve_gitlink_ref(path->buf,"HEAD", &submodule_head)) {2424/* Do not descend and nuke a nested git work tree. */2425if(kept_up)2426*kept_up =1;2427return0;2428}24292430 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2431 dir =opendir(path->buf);2432if(!dir) {2433if(errno == ENOENT)2434return keep_toplevel ? -1:0;2435else if(errno == EACCES && !keep_toplevel)2436/*2437 * An empty dir could be removable even if it2438 * is unreadable:2439 */2440returnrmdir(path->buf);2441else2442return-1;2443}2444strbuf_complete(path,'/');24452446 len = path->len;2447while((e =readdir(dir)) != NULL) {2448struct stat st;2449if(is_dot_or_dotdot(e->d_name))2450continue;24512452strbuf_setlen(path, len);2453strbuf_addstr(path, e->d_name);2454if(lstat(path->buf, &st)) {2455if(errno == ENOENT)2456/*2457 * file disappeared, which is what we2458 * wanted anyway2459 */2460continue;2461/* fall thru */2462}else if(S_ISDIR(st.st_mode)) {2463if(!remove_dir_recurse(path, flag, &kept_down))2464continue;/* happy */2465}else if(!only_empty &&2466(!unlink(path->buf) || errno == ENOENT)) {2467continue;/* happy, too */2468}24692470/* path too long, stat fails, or non-directory still exists */2471 ret = -1;2472break;2473}2474closedir(dir);24752476strbuf_setlen(path, original_len);2477if(!ret && !keep_toplevel && !kept_down)2478 ret = (!rmdir(path->buf) || errno == ENOENT) ?0: -1;2479else if(kept_up)2480/*2481 * report the uplevel that it is not an error that we2482 * did not rmdir() our directory.2483 */2484*kept_up = !ret;2485return ret;2486}24872488intremove_dir_recursively(struct strbuf *path,int flag)2489{2490returnremove_dir_recurse(path, flag, NULL);2491}24922493staticGIT_PATH_FUNC(git_path_info_exclude,"info/exclude")24942495voidsetup_standard_excludes(struct dir_struct *dir)2496{2497 dir->exclude_per_dir =".gitignore";24982499/* core.excludesfile defaulting to $XDG_CONFIG_HOME/git/ignore */2500if(!excludes_file)2501 excludes_file =xdg_config_home("ignore");2502if(excludes_file && !access_or_warn(excludes_file, R_OK,0))2503add_patterns_from_file_1(dir, excludes_file,2504 dir->untracked ? &dir->ss_excludes_file : NULL);25052506/* per repository user preference */2507if(startup_info->have_repository) {2508const char*path =git_path_info_exclude();2509if(!access_or_warn(path, R_OK,0))2510add_patterns_from_file_1(dir, path,2511 dir->untracked ? &dir->ss_info_exclude : NULL);2512}2513}25142515intremove_path(const char*name)2516{2517char*slash;25182519if(unlink(name) && !is_missing_file_error(errno))2520return-1;25212522 slash =strrchr(name,'/');2523if(slash) {2524char*dirs =xstrdup(name);2525 slash = dirs + (slash - name);2526do{2527*slash ='\0';2528}while(rmdir(dirs) ==0&& (slash =strrchr(dirs,'/')));2529free(dirs);2530}2531return0;2532}25332534/*2535 * Frees memory within dir which was allocated for exclude lists and2536 * the exclude_stack. Does not free dir itself.2537 */2538voidclear_directory(struct dir_struct *dir)2539{2540int i, j;2541struct exclude_list_group *group;2542struct pattern_list *pl;2543struct exclude_stack *stk;25442545for(i = EXC_CMDL; i <= EXC_FILE; i++) {2546 group = &dir->exclude_list_group[i];2547for(j =0; j < group->nr; j++) {2548 pl = &group->pl[j];2549if(i == EXC_DIRS)2550free((char*)pl->src);2551clear_pattern_list(pl);2552}2553free(group->pl);2554}25552556 stk = dir->exclude_stack;2557while(stk) {2558struct exclude_stack *prev = stk->prev;2559free(stk);2560 stk = prev;2561}2562strbuf_release(&dir->basebuf);2563}25642565struct ondisk_untracked_cache {2566struct stat_data info_exclude_stat;2567struct stat_data excludes_file_stat;2568uint32_t dir_flags;2569};25702571#define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)25722573struct write_data {2574int index;/* number of written untracked_cache_dir */2575struct ewah_bitmap *check_only;/* from untracked_cache_dir */2576struct ewah_bitmap *valid;/* from untracked_cache_dir */2577struct ewah_bitmap *sha1_valid;/* set if exclude_sha1 is not null */2578struct strbuf out;2579struct strbuf sb_stat;2580struct strbuf sb_sha1;2581};25822583static voidstat_data_to_disk(struct stat_data *to,const struct stat_data *from)2584{2585 to->sd_ctime.sec =htonl(from->sd_ctime.sec);2586 to->sd_ctime.nsec =htonl(from->sd_ctime.nsec);2587 to->sd_mtime.sec =htonl(from->sd_mtime.sec);2588 to->sd_mtime.nsec =htonl(from->sd_mtime.nsec);2589 to->sd_dev =htonl(from->sd_dev);2590 to->sd_ino =htonl(from->sd_ino);2591 to->sd_uid =htonl(from->sd_uid);2592 to->sd_gid =htonl(from->sd_gid);2593 to->sd_size =htonl(from->sd_size);2594}25952596static voidwrite_one_dir(struct untracked_cache_dir *untracked,2597struct write_data *wd)2598{2599struct stat_data stat_data;2600struct strbuf *out = &wd->out;2601unsigned char intbuf[16];2602unsigned int intlen, value;2603int i = wd->index++;26042605/*2606 * untracked_nr should be reset whenever valid is clear, but2607 * for safety..2608 */2609if(!untracked->valid) {2610 untracked->untracked_nr =0;2611 untracked->check_only =0;2612}26132614if(untracked->check_only)2615ewah_set(wd->check_only, i);2616if(untracked->valid) {2617ewah_set(wd->valid, i);2618stat_data_to_disk(&stat_data, &untracked->stat_data);2619strbuf_add(&wd->sb_stat, &stat_data,sizeof(stat_data));2620}2621if(!is_null_oid(&untracked->exclude_oid)) {2622ewah_set(wd->sha1_valid, i);2623strbuf_add(&wd->sb_sha1, untracked->exclude_oid.hash,2624 the_hash_algo->rawsz);2625}26262627 intlen =encode_varint(untracked->untracked_nr, intbuf);2628strbuf_add(out, intbuf, intlen);26292630/* skip non-recurse directories */2631for(i =0, value =0; i < untracked->dirs_nr; i++)2632if(untracked->dirs[i]->recurse)2633 value++;2634 intlen =encode_varint(value, intbuf);2635strbuf_add(out, intbuf, intlen);26362637strbuf_add(out, untracked->name,strlen(untracked->name) +1);26382639for(i =0; i < untracked->untracked_nr; i++)2640strbuf_add(out, untracked->untracked[i],2641strlen(untracked->untracked[i]) +1);26422643for(i =0; i < untracked->dirs_nr; i++)2644if(untracked->dirs[i]->recurse)2645write_one_dir(untracked->dirs[i], wd);2646}26472648voidwrite_untracked_extension(struct strbuf *out,struct untracked_cache *untracked)2649{2650struct ondisk_untracked_cache *ouc;2651struct write_data wd;2652unsigned char varbuf[16];2653int varint_len;2654const unsigned hashsz = the_hash_algo->rawsz;26552656 ouc =xcalloc(1,sizeof(*ouc));2657stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2658stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2659 ouc->dir_flags =htonl(untracked->dir_flags);26602661 varint_len =encode_varint(untracked->ident.len, varbuf);2662strbuf_add(out, varbuf, varint_len);2663strbuf_addbuf(out, &untracked->ident);26642665strbuf_add(out, ouc,sizeof(*ouc));2666strbuf_add(out, untracked->ss_info_exclude.oid.hash, hashsz);2667strbuf_add(out, untracked->ss_excludes_file.oid.hash, hashsz);2668strbuf_add(out, untracked->exclude_per_dir,strlen(untracked->exclude_per_dir) +1);2669FREE_AND_NULL(ouc);26702671if(!untracked->root) {2672 varint_len =encode_varint(0, varbuf);2673strbuf_add(out, varbuf, varint_len);2674return;2675}26762677 wd.index =0;2678 wd.check_only =ewah_new();2679 wd.valid =ewah_new();2680 wd.sha1_valid =ewah_new();2681strbuf_init(&wd.out,1024);2682strbuf_init(&wd.sb_stat,1024);2683strbuf_init(&wd.sb_sha1,1024);2684write_one_dir(untracked->root, &wd);26852686 varint_len =encode_varint(wd.index, varbuf);2687strbuf_add(out, varbuf, varint_len);2688strbuf_addbuf(out, &wd.out);2689ewah_serialize_strbuf(wd.valid, out);2690ewah_serialize_strbuf(wd.check_only, out);2691ewah_serialize_strbuf(wd.sha1_valid, out);2692strbuf_addbuf(out, &wd.sb_stat);2693strbuf_addbuf(out, &wd.sb_sha1);2694strbuf_addch(out,'\0');/* safe guard for string lists */26952696ewah_free(wd.valid);2697ewah_free(wd.check_only);2698ewah_free(wd.sha1_valid);2699strbuf_release(&wd.out);2700strbuf_release(&wd.sb_stat);2701strbuf_release(&wd.sb_sha1);2702}27032704static voidfree_untracked(struct untracked_cache_dir *ucd)2705{2706int i;2707if(!ucd)2708return;2709for(i =0; i < ucd->dirs_nr; i++)2710free_untracked(ucd->dirs[i]);2711for(i =0; i < ucd->untracked_nr; i++)2712free(ucd->untracked[i]);2713free(ucd->untracked);2714free(ucd->dirs);2715free(ucd);2716}27172718voidfree_untracked_cache(struct untracked_cache *uc)2719{2720if(uc)2721free_untracked(uc->root);2722free(uc);2723}27242725struct read_data {2726int index;2727struct untracked_cache_dir **ucd;2728struct ewah_bitmap *check_only;2729struct ewah_bitmap *valid;2730struct ewah_bitmap *sha1_valid;2731const unsigned char*data;2732const unsigned char*end;2733};27342735static voidstat_data_from_disk(struct stat_data *to,const unsigned char*data)2736{2737memcpy(to, data,sizeof(*to));2738 to->sd_ctime.sec =ntohl(to->sd_ctime.sec);2739 to->sd_ctime.nsec =ntohl(to->sd_ctime.nsec);2740 to->sd_mtime.sec =ntohl(to->sd_mtime.sec);2741 to->sd_mtime.nsec =ntohl(to->sd_mtime.nsec);2742 to->sd_dev =ntohl(to->sd_dev);2743 to->sd_ino =ntohl(to->sd_ino);2744 to->sd_uid =ntohl(to->sd_uid);2745 to->sd_gid =ntohl(to->sd_gid);2746 to->sd_size =ntohl(to->sd_size);2747}27482749static intread_one_dir(struct untracked_cache_dir **untracked_,2750struct read_data *rd)2751{2752struct untracked_cache_dir ud, *untracked;2753const unsigned char*data = rd->data, *end = rd->end;2754const unsigned char*eos;2755unsigned int value;2756int i;27572758memset(&ud,0,sizeof(ud));27592760 value =decode_varint(&data);2761if(data > end)2762return-1;2763 ud.recurse =1;2764 ud.untracked_alloc = value;2765 ud.untracked_nr = value;2766if(ud.untracked_nr)2767ALLOC_ARRAY(ud.untracked, ud.untracked_nr);27682769 ud.dirs_alloc = ud.dirs_nr =decode_varint(&data);2770if(data > end)2771return-1;2772ALLOC_ARRAY(ud.dirs, ud.dirs_nr);27732774 eos =memchr(data,'\0', end - data);2775if(!eos || eos == end)2776return-1;27772778*untracked_ = untracked =xmalloc(st_add3(sizeof(*untracked), eos - data,1));2779memcpy(untracked, &ud,sizeof(ud));2780memcpy(untracked->name, data, eos - data +1);2781 data = eos +1;27822783for(i =0; i < untracked->untracked_nr; i++) {2784 eos =memchr(data,'\0', end - data);2785if(!eos || eos == end)2786return-1;2787 untracked->untracked[i] =xmemdupz(data, eos - data);2788 data = eos +1;2789}27902791 rd->ucd[rd->index++] = untracked;2792 rd->data = data;27932794for(i =0; i < untracked->dirs_nr; i++) {2795if(read_one_dir(untracked->dirs + i, rd) <0)2796return-1;2797}2798return0;2799}28002801static voidset_check_only(size_t pos,void*cb)2802{2803struct read_data *rd = cb;2804struct untracked_cache_dir *ud = rd->ucd[pos];2805 ud->check_only =1;2806}28072808static voidread_stat(size_t pos,void*cb)2809{2810struct read_data *rd = cb;2811struct untracked_cache_dir *ud = rd->ucd[pos];2812if(rd->data +sizeof(struct stat_data) > rd->end) {2813 rd->data = rd->end +1;2814return;2815}2816stat_data_from_disk(&ud->stat_data, rd->data);2817 rd->data +=sizeof(struct stat_data);2818 ud->valid =1;2819}28202821static voidread_oid(size_t pos,void*cb)2822{2823struct read_data *rd = cb;2824struct untracked_cache_dir *ud = rd->ucd[pos];2825if(rd->data + the_hash_algo->rawsz > rd->end) {2826 rd->data = rd->end +1;2827return;2828}2829hashcpy(ud->exclude_oid.hash, rd->data);2830 rd->data += the_hash_algo->rawsz;2831}28322833static voidload_oid_stat(struct oid_stat *oid_stat,const unsigned char*data,2834const unsigned char*sha1)2835{2836stat_data_from_disk(&oid_stat->stat, data);2837hashcpy(oid_stat->oid.hash, sha1);2838 oid_stat->valid =1;2839}28402841struct untracked_cache *read_untracked_extension(const void*data,unsigned long sz)2842{2843struct untracked_cache *uc;2844struct read_data rd;2845const unsigned char*next = data, *end = (const unsigned char*)data + sz;2846const char*ident;2847int ident_len;2848 ssize_t len;2849const char*exclude_per_dir;2850const unsigned hashsz = the_hash_algo->rawsz;2851const unsigned offset =sizeof(struct ondisk_untracked_cache);2852const unsigned exclude_per_dir_offset = offset +2* hashsz;28532854if(sz <=1|| end[-1] !='\0')2855return NULL;2856 end--;28572858 ident_len =decode_varint(&next);2859if(next + ident_len > end)2860return NULL;2861 ident = (const char*)next;2862 next += ident_len;28632864if(next + exclude_per_dir_offset +1> end)2865return NULL;28662867 uc =xcalloc(1,sizeof(*uc));2868strbuf_init(&uc->ident, ident_len);2869strbuf_add(&uc->ident, ident, ident_len);2870load_oid_stat(&uc->ss_info_exclude,2871 next +ouc_offset(info_exclude_stat),2872 next + offset);2873load_oid_stat(&uc->ss_excludes_file,2874 next +ouc_offset(excludes_file_stat),2875 next + offset + hashsz);2876 uc->dir_flags =get_be32(next +ouc_offset(dir_flags));2877 exclude_per_dir = (const char*)next + exclude_per_dir_offset;2878 uc->exclude_per_dir =xstrdup(exclude_per_dir);2879/* NUL after exclude_per_dir is covered by sizeof(*ouc) */2880 next += exclude_per_dir_offset +strlen(exclude_per_dir) +1;2881if(next >= end)2882goto done2;28832884 len =decode_varint(&next);2885if(next > end || len ==0)2886goto done2;28872888 rd.valid =ewah_new();2889 rd.check_only =ewah_new();2890 rd.sha1_valid =ewah_new();2891 rd.data = next;2892 rd.end = end;2893 rd.index =0;2894ALLOC_ARRAY(rd.ucd, len);28952896if(read_one_dir(&uc->root, &rd) || rd.index != len)2897goto done;28982899 next = rd.data;2900 len =ewah_read_mmap(rd.valid, next, end - next);2901if(len <0)2902goto done;29032904 next += len;2905 len =ewah_read_mmap(rd.check_only, next, end - next);2906if(len <0)2907goto done;29082909 next += len;2910 len =ewah_read_mmap(rd.sha1_valid, next, end - next);2911if(len <0)2912goto done;29132914ewah_each_bit(rd.check_only, set_check_only, &rd);2915 rd.data = next + len;2916ewah_each_bit(rd.valid, read_stat, &rd);2917ewah_each_bit(rd.sha1_valid, read_oid, &rd);2918 next = rd.data;29192920done:2921free(rd.ucd);2922ewah_free(rd.valid);2923ewah_free(rd.check_only);2924ewah_free(rd.sha1_valid);2925done2:2926if(next != end) {2927free_untracked_cache(uc);2928 uc = NULL;2929}2930return uc;2931}29322933static voidinvalidate_one_directory(struct untracked_cache *uc,2934struct untracked_cache_dir *ucd)2935{2936 uc->dir_invalidated++;2937 ucd->valid =0;2938 ucd->untracked_nr =0;2939}29402941/*2942 * Normally when an entry is added or removed from a directory,2943 * invalidating that directory is enough. No need to touch its2944 * ancestors. When a directory is shown as "foo/bar/" in git-status2945 * however, deleting or adding an entry may have cascading effect.2946 *2947 * Say the "foo/bar/file" has become untracked, we need to tell the2948 * untracked_cache_dir of "foo" that "bar/" is not an untracked2949 * directory any more (because "bar" is managed by foo as an untracked2950 * "file").2951 *2952 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2953 * was the last untracked entry in the entire "foo", we should show2954 * "foo/" instead. Which means we have to invalidate past "bar" up to2955 * "foo".2956 *2957 * This function traverses all directories from root to leaf. If there2958 * is a chance of one of the above cases happening, we invalidate back2959 * to root. Otherwise we just invalidate the leaf. There may be a more2960 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2961 * detect these cases and avoid unnecessary invalidation, for example,2962 * checking for the untracked entry named "bar/" in "foo", but for now2963 * stick to something safe and simple.2964 */2965static intinvalidate_one_component(struct untracked_cache *uc,2966struct untracked_cache_dir *dir,2967const char*path,int len)2968{2969const char*rest =strchr(path,'/');29702971if(rest) {2972int component_len = rest - path;2973struct untracked_cache_dir *d =2974lookup_untracked(uc, dir, path, component_len);2975int ret =2976invalidate_one_component(uc, d, rest +1,2977 len - (component_len +1));2978if(ret)2979invalidate_one_directory(uc, dir);2980return ret;2981}29822983invalidate_one_directory(uc, dir);2984return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2985}29862987voiduntracked_cache_invalidate_path(struct index_state *istate,2988const char*path,int safe_path)2989{2990if(!istate->untracked || !istate->untracked->root)2991return;2992if(!safe_path && !verify_path(path,0))2993return;2994invalidate_one_component(istate->untracked, istate->untracked->root,2995 path,strlen(path));2996}29972998voiduntracked_cache_remove_from_index(struct index_state *istate,2999const char*path)3000{3001untracked_cache_invalidate_path(istate, path,1);3002}30033004voiduntracked_cache_add_to_index(struct index_state *istate,3005const char*path)3006{3007untracked_cache_invalidate_path(istate, path,1);3008}30093010static voidconnect_wt_gitdir_in_nested(const char*sub_worktree,3011const char*sub_gitdir)3012{3013int i;3014struct repository subrepo;3015struct strbuf sub_wt = STRBUF_INIT;3016struct strbuf sub_gd = STRBUF_INIT;30173018const struct submodule *sub;30193020/* If the submodule has no working tree, we can ignore it. */3021if(repo_init(&subrepo, sub_gitdir, sub_worktree))3022return;30233024if(repo_read_index(&subrepo) <0)3025die(_("index file corrupt in repo%s"), subrepo.gitdir);30263027for(i =0; i < subrepo.index->cache_nr; i++) {3028const struct cache_entry *ce = subrepo.index->cache[i];30293030if(!S_ISGITLINK(ce->ce_mode))3031continue;30323033while(i +1< subrepo.index->cache_nr &&3034!strcmp(ce->name, subrepo.index->cache[i +1]->name))3035/*3036 * Skip entries with the same name in different stages3037 * to make sure an entry is returned only once.3038 */3039 i++;30403041 sub =submodule_from_path(&subrepo, &null_oid, ce->name);3042if(!sub || !is_submodule_active(&subrepo, ce->name))3043/* .gitmodules broken or inactive sub */3044continue;30453046strbuf_reset(&sub_wt);3047strbuf_reset(&sub_gd);3048strbuf_addf(&sub_wt,"%s/%s", sub_worktree, sub->path);3049strbuf_addf(&sub_gd,"%s/modules/%s", sub_gitdir, sub->name);30503051connect_work_tree_and_git_dir(sub_wt.buf, sub_gd.buf,1);3052}3053strbuf_release(&sub_wt);3054strbuf_release(&sub_gd);3055repo_clear(&subrepo);3056}30573058voidconnect_work_tree_and_git_dir(const char*work_tree_,3059const char*git_dir_,3060int recurse_into_nested)3061{3062struct strbuf gitfile_sb = STRBUF_INIT;3063struct strbuf cfg_sb = STRBUF_INIT;3064struct strbuf rel_path = STRBUF_INIT;3065char*git_dir, *work_tree;30663067/* Prepare .git file */3068strbuf_addf(&gitfile_sb,"%s/.git", work_tree_);3069if(safe_create_leading_directories_const(gitfile_sb.buf))3070die(_("could not create directories for%s"), gitfile_sb.buf);30713072/* Prepare config file */3073strbuf_addf(&cfg_sb,"%s/config", git_dir_);3074if(safe_create_leading_directories_const(cfg_sb.buf))3075die(_("could not create directories for%s"), cfg_sb.buf);30763077 git_dir =real_pathdup(git_dir_,1);3078 work_tree =real_pathdup(work_tree_,1);30793080/* Write .git file */3081write_file(gitfile_sb.buf,"gitdir:%s",3082relative_path(git_dir, work_tree, &rel_path));3083/* Update core.worktree setting */3084git_config_set_in_file(cfg_sb.buf,"core.worktree",3085relative_path(work_tree, git_dir, &rel_path));30863087strbuf_release(&gitfile_sb);3088strbuf_release(&cfg_sb);3089strbuf_release(&rel_path);30903091if(recurse_into_nested)3092connect_wt_gitdir_in_nested(work_tree, git_dir);30933094free(work_tree);3095free(git_dir);3096}30973098/*3099 * Migrate the git directory of the given path from old_git_dir to new_git_dir.3100 */3101voidrelocate_gitdir(const char*path,const char*old_git_dir,const char*new_git_dir)3102{3103if(rename(old_git_dir, new_git_dir) <0)3104die_errno(_("could not migrate git directory from '%s' to '%s'"),3105 old_git_dir, new_git_dir);31063107connect_work_tree_and_git_dir(path, new_git_dir,0);3108}