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#include"fsmonitor.h" 22 23/* 24 * Tells read_directory_recursive how a file or directory should be treated. 25 * Values are ordered by significance, e.g. if a directory contains both 26 * excluded and untracked files, it is listed as untracked because 27 * path_untracked > path_excluded. 28 */ 29enum path_treatment { 30 path_none =0, 31 path_recurse, 32 path_excluded, 33 path_untracked 34}; 35 36/* 37 * Support data structure for our opendir/readdir/closedir wrappers 38 */ 39struct cached_dir { 40DIR*fdir; 41struct untracked_cache_dir *untracked; 42int nr_files; 43int nr_dirs; 44 45struct dirent *de; 46const char*file; 47struct untracked_cache_dir *ucd; 48}; 49 50static enum path_treatment read_directory_recursive(struct dir_struct *dir, 51struct index_state *istate,const char*path,int len, 52struct untracked_cache_dir *untracked, 53int check_only,const struct pathspec *pathspec); 54static intget_dtype(struct dirent *de,struct index_state *istate, 55const char*path,int len); 56 57intcount_slashes(const char*s) 58{ 59int cnt =0; 60while(*s) 61if(*s++ =='/') 62 cnt++; 63return cnt; 64} 65 66intfspathcmp(const char*a,const char*b) 67{ 68return ignore_case ?strcasecmp(a, b) :strcmp(a, b); 69} 70 71intfspathncmp(const char*a,const char*b,size_t count) 72{ 73return ignore_case ?strncasecmp(a, b, count) :strncmp(a, b, count); 74} 75 76intgit_fnmatch(const struct pathspec_item *item, 77const char*pattern,const char*string, 78int prefix) 79{ 80if(prefix >0) { 81if(ps_strncmp(item, pattern, string, prefix)) 82return WM_NOMATCH; 83 pattern += prefix; 84 string += prefix; 85} 86if(item->flags & PATHSPEC_ONESTAR) { 87int pattern_len =strlen(++pattern); 88int string_len =strlen(string); 89return string_len < pattern_len || 90ps_strcmp(item, pattern, 91 string + string_len - pattern_len); 92} 93if(item->magic & PATHSPEC_GLOB) 94returnwildmatch(pattern, string, 95 WM_PATHNAME | 96(item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0)); 97else 98/* wildmatch has not learned no FNM_PATHNAME mode yet */ 99returnwildmatch(pattern, string, 100 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0); 101} 102 103static intfnmatch_icase_mem(const char*pattern,int patternlen, 104const char*string,int stringlen, 105int flags) 106{ 107int match_status; 108struct strbuf pat_buf = STRBUF_INIT; 109struct strbuf str_buf = STRBUF_INIT; 110const char*use_pat = pattern; 111const char*use_str = string; 112 113if(pattern[patternlen]) { 114strbuf_add(&pat_buf, pattern, patternlen); 115 use_pat = pat_buf.buf; 116} 117if(string[stringlen]) { 118strbuf_add(&str_buf, string, stringlen); 119 use_str = str_buf.buf; 120} 121 122if(ignore_case) 123 flags |= WM_CASEFOLD; 124 match_status =wildmatch(use_pat, use_str, flags); 125 126strbuf_release(&pat_buf); 127strbuf_release(&str_buf); 128 129return match_status; 130} 131 132static size_tcommon_prefix_len(const struct pathspec *pathspec) 133{ 134int n; 135size_t max =0; 136 137/* 138 * ":(icase)path" is treated as a pathspec full of 139 * wildcard. In other words, only prefix is considered common 140 * prefix. If the pathspec is abc/foo abc/bar, running in 141 * subdir xyz, the common prefix is still xyz, not xuz/abc as 142 * in non-:(icase). 143 */ 144GUARD_PATHSPEC(pathspec, 145 PATHSPEC_FROMTOP | 146 PATHSPEC_MAXDEPTH | 147 PATHSPEC_LITERAL | 148 PATHSPEC_GLOB | 149 PATHSPEC_ICASE | 150 PATHSPEC_EXCLUDE | 151 PATHSPEC_ATTR); 152 153for(n =0; n < pathspec->nr; n++) { 154size_t i =0, len =0, item_len; 155if(pathspec->items[n].magic & PATHSPEC_EXCLUDE) 156continue; 157if(pathspec->items[n].magic & PATHSPEC_ICASE) 158 item_len = pathspec->items[n].prefix; 159else 160 item_len = pathspec->items[n].nowildcard_len; 161while(i < item_len && (n ==0|| i < max)) { 162char c = pathspec->items[n].match[i]; 163if(c != pathspec->items[0].match[i]) 164break; 165if(c =='/') 166 len = i +1; 167 i++; 168} 169if(n ==0|| len < max) { 170 max = len; 171if(!max) 172break; 173} 174} 175return max; 176} 177 178/* 179 * Returns a copy of the longest leading path common among all 180 * pathspecs. 181 */ 182char*common_prefix(const struct pathspec *pathspec) 183{ 184unsigned long len =common_prefix_len(pathspec); 185 186return len ?xmemdupz(pathspec->items[0].match, len) : NULL; 187} 188 189intfill_directory(struct dir_struct *dir, 190struct index_state *istate, 191const struct pathspec *pathspec) 192{ 193const char*prefix; 194size_t prefix_len; 195 196/* 197 * Calculate common prefix for the pathspec, and 198 * use that to optimize the directory walk 199 */ 200 prefix_len =common_prefix_len(pathspec); 201 prefix = prefix_len ? pathspec->items[0].match :""; 202 203/* Read the directory and prune it */ 204read_directory(dir, istate, prefix, prefix_len, pathspec); 205 206return prefix_len; 207} 208 209intwithin_depth(const char*name,int namelen, 210int depth,int max_depth) 211{ 212const char*cp = name, *cpe = name + namelen; 213 214while(cp < cpe) { 215if(*cp++ !='/') 216continue; 217 depth++; 218if(depth > max_depth) 219return0; 220} 221return1; 222} 223 224#define DO_MATCH_EXCLUDE (1<<0) 225#define DO_MATCH_DIRECTORY (1<<1) 226#define DO_MATCH_SUBMODULE (1<<2) 227 228static intmatch_attrs(const char*name,int namelen, 229const struct pathspec_item *item) 230{ 231int i; 232 233git_check_attr(name, item->attr_check); 234for(i =0; i < item->attr_match_nr; i++) { 235const char*value; 236int matched; 237enum attr_match_mode match_mode; 238 239 value = item->attr_check->items[i].value; 240 match_mode = item->attr_match[i].match_mode; 241 242if(ATTR_TRUE(value)) 243 matched = (match_mode == MATCH_SET); 244else if(ATTR_FALSE(value)) 245 matched = (match_mode == MATCH_UNSET); 246else if(ATTR_UNSET(value)) 247 matched = (match_mode == MATCH_UNSPECIFIED); 248else 249 matched = (match_mode == MATCH_VALUE && 250!strcmp(item->attr_match[i].value, value)); 251if(!matched) 252return0; 253} 254 255return1; 256} 257 258/* 259 * Does 'match' match the given name? 260 * A match is found if 261 * 262 * (1) the 'match' string is leading directory of 'name', or 263 * (2) the 'match' string is a wildcard and matches 'name', or 264 * (3) the 'match' string is exactly the same as 'name'. 265 * 266 * and the return value tells which case it was. 267 * 268 * It returns 0 when there is no match. 269 */ 270static intmatch_pathspec_item(const struct pathspec_item *item,int prefix, 271const char*name,int namelen,unsigned flags) 272{ 273/* name/namelen has prefix cut off by caller */ 274const char*match = item->match + prefix; 275int matchlen = item->len - prefix; 276 277/* 278 * The normal call pattern is: 279 * 1. prefix = common_prefix_len(ps); 280 * 2. prune something, or fill_directory 281 * 3. match_pathspec() 282 * 283 * 'prefix' at #1 may be shorter than the command's prefix and 284 * it's ok for #2 to match extra files. Those extras will be 285 * trimmed at #3. 286 * 287 * Suppose the pathspec is 'foo' and '../bar' running from 288 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 289 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 290 * user does not want XYZ/foo, only the "foo" part should be 291 * case-insensitive. We need to filter out XYZ/foo here. In 292 * other words, we do not trust the caller on comparing the 293 * prefix part when :(icase) is involved. We do exact 294 * comparison ourselves. 295 * 296 * Normally the caller (common_prefix_len() in fact) does 297 * _exact_ matching on name[-prefix+1..-1] and we do not need 298 * to check that part. Be defensive and check it anyway, in 299 * case common_prefix_len is changed, or a new caller is 300 * introduced that does not use common_prefix_len. 301 * 302 * If the penalty turns out too high when prefix is really 303 * long, maybe change it to 304 * strncmp(match, name, item->prefix - prefix) 305 */ 306if(item->prefix && (item->magic & PATHSPEC_ICASE) && 307strncmp(item->match, name - prefix, item->prefix)) 308return0; 309 310if(item->attr_match_nr && !match_attrs(name, namelen, item)) 311return0; 312 313/* If the match was just the prefix, we matched */ 314if(!*match) 315return MATCHED_RECURSIVELY; 316 317if(matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 318if(matchlen == namelen) 319return MATCHED_EXACTLY; 320 321if(match[matchlen-1] =='/'|| name[matchlen] =='/') 322return MATCHED_RECURSIVELY; 323}else if((flags & DO_MATCH_DIRECTORY) && 324 match[matchlen -1] =='/'&& 325 namelen == matchlen -1&& 326!ps_strncmp(item, match, name, namelen)) 327return MATCHED_EXACTLY; 328 329if(item->nowildcard_len < item->len && 330!git_fnmatch(item, match, name, 331 item->nowildcard_len - prefix)) 332return MATCHED_FNMATCH; 333 334/* Perform checks to see if "name" is a super set of the pathspec */ 335if(flags & DO_MATCH_SUBMODULE) { 336/* name is a literal prefix of the pathspec */ 337if((namelen < matchlen) && 338(match[namelen] =='/') && 339!ps_strncmp(item, match, name, namelen)) 340return MATCHED_RECURSIVELY; 341 342/* name" doesn't match up to the first wild character */ 343if(item->nowildcard_len < item->len && 344ps_strncmp(item, match, name, 345 item->nowildcard_len - prefix)) 346return0; 347 348/* 349 * Here is where we would perform a wildmatch to check if 350 * "name" can be matched as a directory (or a prefix) against 351 * the pathspec. Since wildmatch doesn't have this capability 352 * at the present we have to punt and say that it is a match, 353 * potentially returning a false positive 354 * The submodules themselves will be able to perform more 355 * accurate matching to determine if the pathspec matches. 356 */ 357return MATCHED_RECURSIVELY; 358} 359 360return0; 361} 362 363/* 364 * Given a name and a list of pathspecs, returns the nature of the 365 * closest (i.e. most specific) match of the name to any of the 366 * pathspecs. 367 * 368 * The caller typically calls this multiple times with the same 369 * pathspec and seen[] array but with different name/namelen 370 * (e.g. entries from the index) and is interested in seeing if and 371 * how each pathspec matches all the names it calls this function 372 * with. A mark is left in the seen[] array for each pathspec element 373 * indicating the closest type of match that element achieved, so if 374 * seen[n] remains zero after multiple invocations, that means the nth 375 * pathspec did not match any names, which could indicate that the 376 * user mistyped the nth pathspec. 377 */ 378static intdo_match_pathspec(const struct pathspec *ps, 379const char*name,int namelen, 380int prefix,char*seen, 381unsigned flags) 382{ 383int i, retval =0, exclude = flags & DO_MATCH_EXCLUDE; 384 385GUARD_PATHSPEC(ps, 386 PATHSPEC_FROMTOP | 387 PATHSPEC_MAXDEPTH | 388 PATHSPEC_LITERAL | 389 PATHSPEC_GLOB | 390 PATHSPEC_ICASE | 391 PATHSPEC_EXCLUDE | 392 PATHSPEC_ATTR); 393 394if(!ps->nr) { 395if(!ps->recursive || 396!(ps->magic & PATHSPEC_MAXDEPTH) || 397 ps->max_depth == -1) 398return MATCHED_RECURSIVELY; 399 400if(within_depth(name, namelen,0, ps->max_depth)) 401return MATCHED_EXACTLY; 402else 403return0; 404} 405 406 name += prefix; 407 namelen -= prefix; 408 409for(i = ps->nr -1; i >=0; i--) { 410int how; 411 412if((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 413( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 414continue; 415 416if(seen && seen[i] == MATCHED_EXACTLY) 417continue; 418/* 419 * Make exclude patterns optional and never report 420 * "pathspec ':(exclude)foo' matches no files" 421 */ 422if(seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 423 seen[i] = MATCHED_FNMATCH; 424 how =match_pathspec_item(ps->items+i, prefix, name, 425 namelen, flags); 426if(ps->recursive && 427(ps->magic & PATHSPEC_MAXDEPTH) && 428 ps->max_depth != -1&& 429 how && how != MATCHED_FNMATCH) { 430int len = ps->items[i].len; 431if(name[len] =='/') 432 len++; 433if(within_depth(name+len, namelen-len,0, ps->max_depth)) 434 how = MATCHED_EXACTLY; 435else 436 how =0; 437} 438if(how) { 439if(retval < how) 440 retval = how; 441if(seen && seen[i] < how) 442 seen[i] = how; 443} 444} 445return retval; 446} 447 448intmatch_pathspec(const struct pathspec *ps, 449const char*name,int namelen, 450int prefix,char*seen,int is_dir) 451{ 452int positive, negative; 453unsigned flags = is_dir ? DO_MATCH_DIRECTORY :0; 454 positive =do_match_pathspec(ps, name, namelen, 455 prefix, seen, flags); 456if(!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 457return positive; 458 negative =do_match_pathspec(ps, name, namelen, 459 prefix, seen, 460 flags | DO_MATCH_EXCLUDE); 461return negative ?0: positive; 462} 463 464/** 465 * Check if a submodule is a superset of the pathspec 466 */ 467intsubmodule_path_match(const struct pathspec *ps, 468const char*submodule_name, 469char*seen) 470{ 471int matched =do_match_pathspec(ps, submodule_name, 472strlen(submodule_name), 4730, seen, 474 DO_MATCH_DIRECTORY | 475 DO_MATCH_SUBMODULE); 476return matched; 477} 478 479intreport_path_error(const char*ps_matched, 480const struct pathspec *pathspec, 481const char*prefix) 482{ 483/* 484 * Make sure all pathspec matched; otherwise it is an error. 485 */ 486int num, errors =0; 487for(num =0; num < pathspec->nr; num++) { 488int other, found_dup; 489 490if(ps_matched[num]) 491continue; 492/* 493 * The caller might have fed identical pathspec 494 * twice. Do not barf on such a mistake. 495 * FIXME: parse_pathspec should have eliminated 496 * duplicate pathspec. 497 */ 498for(found_dup = other =0; 499!found_dup && other < pathspec->nr; 500 other++) { 501if(other == num || !ps_matched[other]) 502continue; 503if(!strcmp(pathspec->items[other].original, 504 pathspec->items[num].original)) 505/* 506 * Ok, we have a match already. 507 */ 508 found_dup =1; 509} 510if(found_dup) 511continue; 512 513error("pathspec '%s' did not match any file(s) known to git.", 514 pathspec->items[num].original); 515 errors++; 516} 517return errors; 518} 519 520/* 521 * Return the length of the "simple" part of a path match limiter. 522 */ 523intsimple_length(const char*match) 524{ 525int len = -1; 526 527for(;;) { 528unsigned char c = *match++; 529 len++; 530if(c =='\0'||is_glob_special(c)) 531return len; 532} 533} 534 535intno_wildcard(const char*string) 536{ 537return string[simple_length(string)] =='\0'; 538} 539 540voidparse_exclude_pattern(const char**pattern, 541int*patternlen, 542unsigned*flags, 543int*nowildcardlen) 544{ 545const char*p = *pattern; 546size_t i, len; 547 548*flags =0; 549if(*p =='!') { 550*flags |= EXC_FLAG_NEGATIVE; 551 p++; 552} 553 len =strlen(p); 554if(len && p[len -1] =='/') { 555 len--; 556*flags |= EXC_FLAG_MUSTBEDIR; 557} 558for(i =0; i < len; i++) { 559if(p[i] =='/') 560break; 561} 562if(i == len) 563*flags |= EXC_FLAG_NODIR; 564*nowildcardlen =simple_length(p); 565/* 566 * we should have excluded the trailing slash from 'p' too, 567 * but that's one more allocation. Instead just make sure 568 * nowildcardlen does not exceed real patternlen 569 */ 570if(*nowildcardlen > len) 571*nowildcardlen = len; 572if(*p =='*'&&no_wildcard(p +1)) 573*flags |= EXC_FLAG_ENDSWITH; 574*pattern = p; 575*patternlen = len; 576} 577 578voidadd_exclude(const char*string,const char*base, 579int baselen,struct exclude_list *el,int srcpos) 580{ 581struct exclude *x; 582int patternlen; 583unsigned flags; 584int nowildcardlen; 585 586parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 587if(flags & EXC_FLAG_MUSTBEDIR) { 588FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 589}else{ 590 x =xmalloc(sizeof(*x)); 591 x->pattern = string; 592} 593 x->patternlen = patternlen; 594 x->nowildcardlen = nowildcardlen; 595 x->base = base; 596 x->baselen = baselen; 597 x->flags = flags; 598 x->srcpos = srcpos; 599ALLOC_GROW(el->excludes, el->nr +1, el->alloc); 600 el->excludes[el->nr++] = x; 601 x->el = el; 602} 603 604static void*read_skip_worktree_file_from_index(const struct index_state *istate, 605const char*path,size_t*size, 606struct sha1_stat *sha1_stat) 607{ 608int pos, len; 609unsigned long sz; 610enum object_type type; 611void*data; 612 613 len =strlen(path); 614 pos =index_name_pos(istate, path, len); 615if(pos <0) 616return NULL; 617if(!ce_skip_worktree(istate->cache[pos])) 618return NULL; 619 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz); 620if(!data || type != OBJ_BLOB) { 621free(data); 622return NULL; 623} 624*size =xsize_t(sz); 625if(sha1_stat) { 626memset(&sha1_stat->stat,0,sizeof(sha1_stat->stat)); 627hashcpy(sha1_stat->sha1, istate->cache[pos]->oid.hash); 628} 629return data; 630} 631 632/* 633 * Frees memory within el which was allocated for exclude patterns and 634 * the file buffer. Does not free el itself. 635 */ 636voidclear_exclude_list(struct exclude_list *el) 637{ 638int i; 639 640for(i =0; i < el->nr; i++) 641free(el->excludes[i]); 642free(el->excludes); 643free(el->filebuf); 644 645memset(el,0,sizeof(*el)); 646} 647 648static voidtrim_trailing_spaces(char*buf) 649{ 650char*p, *last_space = NULL; 651 652for(p = buf; *p; p++) 653switch(*p) { 654case' ': 655if(!last_space) 656 last_space = p; 657break; 658case'\\': 659 p++; 660if(!*p) 661return; 662/* fallthrough */ 663default: 664 last_space = NULL; 665} 666 667if(last_space) 668*last_space ='\0'; 669} 670 671/* 672 * Given a subdirectory name and "dir" of the current directory, 673 * search the subdir in "dir" and return it, or create a new one if it 674 * does not exist in "dir". 675 * 676 * If "name" has the trailing slash, it'll be excluded in the search. 677 */ 678static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 679struct untracked_cache_dir *dir, 680const char*name,int len) 681{ 682int first, last; 683struct untracked_cache_dir *d; 684if(!dir) 685return NULL; 686if(len && name[len -1] =='/') 687 len--; 688 first =0; 689 last = dir->dirs_nr; 690while(last > first) { 691int cmp, next = (last + first) >>1; 692 d = dir->dirs[next]; 693 cmp =strncmp(name, d->name, len); 694if(!cmp &&strlen(d->name) > len) 695 cmp = -1; 696if(!cmp) 697return d; 698if(cmp <0) { 699 last = next; 700continue; 701} 702 first = next+1; 703} 704 705 uc->dir_created++; 706FLEX_ALLOC_MEM(d, name, name, len); 707 708ALLOC_GROW(dir->dirs, dir->dirs_nr +1, dir->dirs_alloc); 709memmove(dir->dirs + first +1, dir->dirs + first, 710(dir->dirs_nr - first) *sizeof(*dir->dirs)); 711 dir->dirs_nr++; 712 dir->dirs[first] = d; 713return d; 714} 715 716static voiddo_invalidate_gitignore(struct untracked_cache_dir *dir) 717{ 718int i; 719 dir->valid =0; 720 dir->untracked_nr =0; 721for(i =0; i < dir->dirs_nr; i++) 722do_invalidate_gitignore(dir->dirs[i]); 723} 724 725static voidinvalidate_gitignore(struct untracked_cache *uc, 726struct untracked_cache_dir *dir) 727{ 728 uc->gitignore_invalidated++; 729do_invalidate_gitignore(dir); 730} 731 732static voidinvalidate_directory(struct untracked_cache *uc, 733struct untracked_cache_dir *dir) 734{ 735int i; 736 uc->dir_invalidated++; 737 dir->valid =0; 738 dir->untracked_nr =0; 739for(i =0; i < dir->dirs_nr; i++) 740 dir->dirs[i]->recurse =0; 741} 742 743/* 744 * Given a file with name "fname", read it (either from disk, or from 745 * an index if 'istate' is non-null), parse it and store the 746 * exclude rules in "el". 747 * 748 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 749 * stat data from disk (only valid if add_excludes returns zero). If 750 * ss_valid is non-zero, "ss" must contain good value as input. 751 */ 752static intadd_excludes(const char*fname,const char*base,int baselen, 753struct exclude_list *el, 754struct index_state *istate, 755struct sha1_stat *sha1_stat) 756{ 757struct stat st; 758int fd, i, lineno =1; 759size_t size =0; 760char*buf, *entry; 761 762 fd =open(fname, O_RDONLY); 763if(fd <0||fstat(fd, &st) <0) { 764if(fd <0) 765warn_on_fopen_errors(fname); 766else 767close(fd); 768if(!istate || 769(buf =read_skip_worktree_file_from_index(istate, fname, &size, sha1_stat)) == NULL) 770return-1; 771if(size ==0) { 772free(buf); 773return0; 774} 775if(buf[size-1] !='\n') { 776 buf =xrealloc(buf,st_add(size,1)); 777 buf[size++] ='\n'; 778} 779}else{ 780 size =xsize_t(st.st_size); 781if(size ==0) { 782if(sha1_stat) { 783fill_stat_data(&sha1_stat->stat, &st); 784hashcpy(sha1_stat->sha1, EMPTY_BLOB_SHA1_BIN); 785 sha1_stat->valid =1; 786} 787close(fd); 788return0; 789} 790 buf =xmallocz(size); 791if(read_in_full(fd, buf, size) != size) { 792free(buf); 793close(fd); 794return-1; 795} 796 buf[size++] ='\n'; 797close(fd); 798if(sha1_stat) { 799int pos; 800if(sha1_stat->valid && 801!match_stat_data_racy(istate, &sha1_stat->stat, &st)) 802;/* no content change, ss->sha1 still good */ 803else if(istate && 804(pos =index_name_pos(istate, fname,strlen(fname))) >=0&& 805!ce_stage(istate->cache[pos]) && 806ce_uptodate(istate->cache[pos]) && 807!would_convert_to_git(istate, fname)) 808hashcpy(sha1_stat->sha1, 809 istate->cache[pos]->oid.hash); 810else 811hash_sha1_file(buf, size,"blob", sha1_stat->sha1); 812fill_stat_data(&sha1_stat->stat, &st); 813 sha1_stat->valid =1; 814} 815} 816 817 el->filebuf = buf; 818 819if(skip_utf8_bom(&buf, size)) 820 size -= buf - el->filebuf; 821 822 entry = buf; 823 824for(i =0; i < size; i++) { 825if(buf[i] =='\n') { 826if(entry != buf + i && entry[0] !='#') { 827 buf[i - (i && buf[i-1] =='\r')] =0; 828trim_trailing_spaces(entry); 829add_exclude(entry, base, baselen, el, lineno); 830} 831 lineno++; 832 entry = buf + i +1; 833} 834} 835return0; 836} 837 838intadd_excludes_from_file_to_list(const char*fname,const char*base, 839int baselen,struct exclude_list *el, 840struct index_state *istate) 841{ 842returnadd_excludes(fname, base, baselen, el, istate, NULL); 843} 844 845struct exclude_list *add_exclude_list(struct dir_struct *dir, 846int group_type,const char*src) 847{ 848struct exclude_list *el; 849struct exclude_list_group *group; 850 851 group = &dir->exclude_list_group[group_type]; 852ALLOC_GROW(group->el, group->nr +1, group->alloc); 853 el = &group->el[group->nr++]; 854memset(el,0,sizeof(*el)); 855 el->src = src; 856return el; 857} 858 859/* 860 * Used to set up core.excludesfile and .git/info/exclude lists. 861 */ 862static voidadd_excludes_from_file_1(struct dir_struct *dir,const char*fname, 863struct sha1_stat *sha1_stat) 864{ 865struct exclude_list *el; 866/* 867 * catch setup_standard_excludes() that's called before 868 * dir->untracked is assigned. That function behaves 869 * differently when dir->untracked is non-NULL. 870 */ 871if(!dir->untracked) 872 dir->unmanaged_exclude_files++; 873 el =add_exclude_list(dir, EXC_FILE, fname); 874if(add_excludes(fname,"",0, el, NULL, sha1_stat) <0) 875die("cannot use%sas an exclude file", fname); 876} 877 878voidadd_excludes_from_file(struct dir_struct *dir,const char*fname) 879{ 880 dir->unmanaged_exclude_files++;/* see validate_untracked_cache() */ 881add_excludes_from_file_1(dir, fname, NULL); 882} 883 884intmatch_basename(const char*basename,int basenamelen, 885const char*pattern,int prefix,int patternlen, 886unsigned flags) 887{ 888if(prefix == patternlen) { 889if(patternlen == basenamelen && 890!fspathncmp(pattern, basename, basenamelen)) 891return1; 892}else if(flags & EXC_FLAG_ENDSWITH) { 893/* "*literal" matching against "fooliteral" */ 894if(patternlen -1<= basenamelen && 895!fspathncmp(pattern +1, 896 basename + basenamelen - (patternlen -1), 897 patternlen -1)) 898return1; 899}else{ 900if(fnmatch_icase_mem(pattern, patternlen, 901 basename, basenamelen, 9020) ==0) 903return1; 904} 905return0; 906} 907 908intmatch_pathname(const char*pathname,int pathlen, 909const char*base,int baselen, 910const char*pattern,int prefix,int patternlen, 911unsigned flags) 912{ 913const char*name; 914int namelen; 915 916/* 917 * match with FNM_PATHNAME; the pattern has base implicitly 918 * in front of it. 919 */ 920if(*pattern =='/') { 921 pattern++; 922 patternlen--; 923 prefix--; 924} 925 926/* 927 * baselen does not count the trailing slash. base[] may or 928 * may not end with a trailing slash though. 929 */ 930if(pathlen < baselen +1|| 931(baselen && pathname[baselen] !='/') || 932fspathncmp(pathname, base, baselen)) 933return0; 934 935 namelen = baselen ? pathlen - baselen -1: pathlen; 936 name = pathname + pathlen - namelen; 937 938if(prefix) { 939/* 940 * if the non-wildcard part is longer than the 941 * remaining pathname, surely it cannot match. 942 */ 943if(prefix > namelen) 944return0; 945 946if(fspathncmp(pattern, name, prefix)) 947return0; 948 pattern += prefix; 949 patternlen -= prefix; 950 name += prefix; 951 namelen -= prefix; 952 953/* 954 * If the whole pattern did not have a wildcard, 955 * then our prefix match is all we need; we 956 * do not need to call fnmatch at all. 957 */ 958if(!patternlen && !namelen) 959return1; 960} 961 962returnfnmatch_icase_mem(pattern, patternlen, 963 name, namelen, 964 WM_PATHNAME) ==0; 965} 966 967/* 968 * Scan the given exclude list in reverse to see whether pathname 969 * should be ignored. The first match (i.e. the last on the list), if 970 * any, determines the fate. Returns the exclude_list element which 971 * matched, or NULL for undecided. 972 */ 973static struct exclude *last_exclude_matching_from_list(const char*pathname, 974int pathlen, 975const char*basename, 976int*dtype, 977struct exclude_list *el, 978struct index_state *istate) 979{ 980struct exclude *exc = NULL;/* undecided */ 981int i; 982 983if(!el->nr) 984return NULL;/* undefined */ 985 986for(i = el->nr -1;0<= i; i--) { 987struct exclude *x = el->excludes[i]; 988const char*exclude = x->pattern; 989int prefix = x->nowildcardlen; 990 991if(x->flags & EXC_FLAG_MUSTBEDIR) { 992if(*dtype == DT_UNKNOWN) 993*dtype =get_dtype(NULL, istate, pathname, pathlen); 994if(*dtype != DT_DIR) 995continue; 996} 997 998if(x->flags & EXC_FLAG_NODIR) { 999if(match_basename(basename,1000 pathlen - (basename - pathname),1001 exclude, prefix, x->patternlen,1002 x->flags)) {1003 exc = x;1004break;1005}1006continue;1007}10081009assert(x->baselen ==0|| x->base[x->baselen -1] =='/');1010if(match_pathname(pathname, pathlen,1011 x->base, x->baselen ? x->baselen -1:0,1012 exclude, prefix, x->patternlen, x->flags)) {1013 exc = x;1014break;1015}1016}1017return exc;1018}10191020/*1021 * Scan the list and let the last match determine the fate.1022 * Return 1 for exclude, 0 for include and -1 for undecided.1023 */1024intis_excluded_from_list(const char*pathname,1025int pathlen,const char*basename,int*dtype,1026struct exclude_list *el,struct index_state *istate)1027{1028struct exclude *exclude;1029 exclude =last_exclude_matching_from_list(pathname, pathlen, basename,1030 dtype, el, istate);1031if(exclude)1032return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1033return-1;/* undecided */1034}10351036static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1037struct index_state *istate,1038const char*pathname,int pathlen,const char*basename,1039int*dtype_p)1040{1041int i, j;1042struct exclude_list_group *group;1043struct exclude *exclude;1044for(i = EXC_CMDL; i <= EXC_FILE; i++) {1045 group = &dir->exclude_list_group[i];1046for(j = group->nr -1; j >=0; j--) {1047 exclude =last_exclude_matching_from_list(1048 pathname, pathlen, basename, dtype_p,1049&group->el[j], istate);1050if(exclude)1051return exclude;1052}1053}1054return NULL;1055}10561057/*1058 * Loads the per-directory exclude list for the substring of base1059 * which has a char length of baselen.1060 */1061static voidprep_exclude(struct dir_struct *dir,1062struct index_state *istate,1063const char*base,int baselen)1064{1065struct exclude_list_group *group;1066struct exclude_list *el;1067struct exclude_stack *stk = NULL;1068struct untracked_cache_dir *untracked;1069int current;10701071 group = &dir->exclude_list_group[EXC_DIRS];10721073/*1074 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1075 * which originate from directories not in the prefix of the1076 * path being checked.1077 */1078while((stk = dir->exclude_stack) != NULL) {1079if(stk->baselen <= baselen &&1080!strncmp(dir->basebuf.buf, base, stk->baselen))1081break;1082 el = &group->el[dir->exclude_stack->exclude_ix];1083 dir->exclude_stack = stk->prev;1084 dir->exclude = NULL;1085free((char*)el->src);/* see strbuf_detach() below */1086clear_exclude_list(el);1087free(stk);1088 group->nr--;1089}10901091/* Skip traversing into sub directories if the parent is excluded */1092if(dir->exclude)1093return;10941095/*1096 * Lazy initialization. All call sites currently just1097 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1098 * them seems lots of work for little benefit.1099 */1100if(!dir->basebuf.buf)1101strbuf_init(&dir->basebuf, PATH_MAX);11021103/* Read from the parent directories and push them down. */1104 current = stk ? stk->baselen : -1;1105strbuf_setlen(&dir->basebuf, current <0?0: current);1106if(dir->untracked)1107 untracked = stk ? stk->ucd : dir->untracked->root;1108else1109 untracked = NULL;11101111while(current < baselen) {1112const char*cp;1113struct sha1_stat sha1_stat;11141115 stk =xcalloc(1,sizeof(*stk));1116if(current <0) {1117 cp = base;1118 current =0;1119}else{1120 cp =strchr(base + current +1,'/');1121if(!cp)1122die("oops in prep_exclude");1123 cp++;1124 untracked =1125lookup_untracked(dir->untracked, untracked,1126 base + current,1127 cp - base - current);1128}1129 stk->prev = dir->exclude_stack;1130 stk->baselen = cp - base;1131 stk->exclude_ix = group->nr;1132 stk->ucd = untracked;1133 el =add_exclude_list(dir, EXC_DIRS, NULL);1134strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1135assert(stk->baselen == dir->basebuf.len);11361137/* Abort if the directory is excluded */1138if(stk->baselen) {1139int dt = DT_DIR;1140 dir->basebuf.buf[stk->baselen -1] =0;1141 dir->exclude =last_exclude_matching_from_lists(dir,1142 istate,1143 dir->basebuf.buf, stk->baselen -1,1144 dir->basebuf.buf + current, &dt);1145 dir->basebuf.buf[stk->baselen -1] ='/';1146if(dir->exclude &&1147 dir->exclude->flags & EXC_FLAG_NEGATIVE)1148 dir->exclude = NULL;1149if(dir->exclude) {1150 dir->exclude_stack = stk;1151return;1152}1153}11541155/* Try to read per-directory file */1156hashclr(sha1_stat.sha1);1157 sha1_stat.valid =0;1158if(dir->exclude_per_dir &&1159/*1160 * If we know that no files have been added in1161 * this directory (i.e. valid_cached_dir() has1162 * been executed and set untracked->valid) ..1163 */1164(!untracked || !untracked->valid ||1165/*1166 * .. and .gitignore does not exist before1167 * (i.e. null exclude_sha1). Then we can skip1168 * loading .gitignore, which would result in1169 * ENOENT anyway.1170 */1171!is_null_sha1(untracked->exclude_sha1))) {1172/*1173 * dir->basebuf gets reused by the traversal, but we1174 * need fname to remain unchanged to ensure the src1175 * member of each struct exclude correctly1176 * back-references its source file. Other invocations1177 * of add_exclude_list provide stable strings, so we1178 * strbuf_detach() and free() here in the caller.1179 */1180struct strbuf sb = STRBUF_INIT;1181strbuf_addbuf(&sb, &dir->basebuf);1182strbuf_addstr(&sb, dir->exclude_per_dir);1183 el->src =strbuf_detach(&sb, NULL);1184add_excludes(el->src, el->src, stk->baselen, el, istate,1185 untracked ? &sha1_stat : NULL);1186}1187/*1188 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1189 * will first be called in valid_cached_dir() then maybe many1190 * times more in last_exclude_matching(). When the cache is1191 * used, last_exclude_matching() will not be called and1192 * reading .gitignore content will be a waste.1193 *1194 * So when it's called by valid_cached_dir() and we can get1195 * .gitignore SHA-1 from the index (i.e. .gitignore is not1196 * modified on work tree), we could delay reading the1197 * .gitignore content until we absolutely need it in1198 * last_exclude_matching(). Be careful about ignore rule1199 * order, though, if you do that.1200 */1201if(untracked &&1202hashcmp(sha1_stat.sha1, untracked->exclude_sha1)) {1203invalidate_gitignore(dir->untracked, untracked);1204hashcpy(untracked->exclude_sha1, sha1_stat.sha1);1205}1206 dir->exclude_stack = stk;1207 current = stk->baselen;1208}1209strbuf_setlen(&dir->basebuf, baselen);1210}12111212/*1213 * Loads the exclude lists for the directory containing pathname, then1214 * scans all exclude lists to determine whether pathname is excluded.1215 * Returns the exclude_list element which matched, or NULL for1216 * undecided.1217 */1218struct exclude *last_exclude_matching(struct dir_struct *dir,1219struct index_state *istate,1220const char*pathname,1221int*dtype_p)1222{1223int pathlen =strlen(pathname);1224const char*basename =strrchr(pathname,'/');1225 basename = (basename) ? basename+1: pathname;12261227prep_exclude(dir, istate, pathname, basename-pathname);12281229if(dir->exclude)1230return dir->exclude;12311232returnlast_exclude_matching_from_lists(dir, istate, pathname, pathlen,1233 basename, dtype_p);1234}12351236/*1237 * Loads the exclude lists for the directory containing pathname, then1238 * scans all exclude lists to determine whether pathname is excluded.1239 * Returns 1 if true, otherwise 0.1240 */1241intis_excluded(struct dir_struct *dir,struct index_state *istate,1242const char*pathname,int*dtype_p)1243{1244struct exclude *exclude =1245last_exclude_matching(dir, istate, pathname, dtype_p);1246if(exclude)1247return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1248return0;1249}12501251static struct dir_entry *dir_entry_new(const char*pathname,int len)1252{1253struct dir_entry *ent;12541255FLEX_ALLOC_MEM(ent, name, pathname, len);1256 ent->len = len;1257return ent;1258}12591260static struct dir_entry *dir_add_name(struct dir_struct *dir,1261struct index_state *istate,1262const char*pathname,int len)1263{1264if(index_file_exists(istate, pathname, len, ignore_case))1265return NULL;12661267ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1268return dir->entries[dir->nr++] =dir_entry_new(pathname, len);1269}12701271struct dir_entry *dir_add_ignored(struct dir_struct *dir,1272struct index_state *istate,1273const char*pathname,int len)1274{1275if(!index_name_is_other(istate, pathname, len))1276return NULL;12771278ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1279return dir->ignored[dir->ignored_nr++] =dir_entry_new(pathname, len);1280}12811282enum exist_status {1283 index_nonexistent =0,1284 index_directory,1285 index_gitdir1286};12871288/*1289 * Do not use the alphabetically sorted index to look up1290 * the directory name; instead, use the case insensitive1291 * directory hash.1292 */1293static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1294const char*dirname,int len)1295{1296struct cache_entry *ce;12971298if(index_dir_exists(istate, dirname, len))1299return index_directory;13001301 ce =index_file_exists(istate, dirname, len, ignore_case);1302if(ce &&S_ISGITLINK(ce->ce_mode))1303return index_gitdir;13041305return index_nonexistent;1306}13071308/*1309 * The index sorts alphabetically by entry name, which1310 * means that a gitlink sorts as '\0' at the end, while1311 * a directory (which is defined not as an entry, but as1312 * the files it contains) will sort with the '/' at the1313 * end.1314 */1315static enum exist_status directory_exists_in_index(struct index_state *istate,1316const char*dirname,int len)1317{1318int pos;13191320if(ignore_case)1321returndirectory_exists_in_index_icase(istate, dirname, len);13221323 pos =index_name_pos(istate, dirname, len);1324if(pos <0)1325 pos = -pos-1;1326while(pos < istate->cache_nr) {1327const struct cache_entry *ce = istate->cache[pos++];1328unsigned char endchar;13291330if(strncmp(ce->name, dirname, len))1331break;1332 endchar = ce->name[len];1333if(endchar >'/')1334break;1335if(endchar =='/')1336return index_directory;1337if(!endchar &&S_ISGITLINK(ce->ce_mode))1338return index_gitdir;1339}1340return index_nonexistent;1341}13421343/*1344 * When we find a directory when traversing the filesystem, we1345 * have three distinct cases:1346 *1347 * - ignore it1348 * - see it as a directory1349 * - recurse into it1350 *1351 * and which one we choose depends on a combination of existing1352 * git index contents and the flags passed into the directory1353 * traversal routine.1354 *1355 * Case 1: If we *already* have entries in the index under that1356 * directory name, we always recurse into the directory to see1357 * all the files.1358 *1359 * Case 2: If we *already* have that directory name as a gitlink,1360 * we always continue to see it as a gitlink, regardless of whether1361 * there is an actual git directory there or not (it might not1362 * be checked out as a subproject!)1363 *1364 * Case 3: if we didn't have it in the index previously, we1365 * have a few sub-cases:1366 *1367 * (a) if "show_other_directories" is true, we show it as1368 * just a directory, unless "hide_empty_directories" is1369 * also true, in which case we need to check if it contains any1370 * untracked and / or ignored files.1371 * (b) if it looks like a git directory, and we don't have1372 * 'no_gitlinks' set we treat it as a gitlink, and show it1373 * as a directory.1374 * (c) otherwise, we recurse into it.1375 */1376static enum path_treatment treat_directory(struct dir_struct *dir,1377struct index_state *istate,1378struct untracked_cache_dir *untracked,1379const char*dirname,int len,int baselen,int exclude,1380const struct pathspec *pathspec)1381{1382/* The "len-1" is to strip the final '/' */1383switch(directory_exists_in_index(istate, dirname, len-1)) {1384case index_directory:1385return path_recurse;13861387case index_gitdir:1388return path_none;13891390case index_nonexistent:1391if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1392break;1393if(!(dir->flags & DIR_NO_GITLINKS)) {1394unsigned char sha1[20];1395if(resolve_gitlink_ref(dirname,"HEAD", sha1) ==0)1396return path_untracked;1397}1398return path_recurse;1399}14001401/* This is the "show_other_directories" case */14021403if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1404return exclude ? path_excluded : path_untracked;14051406 untracked =lookup_untracked(dir->untracked, untracked,1407 dirname + baselen, len - baselen);1408returnread_directory_recursive(dir, istate, dirname, len,1409 untracked,1, pathspec);1410}14111412/*1413 * This is an inexact early pruning of any recursive directory1414 * reading - if the path cannot possibly be in the pathspec,1415 * return true, and we'll skip it early.1416 */1417static intsimplify_away(const char*path,int pathlen,1418const struct pathspec *pathspec)1419{1420int i;14211422if(!pathspec || !pathspec->nr)1423return0;14241425GUARD_PATHSPEC(pathspec,1426 PATHSPEC_FROMTOP |1427 PATHSPEC_MAXDEPTH |1428 PATHSPEC_LITERAL |1429 PATHSPEC_GLOB |1430 PATHSPEC_ICASE |1431 PATHSPEC_EXCLUDE |1432 PATHSPEC_ATTR);14331434for(i =0; i < pathspec->nr; i++) {1435const struct pathspec_item *item = &pathspec->items[i];1436int len = item->nowildcard_len;14371438if(len > pathlen)1439 len = pathlen;1440if(!ps_strncmp(item, item->match, path, len))1441return0;1442}14431444return1;1445}14461447/*1448 * This function tells us whether an excluded path matches a1449 * list of "interesting" pathspecs. That is, whether a path matched1450 * by any of the pathspecs could possibly be ignored by excluding1451 * the specified path. This can happen if:1452 *1453 * 1. the path is mentioned explicitly in the pathspec1454 *1455 * 2. the path is a directory prefix of some element in the1456 * pathspec1457 */1458static intexclude_matches_pathspec(const char*path,int pathlen,1459const struct pathspec *pathspec)1460{1461int i;14621463if(!pathspec || !pathspec->nr)1464return0;14651466GUARD_PATHSPEC(pathspec,1467 PATHSPEC_FROMTOP |1468 PATHSPEC_MAXDEPTH |1469 PATHSPEC_LITERAL |1470 PATHSPEC_GLOB |1471 PATHSPEC_ICASE |1472 PATHSPEC_EXCLUDE);14731474for(i =0; i < pathspec->nr; i++) {1475const struct pathspec_item *item = &pathspec->items[i];1476int len = item->nowildcard_len;14771478if(len == pathlen &&1479!ps_strncmp(item, item->match, path, pathlen))1480return1;1481if(len > pathlen &&1482 item->match[pathlen] =='/'&&1483!ps_strncmp(item, item->match, path, pathlen))1484return1;1485}1486return0;1487}14881489static intget_index_dtype(struct index_state *istate,1490const char*path,int len)1491{1492int pos;1493const struct cache_entry *ce;14941495 ce =index_file_exists(istate, path, len,0);1496if(ce) {1497if(!ce_uptodate(ce))1498return DT_UNKNOWN;1499if(S_ISGITLINK(ce->ce_mode))1500return DT_DIR;1501/*1502 * Nobody actually cares about the1503 * difference between DT_LNK and DT_REG1504 */1505return DT_REG;1506}15071508/* Try to look it up as a directory */1509 pos =index_name_pos(istate, path, len);1510if(pos >=0)1511return DT_UNKNOWN;1512 pos = -pos-1;1513while(pos < istate->cache_nr) {1514 ce = istate->cache[pos++];1515if(strncmp(ce->name, path, len))1516break;1517if(ce->name[len] >'/')1518break;1519if(ce->name[len] <'/')1520continue;1521if(!ce_uptodate(ce))1522break;/* continue? */1523return DT_DIR;1524}1525return DT_UNKNOWN;1526}15271528static intget_dtype(struct dirent *de,struct index_state *istate,1529const char*path,int len)1530{1531int dtype = de ?DTYPE(de) : DT_UNKNOWN;1532struct stat st;15331534if(dtype != DT_UNKNOWN)1535return dtype;1536 dtype =get_index_dtype(istate, path, len);1537if(dtype != DT_UNKNOWN)1538return dtype;1539if(lstat(path, &st))1540return dtype;1541if(S_ISREG(st.st_mode))1542return DT_REG;1543if(S_ISDIR(st.st_mode))1544return DT_DIR;1545if(S_ISLNK(st.st_mode))1546return DT_LNK;1547return dtype;1548}15491550static enum path_treatment treat_one_path(struct dir_struct *dir,1551struct untracked_cache_dir *untracked,1552struct index_state *istate,1553struct strbuf *path,1554int baselen,1555const struct pathspec *pathspec,1556int dtype,struct dirent *de)1557{1558int exclude;1559int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);15601561if(dtype == DT_UNKNOWN)1562 dtype =get_dtype(de, istate, path->buf, path->len);15631564/* Always exclude indexed files */1565if(dtype != DT_DIR && has_path_in_index)1566return path_none;15671568/*1569 * When we are looking at a directory P in the working tree,1570 * there are three cases:1571 *1572 * (1) P exists in the index. Everything inside the directory P in1573 * the working tree needs to go when P is checked out from the1574 * index.1575 *1576 * (2) P does not exist in the index, but there is P/Q in the index.1577 * We know P will stay a directory when we check out the contents1578 * of the index, but we do not know yet if there is a directory1579 * P/Q in the working tree to be killed, so we need to recurse.1580 *1581 * (3) P does not exist in the index, and there is no P/Q in the index1582 * to require P to be a directory, either. Only in this case, we1583 * know that everything inside P will not be killed without1584 * recursing.1585 */1586if((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1587(dtype == DT_DIR) &&1588!has_path_in_index &&1589(directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))1590return path_none;15911592 exclude =is_excluded(dir, istate, path->buf, &dtype);15931594/*1595 * Excluded? If we don't explicitly want to show1596 * ignored files, ignore it1597 */1598if(exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1599return path_excluded;16001601switch(dtype) {1602default:1603return path_none;1604case DT_DIR:1605strbuf_addch(path,'/');1606returntreat_directory(dir, istate, untracked, path->buf, path->len,1607 baselen, exclude, pathspec);1608case DT_REG:1609case DT_LNK:1610return exclude ? path_excluded : path_untracked;1611}1612}16131614static enum path_treatment treat_path_fast(struct dir_struct *dir,1615struct untracked_cache_dir *untracked,1616struct cached_dir *cdir,1617struct index_state *istate,1618struct strbuf *path,1619int baselen,1620const struct pathspec *pathspec)1621{1622strbuf_setlen(path, baselen);1623if(!cdir->ucd) {1624strbuf_addstr(path, cdir->file);1625return path_untracked;1626}1627strbuf_addstr(path, cdir->ucd->name);1628/* treat_one_path() does this before it calls treat_directory() */1629strbuf_complete(path,'/');1630if(cdir->ucd->check_only)1631/*1632 * check_only is set as a result of treat_directory() getting1633 * to its bottom. Verify again the same set of directories1634 * with check_only set.1635 */1636returnread_directory_recursive(dir, istate, path->buf, path->len,1637 cdir->ucd,1, pathspec);1638/*1639 * We get path_recurse in the first run when1640 * directory_exists_in_index() returns index_nonexistent. We1641 * are sure that new changes in the index does not impact the1642 * outcome. Return now.1643 */1644return path_recurse;1645}16461647static enum path_treatment treat_path(struct dir_struct *dir,1648struct untracked_cache_dir *untracked,1649struct cached_dir *cdir,1650struct index_state *istate,1651struct strbuf *path,1652int baselen,1653const struct pathspec *pathspec)1654{1655int dtype;1656struct dirent *de = cdir->de;16571658if(!de)1659returntreat_path_fast(dir, untracked, cdir, istate, path,1660 baselen, pathspec);1661if(is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name,".git"))1662return path_none;1663strbuf_setlen(path, baselen);1664strbuf_addstr(path, de->d_name);1665if(simplify_away(path->buf, path->len, pathspec))1666return path_none;16671668 dtype =DTYPE(de);1669returntreat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1670}16711672static voidadd_untracked(struct untracked_cache_dir *dir,const char*name)1673{1674if(!dir)1675return;1676ALLOC_GROW(dir->untracked, dir->untracked_nr +1,1677 dir->untracked_alloc);1678 dir->untracked[dir->untracked_nr++] =xstrdup(name);1679}16801681static intvalid_cached_dir(struct dir_struct *dir,1682struct untracked_cache_dir *untracked,1683struct index_state *istate,1684struct strbuf *path,1685int check_only)1686{1687struct stat st;16881689if(!untracked)1690return0;16911692/*1693 * With fsmonitor, we can trust the untracked cache's valid field.1694 */1695refresh_fsmonitor(istate);1696if(!(dir->untracked->use_fsmonitor && untracked->valid)) {1697if(stat(path->len ? path->buf :".", &st)) {1698invalidate_directory(dir->untracked, untracked);1699memset(&untracked->stat_data,0,sizeof(untracked->stat_data));1700return0;1701}1702if(!untracked->valid ||1703match_stat_data_racy(istate, &untracked->stat_data, &st)) {1704if(untracked->valid)1705invalidate_directory(dir->untracked, untracked);1706fill_stat_data(&untracked->stat_data, &st);1707return0;1708}1709}17101711if(untracked->check_only != !!check_only) {1712invalidate_directory(dir->untracked, untracked);1713return0;1714}17151716/*1717 * prep_exclude will be called eventually on this directory,1718 * but it's called much later in last_exclude_matching(). We1719 * need it now to determine the validity of the cache for this1720 * path. The next calls will be nearly no-op, the way1721 * prep_exclude() is designed.1722 */1723if(path->len && path->buf[path->len -1] !='/') {1724strbuf_addch(path,'/');1725prep_exclude(dir, istate, path->buf, path->len);1726strbuf_setlen(path, path->len -1);1727}else1728prep_exclude(dir, istate, path->buf, path->len);17291730/* hopefully prep_exclude() haven't invalidated this entry... */1731return untracked->valid;1732}17331734static intopen_cached_dir(struct cached_dir *cdir,1735struct dir_struct *dir,1736struct untracked_cache_dir *untracked,1737struct index_state *istate,1738struct strbuf *path,1739int check_only)1740{1741memset(cdir,0,sizeof(*cdir));1742 cdir->untracked = untracked;1743if(valid_cached_dir(dir, untracked, istate, path, check_only))1744return0;1745 cdir->fdir =opendir(path->len ? path->buf :".");1746if(dir->untracked)1747 dir->untracked->dir_opened++;1748if(!cdir->fdir)1749return-1;1750return0;1751}17521753static intread_cached_dir(struct cached_dir *cdir)1754{1755if(cdir->fdir) {1756 cdir->de =readdir(cdir->fdir);1757if(!cdir->de)1758return-1;1759return0;1760}1761while(cdir->nr_dirs < cdir->untracked->dirs_nr) {1762struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1763if(!d->recurse) {1764 cdir->nr_dirs++;1765continue;1766}1767 cdir->ucd = d;1768 cdir->nr_dirs++;1769return0;1770}1771 cdir->ucd = NULL;1772if(cdir->nr_files < cdir->untracked->untracked_nr) {1773struct untracked_cache_dir *d = cdir->untracked;1774 cdir->file = d->untracked[cdir->nr_files++];1775return0;1776}1777return-1;1778}17791780static voidclose_cached_dir(struct cached_dir *cdir)1781{1782if(cdir->fdir)1783closedir(cdir->fdir);1784/*1785 * We have gone through this directory and found no untracked1786 * entries. Mark it valid.1787 */1788if(cdir->untracked) {1789 cdir->untracked->valid =1;1790 cdir->untracked->recurse =1;1791}1792}17931794/*1795 * Read a directory tree. We currently ignore anything but1796 * directories, regular files and symlinks. That's because git1797 * doesn't handle them at all yet. Maybe that will change some1798 * day.1799 *1800 * Also, we ignore the name ".git" (even if it is not a directory).1801 * That likely will not change.1802 *1803 * Returns the most significant path_treatment value encountered in the scan.1804 */1805static enum path_treatment read_directory_recursive(struct dir_struct *dir,1806struct index_state *istate,const char*base,int baselen,1807struct untracked_cache_dir *untracked,int check_only,1808const struct pathspec *pathspec)1809{1810struct cached_dir cdir;1811enum path_treatment state, subdir_state, dir_state = path_none;1812struct strbuf path = STRBUF_INIT;18131814strbuf_add(&path, base, baselen);18151816if(open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1817goto out;18181819if(untracked)1820 untracked->check_only = !!check_only;18211822while(!read_cached_dir(&cdir)) {1823/* check how the file or directory should be treated */1824 state =treat_path(dir, untracked, &cdir, istate, &path,1825 baselen, pathspec);18261827if(state > dir_state)1828 dir_state = state;18291830/* recurse into subdir if instructed by treat_path */1831if((state == path_recurse) ||1832((state == path_untracked) &&1833(dir->flags & DIR_SHOW_IGNORED_TOO) &&1834(get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {1835struct untracked_cache_dir *ud;1836 ud =lookup_untracked(dir->untracked, untracked,1837 path.buf + baselen,1838 path.len - baselen);1839 subdir_state =1840read_directory_recursive(dir, istate, path.buf,1841 path.len, ud,1842 check_only, pathspec);1843if(subdir_state > dir_state)1844 dir_state = subdir_state;1845}18461847if(check_only) {1848/* abort early if maximum state has been reached */1849if(dir_state == path_untracked) {1850if(cdir.fdir)1851add_untracked(untracked, path.buf + baselen);1852break;1853}1854/* skip the dir_add_* part */1855continue;1856}18571858/* add the path to the appropriate result list */1859switch(state) {1860case path_excluded:1861if(dir->flags & DIR_SHOW_IGNORED)1862dir_add_name(dir, istate, path.buf, path.len);1863else if((dir->flags & DIR_SHOW_IGNORED_TOO) ||1864((dir->flags & DIR_COLLECT_IGNORED) &&1865exclude_matches_pathspec(path.buf, path.len,1866 pathspec)))1867dir_add_ignored(dir, istate, path.buf, path.len);1868break;18691870case path_untracked:1871if(dir->flags & DIR_SHOW_IGNORED)1872break;1873dir_add_name(dir, istate, path.buf, path.len);1874if(cdir.fdir)1875add_untracked(untracked, path.buf + baselen);1876break;18771878default:1879break;1880}1881}1882close_cached_dir(&cdir);1883 out:1884strbuf_release(&path);18851886return dir_state;1887}18881889intcmp_dir_entry(const void*p1,const void*p2)1890{1891const struct dir_entry *e1 = *(const struct dir_entry **)p1;1892const struct dir_entry *e2 = *(const struct dir_entry **)p2;18931894returnname_compare(e1->name, e1->len, e2->name, e2->len);1895}18961897/* check if *out lexically strictly contains *in */1898intcheck_dir_entry_contains(const struct dir_entry *out,const struct dir_entry *in)1899{1900return(out->len < in->len) &&1901(out->name[out->len -1] =='/') &&1902!memcmp(out->name, in->name, out->len);1903}19041905static inttreat_leading_path(struct dir_struct *dir,1906struct index_state *istate,1907const char*path,int len,1908const struct pathspec *pathspec)1909{1910struct strbuf sb = STRBUF_INIT;1911int baselen, rc =0;1912const char*cp;1913int old_flags = dir->flags;19141915while(len && path[len -1] =='/')1916 len--;1917if(!len)1918return1;1919 baselen =0;1920 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1921while(1) {1922 cp = path + baselen + !!baselen;1923 cp =memchr(cp,'/', path + len - cp);1924if(!cp)1925 baselen = len;1926else1927 baselen = cp - path;1928strbuf_setlen(&sb,0);1929strbuf_add(&sb, path, baselen);1930if(!is_directory(sb.buf))1931break;1932if(simplify_away(sb.buf, sb.len, pathspec))1933break;1934if(treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,1935 DT_DIR, NULL) == path_none)1936break;/* do not recurse into it */1937if(len <= baselen) {1938 rc =1;1939break;/* finished checking */1940}1941}1942strbuf_release(&sb);1943 dir->flags = old_flags;1944return rc;1945}19461947static const char*get_ident_string(void)1948{1949static struct strbuf sb = STRBUF_INIT;1950struct utsname uts;19511952if(sb.len)1953return sb.buf;1954if(uname(&uts) <0)1955die_errno(_("failed to get kernel name and information"));1956strbuf_addf(&sb,"Location%s, system%s",get_git_work_tree(),1957 uts.sysname);1958return sb.buf;1959}19601961static intident_in_untracked(const struct untracked_cache *uc)1962{1963/*1964 * Previous git versions may have saved many NUL separated1965 * strings in the "ident" field, but it is insane to manage1966 * many locations, so just take care of the first one.1967 */19681969return!strcmp(uc->ident.buf,get_ident_string());1970}19711972static voidset_untracked_ident(struct untracked_cache *uc)1973{1974strbuf_reset(&uc->ident);1975strbuf_addstr(&uc->ident,get_ident_string());19761977/*1978 * This strbuf used to contain a list of NUL separated1979 * strings, so save NUL too for backward compatibility.1980 */1981strbuf_addch(&uc->ident,0);1982}19831984static voidnew_untracked_cache(struct index_state *istate)1985{1986struct untracked_cache *uc =xcalloc(1,sizeof(*uc));1987strbuf_init(&uc->ident,100);1988 uc->exclude_per_dir =".gitignore";1989/* should be the same flags used by git-status */1990 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;1991set_untracked_ident(uc);1992 istate->untracked = uc;1993 istate->cache_changed |= UNTRACKED_CHANGED;1994}19951996voidadd_untracked_cache(struct index_state *istate)1997{1998if(!istate->untracked) {1999new_untracked_cache(istate);2000}else{2001if(!ident_in_untracked(istate->untracked)) {2002free_untracked_cache(istate->untracked);2003new_untracked_cache(istate);2004}2005}2006}20072008voidremove_untracked_cache(struct index_state *istate)2009{2010if(istate->untracked) {2011free_untracked_cache(istate->untracked);2012 istate->untracked = NULL;2013 istate->cache_changed |= UNTRACKED_CHANGED;2014}2015}20162017static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,2018int base_len,2019const struct pathspec *pathspec)2020{2021struct untracked_cache_dir *root;20222023if(!dir->untracked ||getenv("GIT_DISABLE_UNTRACKED_CACHE"))2024return NULL;20252026/*2027 * We only support $GIT_DIR/info/exclude and core.excludesfile2028 * as the global ignore rule files. Any other additions2029 * (e.g. from command line) invalidate the cache. This2030 * condition also catches running setup_standard_excludes()2031 * before setting dir->untracked!2032 */2033if(dir->unmanaged_exclude_files)2034return NULL;20352036/*2037 * Optimize for the main use case only: whole-tree git2038 * status. More work involved in treat_leading_path() if we2039 * use cache on just a subset of the worktree. pathspec2040 * support could make the matter even worse.2041 */2042if(base_len || (pathspec && pathspec->nr))2043return NULL;20442045/* Different set of flags may produce different results */2046if(dir->flags != dir->untracked->dir_flags ||2047/*2048 * See treat_directory(), case index_nonexistent. Without2049 * this flag, we may need to also cache .git file content2050 * for the resolve_gitlink_ref() call, which we don't.2051 */2052!(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2053/* We don't support collecting ignore files */2054(dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2055 DIR_COLLECT_IGNORED)))2056return NULL;20572058/*2059 * If we use .gitignore in the cache and now you change it to2060 * .gitexclude, everything will go wrong.2061 */2062if(dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2063strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2064return NULL;20652066/*2067 * EXC_CMDL is not considered in the cache. If people set it,2068 * skip the cache.2069 */2070if(dir->exclude_list_group[EXC_CMDL].nr)2071return NULL;20722073if(!ident_in_untracked(dir->untracked)) {2074warning(_("Untracked cache is disabled on this system or location."));2075return NULL;2076}20772078if(!dir->untracked->root) {2079const int len =sizeof(*dir->untracked->root);2080 dir->untracked->root =xmalloc(len);2081memset(dir->untracked->root,0, len);2082}20832084/* Validate $GIT_DIR/info/exclude and core.excludesfile */2085 root = dir->untracked->root;2086if(hashcmp(dir->ss_info_exclude.sha1,2087 dir->untracked->ss_info_exclude.sha1)) {2088invalidate_gitignore(dir->untracked, root);2089 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2090}2091if(hashcmp(dir->ss_excludes_file.sha1,2092 dir->untracked->ss_excludes_file.sha1)) {2093invalidate_gitignore(dir->untracked, root);2094 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2095}20962097/* Make sure this directory is not dropped out at saving phase */2098 root->recurse =1;2099return root;2100}21012102intread_directory(struct dir_struct *dir,struct index_state *istate,2103const char*path,int len,const struct pathspec *pathspec)2104{2105struct untracked_cache_dir *untracked;21062107if(has_symlink_leading_path(path, len))2108return dir->nr;21092110 untracked =validate_untracked_cache(dir, len, pathspec);2111if(!untracked)2112/*2113 * make sure untracked cache code path is disabled,2114 * e.g. prep_exclude()2115 */2116 dir->untracked = NULL;2117if(!len ||treat_leading_path(dir, istate, path, len, pathspec))2118read_directory_recursive(dir, istate, path, len, untracked,0, pathspec);2119QSORT(dir->entries, dir->nr, cmp_dir_entry);2120QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);21212122/*2123 * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will2124 * also pick up untracked contents of untracked dirs; by default2125 * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.2126 */2127if((dir->flags & DIR_SHOW_IGNORED_TOO) &&2128!(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {2129int i, j;21302131/* remove from dir->entries untracked contents of untracked dirs */2132for(i = j =0; j < dir->nr; j++) {2133if(i &&2134check_dir_entry_contains(dir->entries[i -1], dir->entries[j])) {2135FREE_AND_NULL(dir->entries[j]);2136}else{2137 dir->entries[i++] = dir->entries[j];2138}2139}21402141 dir->nr = i;2142}21432144if(dir->untracked) {2145static struct trace_key trace_untracked_stats =TRACE_KEY_INIT(UNTRACKED_STATS);2146trace_printf_key(&trace_untracked_stats,2147"node creation:%u\n"2148"gitignore invalidation:%u\n"2149"directory invalidation:%u\n"2150"opendir:%u\n",2151 dir->untracked->dir_created,2152 dir->untracked->gitignore_invalidated,2153 dir->untracked->dir_invalidated,2154 dir->untracked->dir_opened);2155if(dir->untracked == istate->untracked &&2156(dir->untracked->dir_opened ||2157 dir->untracked->gitignore_invalidated ||2158 dir->untracked->dir_invalidated))2159 istate->cache_changed |= UNTRACKED_CHANGED;2160if(dir->untracked != istate->untracked) {2161FREE_AND_NULL(dir->untracked);2162}2163}2164return dir->nr;2165}21662167intfile_exists(const char*f)2168{2169struct stat sb;2170returnlstat(f, &sb) ==0;2171}21722173static intcmp_icase(char a,char b)2174{2175if(a == b)2176return0;2177if(ignore_case)2178returntoupper(a) -toupper(b);2179return a - b;2180}21812182/*2183 * Given two normalized paths (a trailing slash is ok), if subdir is2184 * outside dir, return -1. Otherwise return the offset in subdir that2185 * can be used as relative path to dir.2186 */2187intdir_inside_of(const char*subdir,const char*dir)2188{2189int offset =0;21902191assert(dir && subdir && *dir && *subdir);21922193while(*dir && *subdir && !cmp_icase(*dir, *subdir)) {2194 dir++;2195 subdir++;2196 offset++;2197}21982199/* hel[p]/me vs hel[l]/yeah */2200if(*dir && *subdir)2201return-1;22022203if(!*subdir)2204return!*dir ? offset : -1;/* same dir */22052206/* foo/[b]ar vs foo/[] */2207if(is_dir_sep(dir[-1]))2208returnis_dir_sep(subdir[-1]) ? offset : -1;22092210/* foo[/]bar vs foo[] */2211returnis_dir_sep(*subdir) ? offset +1: -1;2212}22132214intis_inside_dir(const char*dir)2215{2216char*cwd;2217int rc;22182219if(!dir)2220return0;22212222 cwd =xgetcwd();2223 rc = (dir_inside_of(cwd, dir) >=0);2224free(cwd);2225return rc;2226}22272228intis_empty_dir(const char*path)2229{2230DIR*dir =opendir(path);2231struct dirent *e;2232int ret =1;22332234if(!dir)2235return0;22362237while((e =readdir(dir)) != NULL)2238if(!is_dot_or_dotdot(e->d_name)) {2239 ret =0;2240break;2241}22422243closedir(dir);2244return ret;2245}22462247static intremove_dir_recurse(struct strbuf *path,int flag,int*kept_up)2248{2249DIR*dir;2250struct dirent *e;2251int ret =0, original_len = path->len, len, kept_down =0;2252int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2253int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2254unsigned char submodule_head[20];22552256if((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2257!resolve_gitlink_ref(path->buf,"HEAD", submodule_head)) {2258/* Do not descend and nuke a nested git work tree. */2259if(kept_up)2260*kept_up =1;2261return0;2262}22632264 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2265 dir =opendir(path->buf);2266if(!dir) {2267if(errno == ENOENT)2268return keep_toplevel ? -1:0;2269else if(errno == EACCES && !keep_toplevel)2270/*2271 * An empty dir could be removable even if it2272 * is unreadable:2273 */2274returnrmdir(path->buf);2275else2276return-1;2277}2278strbuf_complete(path,'/');22792280 len = path->len;2281while((e =readdir(dir)) != NULL) {2282struct stat st;2283if(is_dot_or_dotdot(e->d_name))2284continue;22852286strbuf_setlen(path, len);2287strbuf_addstr(path, e->d_name);2288if(lstat(path->buf, &st)) {2289if(errno == ENOENT)2290/*2291 * file disappeared, which is what we2292 * wanted anyway2293 */2294continue;2295/* fall thru */2296}else if(S_ISDIR(st.st_mode)) {2297if(!remove_dir_recurse(path, flag, &kept_down))2298continue;/* happy */2299}else if(!only_empty &&2300(!unlink(path->buf) || errno == ENOENT)) {2301continue;/* happy, too */2302}23032304/* path too long, stat fails, or non-directory still exists */2305 ret = -1;2306break;2307}2308closedir(dir);23092310strbuf_setlen(path, original_len);2311if(!ret && !keep_toplevel && !kept_down)2312 ret = (!rmdir(path->buf) || errno == ENOENT) ?0: -1;2313else if(kept_up)2314/*2315 * report the uplevel that it is not an error that we2316 * did not rmdir() our directory.2317 */2318*kept_up = !ret;2319return ret;2320}23212322intremove_dir_recursively(struct strbuf *path,int flag)2323{2324returnremove_dir_recurse(path, flag, NULL);2325}23262327staticGIT_PATH_FUNC(git_path_info_exclude,"info/exclude")23282329voidsetup_standard_excludes(struct dir_struct *dir)2330{2331 dir->exclude_per_dir =".gitignore";23322333/* core.excludefile defaulting to $XDG_HOME/git/ignore */2334if(!excludes_file)2335 excludes_file =xdg_config_home("ignore");2336if(excludes_file && !access_or_warn(excludes_file, R_OK,0))2337add_excludes_from_file_1(dir, excludes_file,2338 dir->untracked ? &dir->ss_excludes_file : NULL);23392340/* per repository user preference */2341if(startup_info->have_repository) {2342const char*path =git_path_info_exclude();2343if(!access_or_warn(path, R_OK,0))2344add_excludes_from_file_1(dir, path,2345 dir->untracked ? &dir->ss_info_exclude : NULL);2346}2347}23482349intremove_path(const char*name)2350{2351char*slash;23522353if(unlink(name) && !is_missing_file_error(errno))2354return-1;23552356 slash =strrchr(name,'/');2357if(slash) {2358char*dirs =xstrdup(name);2359 slash = dirs + (slash - name);2360do{2361*slash ='\0';2362}while(rmdir(dirs) ==0&& (slash =strrchr(dirs,'/')));2363free(dirs);2364}2365return0;2366}23672368/*2369 * Frees memory within dir which was allocated for exclude lists and2370 * the exclude_stack. Does not free dir itself.2371 */2372voidclear_directory(struct dir_struct *dir)2373{2374int i, j;2375struct exclude_list_group *group;2376struct exclude_list *el;2377struct exclude_stack *stk;23782379for(i = EXC_CMDL; i <= EXC_FILE; i++) {2380 group = &dir->exclude_list_group[i];2381for(j =0; j < group->nr; j++) {2382 el = &group->el[j];2383if(i == EXC_DIRS)2384free((char*)el->src);2385clear_exclude_list(el);2386}2387free(group->el);2388}23892390 stk = dir->exclude_stack;2391while(stk) {2392struct exclude_stack *prev = stk->prev;2393free(stk);2394 stk = prev;2395}2396strbuf_release(&dir->basebuf);2397}23982399struct ondisk_untracked_cache {2400struct stat_data info_exclude_stat;2401struct stat_data excludes_file_stat;2402uint32_t dir_flags;2403unsigned char info_exclude_sha1[20];2404unsigned char excludes_file_sha1[20];2405char exclude_per_dir[FLEX_ARRAY];2406};24072408#define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)2409#define ouc_size(len) (ouc_offset(exclude_per_dir) + len + 1)24102411struct write_data {2412int index;/* number of written untracked_cache_dir */2413struct ewah_bitmap *check_only;/* from untracked_cache_dir */2414struct ewah_bitmap *valid;/* from untracked_cache_dir */2415struct ewah_bitmap *sha1_valid;/* set if exclude_sha1 is not null */2416struct strbuf out;2417struct strbuf sb_stat;2418struct strbuf sb_sha1;2419};24202421static voidstat_data_to_disk(struct stat_data *to,const struct stat_data *from)2422{2423 to->sd_ctime.sec =htonl(from->sd_ctime.sec);2424 to->sd_ctime.nsec =htonl(from->sd_ctime.nsec);2425 to->sd_mtime.sec =htonl(from->sd_mtime.sec);2426 to->sd_mtime.nsec =htonl(from->sd_mtime.nsec);2427 to->sd_dev =htonl(from->sd_dev);2428 to->sd_ino =htonl(from->sd_ino);2429 to->sd_uid =htonl(from->sd_uid);2430 to->sd_gid =htonl(from->sd_gid);2431 to->sd_size =htonl(from->sd_size);2432}24332434static voidwrite_one_dir(struct untracked_cache_dir *untracked,2435struct write_data *wd)2436{2437struct stat_data stat_data;2438struct strbuf *out = &wd->out;2439unsigned char intbuf[16];2440unsigned int intlen, value;2441int i = wd->index++;24422443/*2444 * untracked_nr should be reset whenever valid is clear, but2445 * for safety..2446 */2447if(!untracked->valid) {2448 untracked->untracked_nr =0;2449 untracked->check_only =0;2450}24512452if(untracked->check_only)2453ewah_set(wd->check_only, i);2454if(untracked->valid) {2455ewah_set(wd->valid, i);2456stat_data_to_disk(&stat_data, &untracked->stat_data);2457strbuf_add(&wd->sb_stat, &stat_data,sizeof(stat_data));2458}2459if(!is_null_sha1(untracked->exclude_sha1)) {2460ewah_set(wd->sha1_valid, i);2461strbuf_add(&wd->sb_sha1, untracked->exclude_sha1,20);2462}24632464 intlen =encode_varint(untracked->untracked_nr, intbuf);2465strbuf_add(out, intbuf, intlen);24662467/* skip non-recurse directories */2468for(i =0, value =0; i < untracked->dirs_nr; i++)2469if(untracked->dirs[i]->recurse)2470 value++;2471 intlen =encode_varint(value, intbuf);2472strbuf_add(out, intbuf, intlen);24732474strbuf_add(out, untracked->name,strlen(untracked->name) +1);24752476for(i =0; i < untracked->untracked_nr; i++)2477strbuf_add(out, untracked->untracked[i],2478strlen(untracked->untracked[i]) +1);24792480for(i =0; i < untracked->dirs_nr; i++)2481if(untracked->dirs[i]->recurse)2482write_one_dir(untracked->dirs[i], wd);2483}24842485voidwrite_untracked_extension(struct strbuf *out,struct untracked_cache *untracked)2486{2487struct ondisk_untracked_cache *ouc;2488struct write_data wd;2489unsigned char varbuf[16];2490int varint_len;2491size_t len =strlen(untracked->exclude_per_dir);24922493FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2494stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2495stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2496hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);2497hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.sha1);2498 ouc->dir_flags =htonl(untracked->dir_flags);24992500 varint_len =encode_varint(untracked->ident.len, varbuf);2501strbuf_add(out, varbuf, varint_len);2502strbuf_addbuf(out, &untracked->ident);25032504strbuf_add(out, ouc,ouc_size(len));2505FREE_AND_NULL(ouc);25062507if(!untracked->root) {2508 varint_len =encode_varint(0, varbuf);2509strbuf_add(out, varbuf, varint_len);2510return;2511}25122513 wd.index =0;2514 wd.check_only =ewah_new();2515 wd.valid =ewah_new();2516 wd.sha1_valid =ewah_new();2517strbuf_init(&wd.out,1024);2518strbuf_init(&wd.sb_stat,1024);2519strbuf_init(&wd.sb_sha1,1024);2520write_one_dir(untracked->root, &wd);25212522 varint_len =encode_varint(wd.index, varbuf);2523strbuf_add(out, varbuf, varint_len);2524strbuf_addbuf(out, &wd.out);2525ewah_serialize_strbuf(wd.valid, out);2526ewah_serialize_strbuf(wd.check_only, out);2527ewah_serialize_strbuf(wd.sha1_valid, out);2528strbuf_addbuf(out, &wd.sb_stat);2529strbuf_addbuf(out, &wd.sb_sha1);2530strbuf_addch(out,'\0');/* safe guard for string lists */25312532ewah_free(wd.valid);2533ewah_free(wd.check_only);2534ewah_free(wd.sha1_valid);2535strbuf_release(&wd.out);2536strbuf_release(&wd.sb_stat);2537strbuf_release(&wd.sb_sha1);2538}25392540static voidfree_untracked(struct untracked_cache_dir *ucd)2541{2542int i;2543if(!ucd)2544return;2545for(i =0; i < ucd->dirs_nr; i++)2546free_untracked(ucd->dirs[i]);2547for(i =0; i < ucd->untracked_nr; i++)2548free(ucd->untracked[i]);2549free(ucd->untracked);2550free(ucd->dirs);2551free(ucd);2552}25532554voidfree_untracked_cache(struct untracked_cache *uc)2555{2556if(uc)2557free_untracked(uc->root);2558free(uc);2559}25602561struct read_data {2562int index;2563struct untracked_cache_dir **ucd;2564struct ewah_bitmap *check_only;2565struct ewah_bitmap *valid;2566struct ewah_bitmap *sha1_valid;2567const unsigned char*data;2568const unsigned char*end;2569};25702571static voidstat_data_from_disk(struct stat_data *to,const unsigned char*data)2572{2573memcpy(to, data,sizeof(*to));2574 to->sd_ctime.sec =ntohl(to->sd_ctime.sec);2575 to->sd_ctime.nsec =ntohl(to->sd_ctime.nsec);2576 to->sd_mtime.sec =ntohl(to->sd_mtime.sec);2577 to->sd_mtime.nsec =ntohl(to->sd_mtime.nsec);2578 to->sd_dev =ntohl(to->sd_dev);2579 to->sd_ino =ntohl(to->sd_ino);2580 to->sd_uid =ntohl(to->sd_uid);2581 to->sd_gid =ntohl(to->sd_gid);2582 to->sd_size =ntohl(to->sd_size);2583}25842585static intread_one_dir(struct untracked_cache_dir **untracked_,2586struct read_data *rd)2587{2588struct untracked_cache_dir ud, *untracked;2589const unsigned char*next, *data = rd->data, *end = rd->end;2590unsigned int value;2591int i, len;25922593memset(&ud,0,sizeof(ud));25942595 next = data;2596 value =decode_varint(&next);2597if(next > end)2598return-1;2599 ud.recurse =1;2600 ud.untracked_alloc = value;2601 ud.untracked_nr = value;2602if(ud.untracked_nr)2603ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2604 data = next;26052606 next = data;2607 ud.dirs_alloc = ud.dirs_nr =decode_varint(&next);2608if(next > end)2609return-1;2610ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2611 data = next;26122613 len =strlen((const char*)data);2614 next = data + len +1;2615if(next > rd->end)2616return-1;2617*untracked_ = untracked =xmalloc(st_add(sizeof(*untracked), len));2618memcpy(untracked, &ud,sizeof(ud));2619memcpy(untracked->name, data, len +1);2620 data = next;26212622for(i =0; i < untracked->untracked_nr; i++) {2623 len =strlen((const char*)data);2624 next = data + len +1;2625if(next > rd->end)2626return-1;2627 untracked->untracked[i] =xstrdup((const char*)data);2628 data = next;2629}26302631 rd->ucd[rd->index++] = untracked;2632 rd->data = data;26332634for(i =0; i < untracked->dirs_nr; i++) {2635 len =read_one_dir(untracked->dirs + i, rd);2636if(len <0)2637return-1;2638}2639return0;2640}26412642static voidset_check_only(size_t pos,void*cb)2643{2644struct read_data *rd = cb;2645struct untracked_cache_dir *ud = rd->ucd[pos];2646 ud->check_only =1;2647}26482649static voidread_stat(size_t pos,void*cb)2650{2651struct read_data *rd = cb;2652struct untracked_cache_dir *ud = rd->ucd[pos];2653if(rd->data +sizeof(struct stat_data) > rd->end) {2654 rd->data = rd->end +1;2655return;2656}2657stat_data_from_disk(&ud->stat_data, rd->data);2658 rd->data +=sizeof(struct stat_data);2659 ud->valid =1;2660}26612662static voidread_sha1(size_t pos,void*cb)2663{2664struct read_data *rd = cb;2665struct untracked_cache_dir *ud = rd->ucd[pos];2666if(rd->data +20> rd->end) {2667 rd->data = rd->end +1;2668return;2669}2670hashcpy(ud->exclude_sha1, rd->data);2671 rd->data +=20;2672}26732674static voidload_sha1_stat(struct sha1_stat *sha1_stat,2675const unsigned char*data,2676const unsigned char*sha1)2677{2678stat_data_from_disk(&sha1_stat->stat, data);2679hashcpy(sha1_stat->sha1, sha1);2680 sha1_stat->valid =1;2681}26822683struct untracked_cache *read_untracked_extension(const void*data,unsigned long sz)2684{2685struct untracked_cache *uc;2686struct read_data rd;2687const unsigned char*next = data, *end = (const unsigned char*)data + sz;2688const char*ident;2689int ident_len, len;2690const char*exclude_per_dir;26912692if(sz <=1|| end[-1] !='\0')2693return NULL;2694 end--;26952696 ident_len =decode_varint(&next);2697if(next + ident_len > end)2698return NULL;2699 ident = (const char*)next;2700 next += ident_len;27012702if(next +ouc_size(0) > end)2703return NULL;27042705 uc =xcalloc(1,sizeof(*uc));2706strbuf_init(&uc->ident, ident_len);2707strbuf_add(&uc->ident, ident, ident_len);2708load_sha1_stat(&uc->ss_info_exclude,2709 next +ouc_offset(info_exclude_stat),2710 next +ouc_offset(info_exclude_sha1));2711load_sha1_stat(&uc->ss_excludes_file,2712 next +ouc_offset(excludes_file_stat),2713 next +ouc_offset(excludes_file_sha1));2714 uc->dir_flags =get_be32(next +ouc_offset(dir_flags));2715 exclude_per_dir = (const char*)next +ouc_offset(exclude_per_dir);2716 uc->exclude_per_dir =xstrdup(exclude_per_dir);2717/* NUL after exclude_per_dir is covered by sizeof(*ouc) */2718 next +=ouc_size(strlen(exclude_per_dir));2719if(next >= end)2720goto done2;27212722 len =decode_varint(&next);2723if(next > end || len ==0)2724goto done2;27252726 rd.valid =ewah_new();2727 rd.check_only =ewah_new();2728 rd.sha1_valid =ewah_new();2729 rd.data = next;2730 rd.end = end;2731 rd.index =0;2732ALLOC_ARRAY(rd.ucd, len);27332734if(read_one_dir(&uc->root, &rd) || rd.index != len)2735goto done;27362737 next = rd.data;2738 len =ewah_read_mmap(rd.valid, next, end - next);2739if(len <0)2740goto done;27412742 next += len;2743 len =ewah_read_mmap(rd.check_only, next, end - next);2744if(len <0)2745goto done;27462747 next += len;2748 len =ewah_read_mmap(rd.sha1_valid, next, end - next);2749if(len <0)2750goto done;27512752ewah_each_bit(rd.check_only, set_check_only, &rd);2753 rd.data = next + len;2754ewah_each_bit(rd.valid, read_stat, &rd);2755ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2756 next = rd.data;27572758done:2759free(rd.ucd);2760ewah_free(rd.valid);2761ewah_free(rd.check_only);2762ewah_free(rd.sha1_valid);2763done2:2764if(next != end) {2765free_untracked_cache(uc);2766 uc = NULL;2767}2768return uc;2769}27702771static voidinvalidate_one_directory(struct untracked_cache *uc,2772struct untracked_cache_dir *ucd)2773{2774 uc->dir_invalidated++;2775 ucd->valid =0;2776 ucd->untracked_nr =0;2777}27782779/*2780 * Normally when an entry is added or removed from a directory,2781 * invalidating that directory is enough. No need to touch its2782 * ancestors. When a directory is shown as "foo/bar/" in git-status2783 * however, deleting or adding an entry may have cascading effect.2784 *2785 * Say the "foo/bar/file" has become untracked, we need to tell the2786 * untracked_cache_dir of "foo" that "bar/" is not an untracked2787 * directory any more (because "bar" is managed by foo as an untracked2788 * "file").2789 *2790 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2791 * was the last untracked entry in the entire "foo", we should show2792 * "foo/" instead. Which means we have to invalidate past "bar" up to2793 * "foo".2794 *2795 * This function traverses all directories from root to leaf. If there2796 * is a chance of one of the above cases happening, we invalidate back2797 * to root. Otherwise we just invalidate the leaf. There may be a more2798 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2799 * detect these cases and avoid unnecessary invalidation, for example,2800 * checking for the untracked entry named "bar/" in "foo", but for now2801 * stick to something safe and simple.2802 */2803static intinvalidate_one_component(struct untracked_cache *uc,2804struct untracked_cache_dir *dir,2805const char*path,int len)2806{2807const char*rest =strchr(path,'/');28082809if(rest) {2810int component_len = rest - path;2811struct untracked_cache_dir *d =2812lookup_untracked(uc, dir, path, component_len);2813int ret =2814invalidate_one_component(uc, d, rest +1,2815 len - (component_len +1));2816if(ret)2817invalidate_one_directory(uc, dir);2818return ret;2819}28202821invalidate_one_directory(uc, dir);2822return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2823}28242825voiduntracked_cache_invalidate_path(struct index_state *istate,2826const char*path)2827{2828if(!istate->untracked || !istate->untracked->root)2829return;2830invalidate_one_component(istate->untracked, istate->untracked->root,2831 path,strlen(path));2832}28332834voiduntracked_cache_remove_from_index(struct index_state *istate,2835const char*path)2836{2837untracked_cache_invalidate_path(istate, path);2838}28392840voiduntracked_cache_add_to_index(struct index_state *istate,2841const char*path)2842{2843untracked_cache_invalidate_path(istate, path);2844}28452846/* Update gitfile and core.worktree setting to connect work tree and git dir */2847voidconnect_work_tree_and_git_dir(const char*work_tree_,const char*git_dir_)2848{2849struct strbuf gitfile_sb = STRBUF_INIT;2850struct strbuf cfg_sb = STRBUF_INIT;2851struct strbuf rel_path = STRBUF_INIT;2852char*git_dir, *work_tree;28532854/* Prepare .git file */2855strbuf_addf(&gitfile_sb,"%s/.git", work_tree_);2856if(safe_create_leading_directories_const(gitfile_sb.buf))2857die(_("could not create directories for%s"), gitfile_sb.buf);28582859/* Prepare config file */2860strbuf_addf(&cfg_sb,"%s/config", git_dir_);2861if(safe_create_leading_directories_const(cfg_sb.buf))2862die(_("could not create directories for%s"), cfg_sb.buf);28632864 git_dir =real_pathdup(git_dir_,1);2865 work_tree =real_pathdup(work_tree_,1);28662867/* Write .git file */2868write_file(gitfile_sb.buf,"gitdir:%s",2869relative_path(git_dir, work_tree, &rel_path));2870/* Update core.worktree setting */2871git_config_set_in_file(cfg_sb.buf,"core.worktree",2872relative_path(work_tree, git_dir, &rel_path));28732874strbuf_release(&gitfile_sb);2875strbuf_release(&cfg_sb);2876strbuf_release(&rel_path);2877free(work_tree);2878free(git_dir);2879}28802881/*2882 * Migrate the git directory of the given path from old_git_dir to new_git_dir.2883 */2884voidrelocate_gitdir(const char*path,const char*old_git_dir,const char*new_git_dir)2885{2886if(rename(old_git_dir, new_git_dir) <0)2887die_errno(_("could not migrate git directory from '%s' to '%s'"),2888 old_git_dir, new_git_dir);28892890connect_work_tree_and_git_dir(path, new_git_dir);2891}