1/* 2 * This handles recursive filename detection with exclude 3 * files, index knowledge etc.. 4 * 5 * See Documentation/technical/api-directory-listing.txt 6 * 7 * Copyright (C) Linus Torvalds, 2005-2006 8 * Junio Hamano, 2005-2006 9 */ 10#define NO_THE_INDEX_COMPATIBILITY_MACROS 11#include"cache.h" 12#include"dir.h" 13#include"attr.h" 14#include"refs.h" 15#include"wildmatch.h" 16#include"pathspec.h" 17#include"utf8.h" 18#include"varint.h" 19#include"ewah/ewok.h" 20 21/* 22 * Tells read_directory_recursive how a file or directory should be treated. 23 * Values are ordered by significance, e.g. if a directory contains both 24 * excluded and untracked files, it is listed as untracked because 25 * path_untracked > path_excluded. 26 */ 27enum path_treatment { 28 path_none =0, 29 path_recurse, 30 path_excluded, 31 path_untracked 32}; 33 34/* 35 * Support data structure for our opendir/readdir/closedir wrappers 36 */ 37struct cached_dir { 38DIR*fdir; 39struct untracked_cache_dir *untracked; 40int nr_files; 41int nr_dirs; 42 43struct dirent *de; 44const char*file; 45struct untracked_cache_dir *ucd; 46}; 47 48static enum path_treatment read_directory_recursive(struct dir_struct *dir, 49struct index_state *istate,const char*path,int len, 50struct untracked_cache_dir *untracked, 51int check_only,const struct pathspec *pathspec); 52static intget_dtype(struct dirent *de,struct index_state *istate, 53const char*path,int len); 54 55intfspathcmp(const char*a,const char*b) 56{ 57return ignore_case ?strcasecmp(a, b) :strcmp(a, b); 58} 59 60intfspathncmp(const char*a,const char*b,size_t count) 61{ 62return ignore_case ?strncasecmp(a, b, count) :strncmp(a, b, count); 63} 64 65intgit_fnmatch(const struct pathspec_item *item, 66const char*pattern,const char*string, 67int prefix) 68{ 69if(prefix >0) { 70if(ps_strncmp(item, pattern, string, prefix)) 71return WM_NOMATCH; 72 pattern += prefix; 73 string += prefix; 74} 75if(item->flags & PATHSPEC_ONESTAR) { 76int pattern_len =strlen(++pattern); 77int string_len =strlen(string); 78return string_len < pattern_len || 79ps_strcmp(item, pattern, 80 string + string_len - pattern_len); 81} 82if(item->magic & PATHSPEC_GLOB) 83returnwildmatch(pattern, string, 84 WM_PATHNAME | 85(item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0), 86 NULL); 87else 88/* wildmatch has not learned no FNM_PATHNAME mode yet */ 89returnwildmatch(pattern, string, 90 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0, 91 NULL); 92} 93 94static intfnmatch_icase_mem(const char*pattern,int patternlen, 95const char*string,int stringlen, 96int flags) 97{ 98int match_status; 99struct strbuf pat_buf = STRBUF_INIT; 100struct strbuf str_buf = STRBUF_INIT; 101const char*use_pat = pattern; 102const char*use_str = string; 103 104if(pattern[patternlen]) { 105strbuf_add(&pat_buf, pattern, patternlen); 106 use_pat = pat_buf.buf; 107} 108if(string[stringlen]) { 109strbuf_add(&str_buf, string, stringlen); 110 use_str = str_buf.buf; 111} 112 113if(ignore_case) 114 flags |= WM_CASEFOLD; 115 match_status =wildmatch(use_pat, use_str, flags, NULL); 116 117strbuf_release(&pat_buf); 118strbuf_release(&str_buf); 119 120return match_status; 121} 122 123static size_tcommon_prefix_len(const struct pathspec *pathspec) 124{ 125int n; 126size_t max =0; 127 128/* 129 * ":(icase)path" is treated as a pathspec full of 130 * wildcard. In other words, only prefix is considered common 131 * prefix. If the pathspec is abc/foo abc/bar, running in 132 * subdir xyz, the common prefix is still xyz, not xuz/abc as 133 * in non-:(icase). 134 */ 135GUARD_PATHSPEC(pathspec, 136 PATHSPEC_FROMTOP | 137 PATHSPEC_MAXDEPTH | 138 PATHSPEC_LITERAL | 139 PATHSPEC_GLOB | 140 PATHSPEC_ICASE | 141 PATHSPEC_EXCLUDE | 142 PATHSPEC_ATTR); 143 144for(n =0; n < pathspec->nr; n++) { 145size_t i =0, len =0, item_len; 146if(pathspec->items[n].magic & PATHSPEC_EXCLUDE) 147continue; 148if(pathspec->items[n].magic & PATHSPEC_ICASE) 149 item_len = pathspec->items[n].prefix; 150else 151 item_len = pathspec->items[n].nowildcard_len; 152while(i < item_len && (n ==0|| i < max)) { 153char c = pathspec->items[n].match[i]; 154if(c != pathspec->items[0].match[i]) 155break; 156if(c =='/') 157 len = i +1; 158 i++; 159} 160if(n ==0|| len < max) { 161 max = len; 162if(!max) 163break; 164} 165} 166return max; 167} 168 169/* 170 * Returns a copy of the longest leading path common among all 171 * pathspecs. 172 */ 173char*common_prefix(const struct pathspec *pathspec) 174{ 175unsigned long len =common_prefix_len(pathspec); 176 177return len ?xmemdupz(pathspec->items[0].match, len) : NULL; 178} 179 180intfill_directory(struct dir_struct *dir, 181struct index_state *istate, 182const struct pathspec *pathspec) 183{ 184const char*prefix; 185size_t prefix_len; 186 187/* 188 * Calculate common prefix for the pathspec, and 189 * use that to optimize the directory walk 190 */ 191 prefix_len =common_prefix_len(pathspec); 192 prefix = prefix_len ? pathspec->items[0].match :""; 193 194/* Read the directory and prune it */ 195read_directory(dir, istate, prefix, prefix_len, pathspec); 196 197return prefix_len; 198} 199 200intwithin_depth(const char*name,int namelen, 201int depth,int max_depth) 202{ 203const char*cp = name, *cpe = name + namelen; 204 205while(cp < cpe) { 206if(*cp++ !='/') 207continue; 208 depth++; 209if(depth > max_depth) 210return0; 211} 212return1; 213} 214 215#define DO_MATCH_EXCLUDE (1<<0) 216#define DO_MATCH_DIRECTORY (1<<1) 217#define DO_MATCH_SUBMODULE (1<<2) 218 219static intmatch_attrs(const char*name,int namelen, 220const struct pathspec_item *item) 221{ 222int i; 223 224git_check_attr(name, item->attr_check); 225for(i =0; i < item->attr_match_nr; i++) { 226const char*value; 227int matched; 228enum attr_match_mode match_mode; 229 230 value = item->attr_check->items[i].value; 231 match_mode = item->attr_match[i].match_mode; 232 233if(ATTR_TRUE(value)) 234 matched = (match_mode == MATCH_SET); 235else if(ATTR_FALSE(value)) 236 matched = (match_mode == MATCH_UNSET); 237else if(ATTR_UNSET(value)) 238 matched = (match_mode == MATCH_UNSPECIFIED); 239else 240 matched = (match_mode == MATCH_VALUE && 241!strcmp(item->attr_match[i].value, value)); 242if(!matched) 243return0; 244} 245 246return1; 247} 248 249/* 250 * Does 'match' match the given name? 251 * A match is found if 252 * 253 * (1) the 'match' string is leading directory of 'name', or 254 * (2) the 'match' string is a wildcard and matches 'name', or 255 * (3) the 'match' string is exactly the same as 'name'. 256 * 257 * and the return value tells which case it was. 258 * 259 * It returns 0 when there is no match. 260 */ 261static intmatch_pathspec_item(const struct pathspec_item *item,int prefix, 262const char*name,int namelen,unsigned flags) 263{ 264/* name/namelen has prefix cut off by caller */ 265const char*match = item->match + prefix; 266int matchlen = item->len - prefix; 267 268/* 269 * The normal call pattern is: 270 * 1. prefix = common_prefix_len(ps); 271 * 2. prune something, or fill_directory 272 * 3. match_pathspec() 273 * 274 * 'prefix' at #1 may be shorter than the command's prefix and 275 * it's ok for #2 to match extra files. Those extras will be 276 * trimmed at #3. 277 * 278 * Suppose the pathspec is 'foo' and '../bar' running from 279 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 280 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 281 * user does not want XYZ/foo, only the "foo" part should be 282 * case-insensitive. We need to filter out XYZ/foo here. In 283 * other words, we do not trust the caller on comparing the 284 * prefix part when :(icase) is involved. We do exact 285 * comparison ourselves. 286 * 287 * Normally the caller (common_prefix_len() in fact) does 288 * _exact_ matching on name[-prefix+1..-1] and we do not need 289 * to check that part. Be defensive and check it anyway, in 290 * case common_prefix_len is changed, or a new caller is 291 * introduced that does not use common_prefix_len. 292 * 293 * If the penalty turns out too high when prefix is really 294 * long, maybe change it to 295 * strncmp(match, name, item->prefix - prefix) 296 */ 297if(item->prefix && (item->magic & PATHSPEC_ICASE) && 298strncmp(item->match, name - prefix, item->prefix)) 299return0; 300 301if(item->attr_match_nr && !match_attrs(name, namelen, item)) 302return0; 303 304/* If the match was just the prefix, we matched */ 305if(!*match) 306return MATCHED_RECURSIVELY; 307 308if(matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 309if(matchlen == namelen) 310return MATCHED_EXACTLY; 311 312if(match[matchlen-1] =='/'|| name[matchlen] =='/') 313return MATCHED_RECURSIVELY; 314}else if((flags & DO_MATCH_DIRECTORY) && 315 match[matchlen -1] =='/'&& 316 namelen == matchlen -1&& 317!ps_strncmp(item, match, name, namelen)) 318return MATCHED_EXACTLY; 319 320if(item->nowildcard_len < item->len && 321!git_fnmatch(item, match, name, 322 item->nowildcard_len - prefix)) 323return MATCHED_FNMATCH; 324 325/* Perform checks to see if "name" is a super set of the pathspec */ 326if(flags & DO_MATCH_SUBMODULE) { 327/* name is a literal prefix of the pathspec */ 328if((namelen < matchlen) && 329(match[namelen] =='/') && 330!ps_strncmp(item, match, name, namelen)) 331return MATCHED_RECURSIVELY; 332 333/* name" doesn't match up to the first wild character */ 334if(item->nowildcard_len < item->len && 335ps_strncmp(item, match, name, 336 item->nowildcard_len - prefix)) 337return0; 338 339/* 340 * Here is where we would perform a wildmatch to check if 341 * "name" can be matched as a directory (or a prefix) against 342 * the pathspec. Since wildmatch doesn't have this capability 343 * at the present we have to punt and say that it is a match, 344 * potentially returning a false positive 345 * The submodules themselves will be able to perform more 346 * accurate matching to determine if the pathspec matches. 347 */ 348return MATCHED_RECURSIVELY; 349} 350 351return0; 352} 353 354/* 355 * Given a name and a list of pathspecs, returns the nature of the 356 * closest (i.e. most specific) match of the name to any of the 357 * pathspecs. 358 * 359 * The caller typically calls this multiple times with the same 360 * pathspec and seen[] array but with different name/namelen 361 * (e.g. entries from the index) and is interested in seeing if and 362 * how each pathspec matches all the names it calls this function 363 * with. A mark is left in the seen[] array for each pathspec element 364 * indicating the closest type of match that element achieved, so if 365 * seen[n] remains zero after multiple invocations, that means the nth 366 * pathspec did not match any names, which could indicate that the 367 * user mistyped the nth pathspec. 368 */ 369static intdo_match_pathspec(const struct pathspec *ps, 370const char*name,int namelen, 371int prefix,char*seen, 372unsigned flags) 373{ 374int i, retval =0, exclude = flags & DO_MATCH_EXCLUDE; 375 376GUARD_PATHSPEC(ps, 377 PATHSPEC_FROMTOP | 378 PATHSPEC_MAXDEPTH | 379 PATHSPEC_LITERAL | 380 PATHSPEC_GLOB | 381 PATHSPEC_ICASE | 382 PATHSPEC_EXCLUDE | 383 PATHSPEC_ATTR); 384 385if(!ps->nr) { 386if(!ps->recursive || 387!(ps->magic & PATHSPEC_MAXDEPTH) || 388 ps->max_depth == -1) 389return MATCHED_RECURSIVELY; 390 391if(within_depth(name, namelen,0, ps->max_depth)) 392return MATCHED_EXACTLY; 393else 394return0; 395} 396 397 name += prefix; 398 namelen -= prefix; 399 400for(i = ps->nr -1; i >=0; i--) { 401int how; 402 403if((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 404( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 405continue; 406 407if(seen && seen[i] == MATCHED_EXACTLY) 408continue; 409/* 410 * Make exclude patterns optional and never report 411 * "pathspec ':(exclude)foo' matches no files" 412 */ 413if(seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 414 seen[i] = MATCHED_FNMATCH; 415 how =match_pathspec_item(ps->items+i, prefix, name, 416 namelen, flags); 417if(ps->recursive && 418(ps->magic & PATHSPEC_MAXDEPTH) && 419 ps->max_depth != -1&& 420 how && how != MATCHED_FNMATCH) { 421int len = ps->items[i].len; 422if(name[len] =='/') 423 len++; 424if(within_depth(name+len, namelen-len,0, ps->max_depth)) 425 how = MATCHED_EXACTLY; 426else 427 how =0; 428} 429if(how) { 430if(retval < how) 431 retval = how; 432if(seen && seen[i] < how) 433 seen[i] = how; 434} 435} 436return retval; 437} 438 439intmatch_pathspec(const struct pathspec *ps, 440const char*name,int namelen, 441int prefix,char*seen,int is_dir) 442{ 443int positive, negative; 444unsigned flags = is_dir ? DO_MATCH_DIRECTORY :0; 445 positive =do_match_pathspec(ps, name, namelen, 446 prefix, seen, flags); 447if(!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 448return positive; 449 negative =do_match_pathspec(ps, name, namelen, 450 prefix, seen, 451 flags | DO_MATCH_EXCLUDE); 452return negative ?0: positive; 453} 454 455/** 456 * Check if a submodule is a superset of the pathspec 457 */ 458intsubmodule_path_match(const struct pathspec *ps, 459const char*submodule_name, 460char*seen) 461{ 462int matched =do_match_pathspec(ps, submodule_name, 463strlen(submodule_name), 4640, seen, 465 DO_MATCH_DIRECTORY | 466 DO_MATCH_SUBMODULE); 467return matched; 468} 469 470intreport_path_error(const char*ps_matched, 471const struct pathspec *pathspec, 472const char*prefix) 473{ 474/* 475 * Make sure all pathspec matched; otherwise it is an error. 476 */ 477int num, errors =0; 478for(num =0; num < pathspec->nr; num++) { 479int other, found_dup; 480 481if(ps_matched[num]) 482continue; 483/* 484 * The caller might have fed identical pathspec 485 * twice. Do not barf on such a mistake. 486 * FIXME: parse_pathspec should have eliminated 487 * duplicate pathspec. 488 */ 489for(found_dup = other =0; 490!found_dup && other < pathspec->nr; 491 other++) { 492if(other == num || !ps_matched[other]) 493continue; 494if(!strcmp(pathspec->items[other].original, 495 pathspec->items[num].original)) 496/* 497 * Ok, we have a match already. 498 */ 499 found_dup =1; 500} 501if(found_dup) 502continue; 503 504error("pathspec '%s' did not match any file(s) known to git.", 505 pathspec->items[num].original); 506 errors++; 507} 508return errors; 509} 510 511/* 512 * Return the length of the "simple" part of a path match limiter. 513 */ 514intsimple_length(const char*match) 515{ 516int len = -1; 517 518for(;;) { 519unsigned char c = *match++; 520 len++; 521if(c =='\0'||is_glob_special(c)) 522return len; 523} 524} 525 526intno_wildcard(const char*string) 527{ 528return string[simple_length(string)] =='\0'; 529} 530 531voidparse_exclude_pattern(const char**pattern, 532int*patternlen, 533unsigned*flags, 534int*nowildcardlen) 535{ 536const char*p = *pattern; 537size_t i, len; 538 539*flags =0; 540if(*p =='!') { 541*flags |= EXC_FLAG_NEGATIVE; 542 p++; 543} 544 len =strlen(p); 545if(len && p[len -1] =='/') { 546 len--; 547*flags |= EXC_FLAG_MUSTBEDIR; 548} 549for(i =0; i < len; i++) { 550if(p[i] =='/') 551break; 552} 553if(i == len) 554*flags |= EXC_FLAG_NODIR; 555*nowildcardlen =simple_length(p); 556/* 557 * we should have excluded the trailing slash from 'p' too, 558 * but that's one more allocation. Instead just make sure 559 * nowildcardlen does not exceed real patternlen 560 */ 561if(*nowildcardlen > len) 562*nowildcardlen = len; 563if(*p =='*'&&no_wildcard(p +1)) 564*flags |= EXC_FLAG_ENDSWITH; 565*pattern = p; 566*patternlen = len; 567} 568 569voidadd_exclude(const char*string,const char*base, 570int baselen,struct exclude_list *el,int srcpos) 571{ 572struct exclude *x; 573int patternlen; 574unsigned flags; 575int nowildcardlen; 576 577parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 578if(flags & EXC_FLAG_MUSTBEDIR) { 579FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 580}else{ 581 x =xmalloc(sizeof(*x)); 582 x->pattern = string; 583} 584 x->patternlen = patternlen; 585 x->nowildcardlen = nowildcardlen; 586 x->base = base; 587 x->baselen = baselen; 588 x->flags = flags; 589 x->srcpos = srcpos; 590ALLOC_GROW(el->excludes, el->nr +1, el->alloc); 591 el->excludes[el->nr++] = x; 592 x->el = el; 593} 594 595static void*read_skip_worktree_file_from_index(const struct index_state *istate, 596const char*path,size_t*size, 597struct sha1_stat *sha1_stat) 598{ 599int pos, len; 600unsigned long sz; 601enum object_type type; 602void*data; 603 604 len =strlen(path); 605 pos =index_name_pos(istate, path, len); 606if(pos <0) 607return NULL; 608if(!ce_skip_worktree(istate->cache[pos])) 609return NULL; 610 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz); 611if(!data || type != OBJ_BLOB) { 612free(data); 613return NULL; 614} 615*size =xsize_t(sz); 616if(sha1_stat) { 617memset(&sha1_stat->stat,0,sizeof(sha1_stat->stat)); 618hashcpy(sha1_stat->sha1, istate->cache[pos]->oid.hash); 619} 620return data; 621} 622 623/* 624 * Frees memory within el which was allocated for exclude patterns and 625 * the file buffer. Does not free el itself. 626 */ 627voidclear_exclude_list(struct exclude_list *el) 628{ 629int i; 630 631for(i =0; i < el->nr; i++) 632free(el->excludes[i]); 633free(el->excludes); 634free(el->filebuf); 635 636memset(el,0,sizeof(*el)); 637} 638 639static voidtrim_trailing_spaces(char*buf) 640{ 641char*p, *last_space = NULL; 642 643for(p = buf; *p; p++) 644switch(*p) { 645case' ': 646if(!last_space) 647 last_space = p; 648break; 649case'\\': 650 p++; 651if(!*p) 652return; 653/* fallthrough */ 654default: 655 last_space = NULL; 656} 657 658if(last_space) 659*last_space ='\0'; 660} 661 662/* 663 * Given a subdirectory name and "dir" of the current directory, 664 * search the subdir in "dir" and return it, or create a new one if it 665 * does not exist in "dir". 666 * 667 * If "name" has the trailing slash, it'll be excluded in the search. 668 */ 669static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 670struct untracked_cache_dir *dir, 671const char*name,int len) 672{ 673int first, last; 674struct untracked_cache_dir *d; 675if(!dir) 676return NULL; 677if(len && name[len -1] =='/') 678 len--; 679 first =0; 680 last = dir->dirs_nr; 681while(last > first) { 682int cmp, next = (last + first) >>1; 683 d = dir->dirs[next]; 684 cmp =strncmp(name, d->name, len); 685if(!cmp &&strlen(d->name) > len) 686 cmp = -1; 687if(!cmp) 688return d; 689if(cmp <0) { 690 last = next; 691continue; 692} 693 first = next+1; 694} 695 696 uc->dir_created++; 697FLEX_ALLOC_MEM(d, name, name, len); 698 699ALLOC_GROW(dir->dirs, dir->dirs_nr +1, dir->dirs_alloc); 700memmove(dir->dirs + first +1, dir->dirs + first, 701(dir->dirs_nr - first) *sizeof(*dir->dirs)); 702 dir->dirs_nr++; 703 dir->dirs[first] = d; 704return d; 705} 706 707static voiddo_invalidate_gitignore(struct untracked_cache_dir *dir) 708{ 709int i; 710 dir->valid =0; 711 dir->untracked_nr =0; 712for(i =0; i < dir->dirs_nr; i++) 713do_invalidate_gitignore(dir->dirs[i]); 714} 715 716static voidinvalidate_gitignore(struct untracked_cache *uc, 717struct untracked_cache_dir *dir) 718{ 719 uc->gitignore_invalidated++; 720do_invalidate_gitignore(dir); 721} 722 723static voidinvalidate_directory(struct untracked_cache *uc, 724struct untracked_cache_dir *dir) 725{ 726int i; 727 uc->dir_invalidated++; 728 dir->valid =0; 729 dir->untracked_nr =0; 730for(i =0; i < dir->dirs_nr; i++) 731 dir->dirs[i]->recurse =0; 732} 733 734/* 735 * Given a file with name "fname", read it (either from disk, or from 736 * an index if 'istate' is non-null), parse it and store the 737 * exclude rules in "el". 738 * 739 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 740 * stat data from disk (only valid if add_excludes returns zero). If 741 * ss_valid is non-zero, "ss" must contain good value as input. 742 */ 743static intadd_excludes(const char*fname,const char*base,int baselen, 744struct exclude_list *el, 745struct index_state *istate, 746struct sha1_stat *sha1_stat) 747{ 748struct stat st; 749int fd, i, lineno =1; 750size_t size =0; 751char*buf, *entry; 752 753 fd =open(fname, O_RDONLY); 754if(fd <0||fstat(fd, &st) <0) { 755if(fd <0) 756warn_on_fopen_errors(fname); 757else 758close(fd); 759if(!istate || 760(buf =read_skip_worktree_file_from_index(istate, fname, &size, sha1_stat)) == NULL) 761return-1; 762if(size ==0) { 763free(buf); 764return0; 765} 766if(buf[size-1] !='\n') { 767 buf =xrealloc(buf,st_add(size,1)); 768 buf[size++] ='\n'; 769} 770}else{ 771 size =xsize_t(st.st_size); 772if(size ==0) { 773if(sha1_stat) { 774fill_stat_data(&sha1_stat->stat, &st); 775hashcpy(sha1_stat->sha1, EMPTY_BLOB_SHA1_BIN); 776 sha1_stat->valid =1; 777} 778close(fd); 779return0; 780} 781 buf =xmallocz(size); 782if(read_in_full(fd, buf, size) != size) { 783free(buf); 784close(fd); 785return-1; 786} 787 buf[size++] ='\n'; 788close(fd); 789if(sha1_stat) { 790int pos; 791if(sha1_stat->valid && 792!match_stat_data_racy(istate, &sha1_stat->stat, &st)) 793;/* no content change, ss->sha1 still good */ 794else if(istate && 795(pos =index_name_pos(istate, fname,strlen(fname))) >=0&& 796!ce_stage(istate->cache[pos]) && 797ce_uptodate(istate->cache[pos]) && 798!would_convert_to_git(fname)) 799hashcpy(sha1_stat->sha1, 800 istate->cache[pos]->oid.hash); 801else 802hash_sha1_file(buf, size,"blob", sha1_stat->sha1); 803fill_stat_data(&sha1_stat->stat, &st); 804 sha1_stat->valid =1; 805} 806} 807 808 el->filebuf = buf; 809 810if(skip_utf8_bom(&buf, size)) 811 size -= buf - el->filebuf; 812 813 entry = buf; 814 815for(i =0; i < size; i++) { 816if(buf[i] =='\n') { 817if(entry != buf + i && entry[0] !='#') { 818 buf[i - (i && buf[i-1] =='\r')] =0; 819trim_trailing_spaces(entry); 820add_exclude(entry, base, baselen, el, lineno); 821} 822 lineno++; 823 entry = buf + i +1; 824} 825} 826return0; 827} 828 829intadd_excludes_from_file_to_list(const char*fname,const char*base, 830int baselen,struct exclude_list *el, 831struct index_state *istate) 832{ 833returnadd_excludes(fname, base, baselen, el, istate, NULL); 834} 835 836struct exclude_list *add_exclude_list(struct dir_struct *dir, 837int group_type,const char*src) 838{ 839struct exclude_list *el; 840struct exclude_list_group *group; 841 842 group = &dir->exclude_list_group[group_type]; 843ALLOC_GROW(group->el, group->nr +1, group->alloc); 844 el = &group->el[group->nr++]; 845memset(el,0,sizeof(*el)); 846 el->src = src; 847return el; 848} 849 850/* 851 * Used to set up core.excludesfile and .git/info/exclude lists. 852 */ 853static voidadd_excludes_from_file_1(struct dir_struct *dir,const char*fname, 854struct sha1_stat *sha1_stat) 855{ 856struct exclude_list *el; 857/* 858 * catch setup_standard_excludes() that's called before 859 * dir->untracked is assigned. That function behaves 860 * differently when dir->untracked is non-NULL. 861 */ 862if(!dir->untracked) 863 dir->unmanaged_exclude_files++; 864 el =add_exclude_list(dir, EXC_FILE, fname); 865if(add_excludes(fname,"",0, el, NULL, sha1_stat) <0) 866die("cannot use%sas an exclude file", fname); 867} 868 869voidadd_excludes_from_file(struct dir_struct *dir,const char*fname) 870{ 871 dir->unmanaged_exclude_files++;/* see validate_untracked_cache() */ 872add_excludes_from_file_1(dir, fname, NULL); 873} 874 875intmatch_basename(const char*basename,int basenamelen, 876const char*pattern,int prefix,int patternlen, 877unsigned flags) 878{ 879if(prefix == patternlen) { 880if(patternlen == basenamelen && 881!fspathncmp(pattern, basename, basenamelen)) 882return1; 883}else if(flags & EXC_FLAG_ENDSWITH) { 884/* "*literal" matching against "fooliteral" */ 885if(patternlen -1<= basenamelen && 886!fspathncmp(pattern +1, 887 basename + basenamelen - (patternlen -1), 888 patternlen -1)) 889return1; 890}else{ 891if(fnmatch_icase_mem(pattern, patternlen, 892 basename, basenamelen, 8930) ==0) 894return1; 895} 896return0; 897} 898 899intmatch_pathname(const char*pathname,int pathlen, 900const char*base,int baselen, 901const char*pattern,int prefix,int patternlen, 902unsigned flags) 903{ 904const char*name; 905int namelen; 906 907/* 908 * match with FNM_PATHNAME; the pattern has base implicitly 909 * in front of it. 910 */ 911if(*pattern =='/') { 912 pattern++; 913 patternlen--; 914 prefix--; 915} 916 917/* 918 * baselen does not count the trailing slash. base[] may or 919 * may not end with a trailing slash though. 920 */ 921if(pathlen < baselen +1|| 922(baselen && pathname[baselen] !='/') || 923fspathncmp(pathname, base, baselen)) 924return0; 925 926 namelen = baselen ? pathlen - baselen -1: pathlen; 927 name = pathname + pathlen - namelen; 928 929if(prefix) { 930/* 931 * if the non-wildcard part is longer than the 932 * remaining pathname, surely it cannot match. 933 */ 934if(prefix > namelen) 935return0; 936 937if(fspathncmp(pattern, name, prefix)) 938return0; 939 pattern += prefix; 940 patternlen -= prefix; 941 name += prefix; 942 namelen -= prefix; 943 944/* 945 * If the whole pattern did not have a wildcard, 946 * then our prefix match is all we need; we 947 * do not need to call fnmatch at all. 948 */ 949if(!patternlen && !namelen) 950return1; 951} 952 953returnfnmatch_icase_mem(pattern, patternlen, 954 name, namelen, 955 WM_PATHNAME) ==0; 956} 957 958/* 959 * Scan the given exclude list in reverse to see whether pathname 960 * should be ignored. The first match (i.e. the last on the list), if 961 * any, determines the fate. Returns the exclude_list element which 962 * matched, or NULL for undecided. 963 */ 964static struct exclude *last_exclude_matching_from_list(const char*pathname, 965int pathlen, 966const char*basename, 967int*dtype, 968struct exclude_list *el, 969struct index_state *istate) 970{ 971struct exclude *exc = NULL;/* undecided */ 972int i; 973 974if(!el->nr) 975return NULL;/* undefined */ 976 977for(i = el->nr -1;0<= i; i--) { 978struct exclude *x = el->excludes[i]; 979const char*exclude = x->pattern; 980int prefix = x->nowildcardlen; 981 982if(x->flags & EXC_FLAG_MUSTBEDIR) { 983if(*dtype == DT_UNKNOWN) 984*dtype =get_dtype(NULL, istate, pathname, pathlen); 985if(*dtype != DT_DIR) 986continue; 987} 988 989if(x->flags & EXC_FLAG_NODIR) { 990if(match_basename(basename, 991 pathlen - (basename - pathname), 992 exclude, prefix, x->patternlen, 993 x->flags)) { 994 exc = x; 995break; 996} 997continue; 998} 9991000assert(x->baselen ==0|| x->base[x->baselen -1] =='/');1001if(match_pathname(pathname, pathlen,1002 x->base, x->baselen ? x->baselen -1:0,1003 exclude, prefix, x->patternlen, x->flags)) {1004 exc = x;1005break;1006}1007}1008return exc;1009}10101011/*1012 * Scan the list and let the last match determine the fate.1013 * Return 1 for exclude, 0 for include and -1 for undecided.1014 */1015intis_excluded_from_list(const char*pathname,1016int pathlen,const char*basename,int*dtype,1017struct exclude_list *el,struct index_state *istate)1018{1019struct exclude *exclude;1020 exclude =last_exclude_matching_from_list(pathname, pathlen, basename,1021 dtype, el, istate);1022if(exclude)1023return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1024return-1;/* undecided */1025}10261027static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1028struct index_state *istate,1029const char*pathname,int pathlen,const char*basename,1030int*dtype_p)1031{1032int i, j;1033struct exclude_list_group *group;1034struct exclude *exclude;1035for(i = EXC_CMDL; i <= EXC_FILE; i++) {1036 group = &dir->exclude_list_group[i];1037for(j = group->nr -1; j >=0; j--) {1038 exclude =last_exclude_matching_from_list(1039 pathname, pathlen, basename, dtype_p,1040&group->el[j], istate);1041if(exclude)1042return exclude;1043}1044}1045return NULL;1046}10471048/*1049 * Loads the per-directory exclude list for the substring of base1050 * which has a char length of baselen.1051 */1052static voidprep_exclude(struct dir_struct *dir,1053struct index_state *istate,1054const char*base,int baselen)1055{1056struct exclude_list_group *group;1057struct exclude_list *el;1058struct exclude_stack *stk = NULL;1059struct untracked_cache_dir *untracked;1060int current;10611062 group = &dir->exclude_list_group[EXC_DIRS];10631064/*1065 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1066 * which originate from directories not in the prefix of the1067 * path being checked.1068 */1069while((stk = dir->exclude_stack) != NULL) {1070if(stk->baselen <= baselen &&1071!strncmp(dir->basebuf.buf, base, stk->baselen))1072break;1073 el = &group->el[dir->exclude_stack->exclude_ix];1074 dir->exclude_stack = stk->prev;1075 dir->exclude = NULL;1076free((char*)el->src);/* see strbuf_detach() below */1077clear_exclude_list(el);1078free(stk);1079 group->nr--;1080}10811082/* Skip traversing into sub directories if the parent is excluded */1083if(dir->exclude)1084return;10851086/*1087 * Lazy initialization. All call sites currently just1088 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1089 * them seems lots of work for little benefit.1090 */1091if(!dir->basebuf.buf)1092strbuf_init(&dir->basebuf, PATH_MAX);10931094/* Read from the parent directories and push them down. */1095 current = stk ? stk->baselen : -1;1096strbuf_setlen(&dir->basebuf, current <0?0: current);1097if(dir->untracked)1098 untracked = stk ? stk->ucd : dir->untracked->root;1099else1100 untracked = NULL;11011102while(current < baselen) {1103const char*cp;1104struct sha1_stat sha1_stat;11051106 stk =xcalloc(1,sizeof(*stk));1107if(current <0) {1108 cp = base;1109 current =0;1110}else{1111 cp =strchr(base + current +1,'/');1112if(!cp)1113die("oops in prep_exclude");1114 cp++;1115 untracked =1116lookup_untracked(dir->untracked, untracked,1117 base + current,1118 cp - base - current);1119}1120 stk->prev = dir->exclude_stack;1121 stk->baselen = cp - base;1122 stk->exclude_ix = group->nr;1123 stk->ucd = untracked;1124 el =add_exclude_list(dir, EXC_DIRS, NULL);1125strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1126assert(stk->baselen == dir->basebuf.len);11271128/* Abort if the directory is excluded */1129if(stk->baselen) {1130int dt = DT_DIR;1131 dir->basebuf.buf[stk->baselen -1] =0;1132 dir->exclude =last_exclude_matching_from_lists(dir,1133 istate,1134 dir->basebuf.buf, stk->baselen -1,1135 dir->basebuf.buf + current, &dt);1136 dir->basebuf.buf[stk->baselen -1] ='/';1137if(dir->exclude &&1138 dir->exclude->flags & EXC_FLAG_NEGATIVE)1139 dir->exclude = NULL;1140if(dir->exclude) {1141 dir->exclude_stack = stk;1142return;1143}1144}11451146/* Try to read per-directory file */1147hashclr(sha1_stat.sha1);1148 sha1_stat.valid =0;1149if(dir->exclude_per_dir &&1150/*1151 * If we know that no files have been added in1152 * this directory (i.e. valid_cached_dir() has1153 * been executed and set untracked->valid) ..1154 */1155(!untracked || !untracked->valid ||1156/*1157 * .. and .gitignore does not exist before1158 * (i.e. null exclude_sha1). Then we can skip1159 * loading .gitignore, which would result in1160 * ENOENT anyway.1161 */1162!is_null_sha1(untracked->exclude_sha1))) {1163/*1164 * dir->basebuf gets reused by the traversal, but we1165 * need fname to remain unchanged to ensure the src1166 * member of each struct exclude correctly1167 * back-references its source file. Other invocations1168 * of add_exclude_list provide stable strings, so we1169 * strbuf_detach() and free() here in the caller.1170 */1171struct strbuf sb = STRBUF_INIT;1172strbuf_addbuf(&sb, &dir->basebuf);1173strbuf_addstr(&sb, dir->exclude_per_dir);1174 el->src =strbuf_detach(&sb, NULL);1175add_excludes(el->src, el->src, stk->baselen, el, istate,1176 untracked ? &sha1_stat : NULL);1177}1178/*1179 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1180 * will first be called in valid_cached_dir() then maybe many1181 * times more in last_exclude_matching(). When the cache is1182 * used, last_exclude_matching() will not be called and1183 * reading .gitignore content will be a waste.1184 *1185 * So when it's called by valid_cached_dir() and we can get1186 * .gitignore SHA-1 from the index (i.e. .gitignore is not1187 * modified on work tree), we could delay reading the1188 * .gitignore content until we absolutely need it in1189 * last_exclude_matching(). Be careful about ignore rule1190 * order, though, if you do that.1191 */1192if(untracked &&1193hashcmp(sha1_stat.sha1, untracked->exclude_sha1)) {1194invalidate_gitignore(dir->untracked, untracked);1195hashcpy(untracked->exclude_sha1, sha1_stat.sha1);1196}1197 dir->exclude_stack = stk;1198 current = stk->baselen;1199}1200strbuf_setlen(&dir->basebuf, baselen);1201}12021203/*1204 * Loads the exclude lists for the directory containing pathname, then1205 * scans all exclude lists to determine whether pathname is excluded.1206 * Returns the exclude_list element which matched, or NULL for1207 * undecided.1208 */1209struct exclude *last_exclude_matching(struct dir_struct *dir,1210struct index_state *istate,1211const char*pathname,1212int*dtype_p)1213{1214int pathlen =strlen(pathname);1215const char*basename =strrchr(pathname,'/');1216 basename = (basename) ? basename+1: pathname;12171218prep_exclude(dir, istate, pathname, basename-pathname);12191220if(dir->exclude)1221return dir->exclude;12221223returnlast_exclude_matching_from_lists(dir, istate, pathname, pathlen,1224 basename, dtype_p);1225}12261227/*1228 * Loads the exclude lists for the directory containing pathname, then1229 * scans all exclude lists to determine whether pathname is excluded.1230 * Returns 1 if true, otherwise 0.1231 */1232intis_excluded(struct dir_struct *dir,struct index_state *istate,1233const char*pathname,int*dtype_p)1234{1235struct exclude *exclude =1236last_exclude_matching(dir, istate, pathname, dtype_p);1237if(exclude)1238return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1239return0;1240}12411242static struct dir_entry *dir_entry_new(const char*pathname,int len)1243{1244struct dir_entry *ent;12451246FLEX_ALLOC_MEM(ent, name, pathname, len);1247 ent->len = len;1248return ent;1249}12501251static struct dir_entry *dir_add_name(struct dir_struct *dir,1252struct index_state *istate,1253const char*pathname,int len)1254{1255if(index_file_exists(istate, pathname, len, ignore_case))1256return NULL;12571258ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1259return dir->entries[dir->nr++] =dir_entry_new(pathname, len);1260}12611262struct dir_entry *dir_add_ignored(struct dir_struct *dir,1263struct index_state *istate,1264const char*pathname,int len)1265{1266if(!index_name_is_other(istate, pathname, len))1267return NULL;12681269ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1270return dir->ignored[dir->ignored_nr++] =dir_entry_new(pathname, len);1271}12721273enum exist_status {1274 index_nonexistent =0,1275 index_directory,1276 index_gitdir1277};12781279/*1280 * Do not use the alphabetically sorted index to look up1281 * the directory name; instead, use the case insensitive1282 * directory hash.1283 */1284static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1285const char*dirname,int len)1286{1287struct cache_entry *ce;12881289if(index_dir_exists(istate, dirname, len))1290return index_directory;12911292 ce =index_file_exists(istate, dirname, len, ignore_case);1293if(ce &&S_ISGITLINK(ce->ce_mode))1294return index_gitdir;12951296return index_nonexistent;1297}12981299/*1300 * The index sorts alphabetically by entry name, which1301 * means that a gitlink sorts as '\0' at the end, while1302 * a directory (which is defined not as an entry, but as1303 * the files it contains) will sort with the '/' at the1304 * end.1305 */1306static enum exist_status directory_exists_in_index(struct index_state *istate,1307const char*dirname,int len)1308{1309int pos;13101311if(ignore_case)1312returndirectory_exists_in_index_icase(istate, dirname, len);13131314 pos =index_name_pos(istate, dirname, len);1315if(pos <0)1316 pos = -pos-1;1317while(pos < istate->cache_nr) {1318const struct cache_entry *ce = istate->cache[pos++];1319unsigned char endchar;13201321if(strncmp(ce->name, dirname, len))1322break;1323 endchar = ce->name[len];1324if(endchar >'/')1325break;1326if(endchar =='/')1327return index_directory;1328if(!endchar &&S_ISGITLINK(ce->ce_mode))1329return index_gitdir;1330}1331return index_nonexistent;1332}13331334/*1335 * When we find a directory when traversing the filesystem, we1336 * have three distinct cases:1337 *1338 * - ignore it1339 * - see it as a directory1340 * - recurse into it1341 *1342 * and which one we choose depends on a combination of existing1343 * git index contents and the flags passed into the directory1344 * traversal routine.1345 *1346 * Case 1: If we *already* have entries in the index under that1347 * directory name, we always recurse into the directory to see1348 * all the files.1349 *1350 * Case 2: If we *already* have that directory name as a gitlink,1351 * we always continue to see it as a gitlink, regardless of whether1352 * there is an actual git directory there or not (it might not1353 * be checked out as a subproject!)1354 *1355 * Case 3: if we didn't have it in the index previously, we1356 * have a few sub-cases:1357 *1358 * (a) if "show_other_directories" is true, we show it as1359 * just a directory, unless "hide_empty_directories" is1360 * also true, in which case we need to check if it contains any1361 * untracked and / or ignored files.1362 * (b) if it looks like a git directory, and we don't have1363 * 'no_gitlinks' set we treat it as a gitlink, and show it1364 * as a directory.1365 * (c) otherwise, we recurse into it.1366 */1367static enum path_treatment treat_directory(struct dir_struct *dir,1368struct index_state *istate,1369struct untracked_cache_dir *untracked,1370const char*dirname,int len,int baselen,int exclude,1371const struct pathspec *pathspec)1372{1373/* The "len-1" is to strip the final '/' */1374switch(directory_exists_in_index(istate, dirname, len-1)) {1375case index_directory:1376return path_recurse;13771378case index_gitdir:1379return path_none;13801381case index_nonexistent:1382if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1383break;1384if(!(dir->flags & DIR_NO_GITLINKS)) {1385unsigned char sha1[20];1386if(resolve_gitlink_ref(dirname,"HEAD", sha1) ==0)1387return path_untracked;1388}1389return path_recurse;1390}13911392/* This is the "show_other_directories" case */13931394if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1395return exclude ? path_excluded : path_untracked;13961397 untracked =lookup_untracked(dir->untracked, untracked,1398 dirname + baselen, len - baselen);1399returnread_directory_recursive(dir, istate, dirname, len,1400 untracked,1, pathspec);1401}14021403/*1404 * This is an inexact early pruning of any recursive directory1405 * reading - if the path cannot possibly be in the pathspec,1406 * return true, and we'll skip it early.1407 */1408static intsimplify_away(const char*path,int pathlen,1409const struct pathspec *pathspec)1410{1411int i;14121413if(!pathspec || !pathspec->nr)1414return0;14151416GUARD_PATHSPEC(pathspec,1417 PATHSPEC_FROMTOP |1418 PATHSPEC_MAXDEPTH |1419 PATHSPEC_LITERAL |1420 PATHSPEC_GLOB |1421 PATHSPEC_ICASE |1422 PATHSPEC_EXCLUDE |1423 PATHSPEC_ATTR);14241425for(i =0; i < pathspec->nr; i++) {1426const struct pathspec_item *item = &pathspec->items[i];1427int len = item->nowildcard_len;14281429if(len > pathlen)1430 len = pathlen;1431if(!ps_strncmp(item, item->match, path, len))1432return0;1433}14341435return1;1436}14371438/*1439 * This function tells us whether an excluded path matches a1440 * list of "interesting" pathspecs. That is, whether a path matched1441 * by any of the pathspecs could possibly be ignored by excluding1442 * the specified path. This can happen if:1443 *1444 * 1. the path is mentioned explicitly in the pathspec1445 *1446 * 2. the path is a directory prefix of some element in the1447 * pathspec1448 */1449static intexclude_matches_pathspec(const char*path,int pathlen,1450const struct pathspec *pathspec)1451{1452int i;14531454if(!pathspec || !pathspec->nr)1455return0;14561457GUARD_PATHSPEC(pathspec,1458 PATHSPEC_FROMTOP |1459 PATHSPEC_MAXDEPTH |1460 PATHSPEC_LITERAL |1461 PATHSPEC_GLOB |1462 PATHSPEC_ICASE |1463 PATHSPEC_EXCLUDE);14641465for(i =0; i < pathspec->nr; i++) {1466const struct pathspec_item *item = &pathspec->items[i];1467int len = item->nowildcard_len;14681469if(len == pathlen &&1470!ps_strncmp(item, item->match, path, pathlen))1471return1;1472if(len > pathlen &&1473 item->match[pathlen] =='/'&&1474!ps_strncmp(item, item->match, path, pathlen))1475return1;1476}1477return0;1478}14791480static intget_index_dtype(struct index_state *istate,1481const char*path,int len)1482{1483int pos;1484const struct cache_entry *ce;14851486 ce =index_file_exists(istate, path, len,0);1487if(ce) {1488if(!ce_uptodate(ce))1489return DT_UNKNOWN;1490if(S_ISGITLINK(ce->ce_mode))1491return DT_DIR;1492/*1493 * Nobody actually cares about the1494 * difference between DT_LNK and DT_REG1495 */1496return DT_REG;1497}14981499/* Try to look it up as a directory */1500 pos =index_name_pos(istate, path, len);1501if(pos >=0)1502return DT_UNKNOWN;1503 pos = -pos-1;1504while(pos < istate->cache_nr) {1505 ce = istate->cache[pos++];1506if(strncmp(ce->name, path, len))1507break;1508if(ce->name[len] >'/')1509break;1510if(ce->name[len] <'/')1511continue;1512if(!ce_uptodate(ce))1513break;/* continue? */1514return DT_DIR;1515}1516return DT_UNKNOWN;1517}15181519static intget_dtype(struct dirent *de,struct index_state *istate,1520const char*path,int len)1521{1522int dtype = de ?DTYPE(de) : DT_UNKNOWN;1523struct stat st;15241525if(dtype != DT_UNKNOWN)1526return dtype;1527 dtype =get_index_dtype(istate, path, len);1528if(dtype != DT_UNKNOWN)1529return dtype;1530if(lstat(path, &st))1531return dtype;1532if(S_ISREG(st.st_mode))1533return DT_REG;1534if(S_ISDIR(st.st_mode))1535return DT_DIR;1536if(S_ISLNK(st.st_mode))1537return DT_LNK;1538return dtype;1539}15401541static enum path_treatment treat_one_path(struct dir_struct *dir,1542struct untracked_cache_dir *untracked,1543struct index_state *istate,1544struct strbuf *path,1545int baselen,1546const struct pathspec *pathspec,1547int dtype,struct dirent *de)1548{1549int exclude;1550int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);15511552if(dtype == DT_UNKNOWN)1553 dtype =get_dtype(de, istate, path->buf, path->len);15541555/* Always exclude indexed files */1556if(dtype != DT_DIR && has_path_in_index)1557return path_none;15581559/*1560 * When we are looking at a directory P in the working tree,1561 * there are three cases:1562 *1563 * (1) P exists in the index. Everything inside the directory P in1564 * the working tree needs to go when P is checked out from the1565 * index.1566 *1567 * (2) P does not exist in the index, but there is P/Q in the index.1568 * We know P will stay a directory when we check out the contents1569 * of the index, but we do not know yet if there is a directory1570 * P/Q in the working tree to be killed, so we need to recurse.1571 *1572 * (3) P does not exist in the index, and there is no P/Q in the index1573 * to require P to be a directory, either. Only in this case, we1574 * know that everything inside P will not be killed without1575 * recursing.1576 */1577if((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1578(dtype == DT_DIR) &&1579!has_path_in_index &&1580(directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))1581return path_none;15821583 exclude =is_excluded(dir, istate, path->buf, &dtype);15841585/*1586 * Excluded? If we don't explicitly want to show1587 * ignored files, ignore it1588 */1589if(exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1590return path_excluded;15911592switch(dtype) {1593default:1594return path_none;1595case DT_DIR:1596strbuf_addch(path,'/');1597returntreat_directory(dir, istate, untracked, path->buf, path->len,1598 baselen, exclude, pathspec);1599case DT_REG:1600case DT_LNK:1601return exclude ? path_excluded : path_untracked;1602}1603}16041605static enum path_treatment treat_path_fast(struct dir_struct *dir,1606struct untracked_cache_dir *untracked,1607struct cached_dir *cdir,1608struct index_state *istate,1609struct strbuf *path,1610int baselen,1611const struct pathspec *pathspec)1612{1613strbuf_setlen(path, baselen);1614if(!cdir->ucd) {1615strbuf_addstr(path, cdir->file);1616return path_untracked;1617}1618strbuf_addstr(path, cdir->ucd->name);1619/* treat_one_path() does this before it calls treat_directory() */1620strbuf_complete(path,'/');1621if(cdir->ucd->check_only)1622/*1623 * check_only is set as a result of treat_directory() getting1624 * to its bottom. Verify again the same set of directories1625 * with check_only set.1626 */1627returnread_directory_recursive(dir, istate, path->buf, path->len,1628 cdir->ucd,1, pathspec);1629/*1630 * We get path_recurse in the first run when1631 * directory_exists_in_index() returns index_nonexistent. We1632 * are sure that new changes in the index does not impact the1633 * outcome. Return now.1634 */1635return path_recurse;1636}16371638static enum path_treatment treat_path(struct dir_struct *dir,1639struct untracked_cache_dir *untracked,1640struct cached_dir *cdir,1641struct index_state *istate,1642struct strbuf *path,1643int baselen,1644const struct pathspec *pathspec)1645{1646int dtype;1647struct dirent *de = cdir->de;16481649if(!de)1650returntreat_path_fast(dir, untracked, cdir, istate, path,1651 baselen, pathspec);1652if(is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name,".git"))1653return path_none;1654strbuf_setlen(path, baselen);1655strbuf_addstr(path, de->d_name);1656if(simplify_away(path->buf, path->len, pathspec))1657return path_none;16581659 dtype =DTYPE(de);1660returntreat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1661}16621663static voidadd_untracked(struct untracked_cache_dir *dir,const char*name)1664{1665if(!dir)1666return;1667ALLOC_GROW(dir->untracked, dir->untracked_nr +1,1668 dir->untracked_alloc);1669 dir->untracked[dir->untracked_nr++] =xstrdup(name);1670}16711672static intvalid_cached_dir(struct dir_struct *dir,1673struct untracked_cache_dir *untracked,1674struct index_state *istate,1675struct strbuf *path,1676int check_only)1677{1678struct stat st;16791680if(!untracked)1681return0;16821683if(stat(path->len ? path->buf :".", &st)) {1684invalidate_directory(dir->untracked, untracked);1685memset(&untracked->stat_data,0,sizeof(untracked->stat_data));1686return0;1687}1688if(!untracked->valid ||1689match_stat_data_racy(istate, &untracked->stat_data, &st)) {1690if(untracked->valid)1691invalidate_directory(dir->untracked, untracked);1692fill_stat_data(&untracked->stat_data, &st);1693return0;1694}16951696if(untracked->check_only != !!check_only) {1697invalidate_directory(dir->untracked, untracked);1698return0;1699}17001701/*1702 * prep_exclude will be called eventually on this directory,1703 * but it's called much later in last_exclude_matching(). We1704 * need it now to determine the validity of the cache for this1705 * path. The next calls will be nearly no-op, the way1706 * prep_exclude() is designed.1707 */1708if(path->len && path->buf[path->len -1] !='/') {1709strbuf_addch(path,'/');1710prep_exclude(dir, istate, path->buf, path->len);1711strbuf_setlen(path, path->len -1);1712}else1713prep_exclude(dir, istate, path->buf, path->len);17141715/* hopefully prep_exclude() haven't invalidated this entry... */1716return untracked->valid;1717}17181719static intopen_cached_dir(struct cached_dir *cdir,1720struct dir_struct *dir,1721struct untracked_cache_dir *untracked,1722struct index_state *istate,1723struct strbuf *path,1724int check_only)1725{1726memset(cdir,0,sizeof(*cdir));1727 cdir->untracked = untracked;1728if(valid_cached_dir(dir, untracked, istate, path, check_only))1729return0;1730 cdir->fdir =opendir(path->len ? path->buf :".");1731if(dir->untracked)1732 dir->untracked->dir_opened++;1733if(!cdir->fdir)1734return-1;1735return0;1736}17371738static intread_cached_dir(struct cached_dir *cdir)1739{1740if(cdir->fdir) {1741 cdir->de =readdir(cdir->fdir);1742if(!cdir->de)1743return-1;1744return0;1745}1746while(cdir->nr_dirs < cdir->untracked->dirs_nr) {1747struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1748if(!d->recurse) {1749 cdir->nr_dirs++;1750continue;1751}1752 cdir->ucd = d;1753 cdir->nr_dirs++;1754return0;1755}1756 cdir->ucd = NULL;1757if(cdir->nr_files < cdir->untracked->untracked_nr) {1758struct untracked_cache_dir *d = cdir->untracked;1759 cdir->file = d->untracked[cdir->nr_files++];1760return0;1761}1762return-1;1763}17641765static voidclose_cached_dir(struct cached_dir *cdir)1766{1767if(cdir->fdir)1768closedir(cdir->fdir);1769/*1770 * We have gone through this directory and found no untracked1771 * entries. Mark it valid.1772 */1773if(cdir->untracked) {1774 cdir->untracked->valid =1;1775 cdir->untracked->recurse =1;1776}1777}17781779/*1780 * Read a directory tree. We currently ignore anything but1781 * directories, regular files and symlinks. That's because git1782 * doesn't handle them at all yet. Maybe that will change some1783 * day.1784 *1785 * Also, we ignore the name ".git" (even if it is not a directory).1786 * That likely will not change.1787 *1788 * Returns the most significant path_treatment value encountered in the scan.1789 */1790static enum path_treatment read_directory_recursive(struct dir_struct *dir,1791struct index_state *istate,const char*base,int baselen,1792struct untracked_cache_dir *untracked,int check_only,1793const struct pathspec *pathspec)1794{1795struct cached_dir cdir;1796enum path_treatment state, subdir_state, dir_state = path_none;1797struct strbuf path = STRBUF_INIT;17981799strbuf_add(&path, base, baselen);18001801if(open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1802goto out;18031804if(untracked)1805 untracked->check_only = !!check_only;18061807while(!read_cached_dir(&cdir)) {1808/* check how the file or directory should be treated */1809 state =treat_path(dir, untracked, &cdir, istate, &path,1810 baselen, pathspec);18111812if(state > dir_state)1813 dir_state = state;18141815/* recurse into subdir if instructed by treat_path */1816if((state == path_recurse) ||1817((state == path_untracked) &&1818(dir->flags & DIR_SHOW_IGNORED_TOO) &&1819(get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {1820struct untracked_cache_dir *ud;1821 ud =lookup_untracked(dir->untracked, untracked,1822 path.buf + baselen,1823 path.len - baselen);1824 subdir_state =1825read_directory_recursive(dir, istate, path.buf,1826 path.len, ud,1827 check_only, pathspec);1828if(subdir_state > dir_state)1829 dir_state = subdir_state;1830}18311832if(check_only) {1833/* abort early if maximum state has been reached */1834if(dir_state == path_untracked) {1835if(cdir.fdir)1836add_untracked(untracked, path.buf + baselen);1837break;1838}1839/* skip the dir_add_* part */1840continue;1841}18421843/* add the path to the appropriate result list */1844switch(state) {1845case path_excluded:1846if(dir->flags & DIR_SHOW_IGNORED)1847dir_add_name(dir, istate, path.buf, path.len);1848else if((dir->flags & DIR_SHOW_IGNORED_TOO) ||1849((dir->flags & DIR_COLLECT_IGNORED) &&1850exclude_matches_pathspec(path.buf, path.len,1851 pathspec)))1852dir_add_ignored(dir, istate, path.buf, path.len);1853break;18541855case path_untracked:1856if(dir->flags & DIR_SHOW_IGNORED)1857break;1858dir_add_name(dir, istate, path.buf, path.len);1859if(cdir.fdir)1860add_untracked(untracked, path.buf + baselen);1861break;18621863default:1864break;1865}1866}1867close_cached_dir(&cdir);1868 out:1869strbuf_release(&path);18701871return dir_state;1872}18731874intcmp_dir_entry(const void*p1,const void*p2)1875{1876const struct dir_entry *e1 = *(const struct dir_entry **)p1;1877const struct dir_entry *e2 = *(const struct dir_entry **)p2;18781879returnname_compare(e1->name, e1->len, e2->name, e2->len);1880}18811882/* check if *out lexically strictly contains *in */1883intcheck_dir_entry_contains(const struct dir_entry *out,const struct dir_entry *in)1884{1885return(out->len < in->len) &&1886(out->name[out->len -1] =='/') &&1887!memcmp(out->name, in->name, out->len);1888}18891890static inttreat_leading_path(struct dir_struct *dir,1891struct index_state *istate,1892const char*path,int len,1893const struct pathspec *pathspec)1894{1895struct strbuf sb = STRBUF_INIT;1896int baselen, rc =0;1897const char*cp;1898int old_flags = dir->flags;18991900while(len && path[len -1] =='/')1901 len--;1902if(!len)1903return1;1904 baselen =0;1905 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1906while(1) {1907 cp = path + baselen + !!baselen;1908 cp =memchr(cp,'/', path + len - cp);1909if(!cp)1910 baselen = len;1911else1912 baselen = cp - path;1913strbuf_setlen(&sb,0);1914strbuf_add(&sb, path, baselen);1915if(!is_directory(sb.buf))1916break;1917if(simplify_away(sb.buf, sb.len, pathspec))1918break;1919if(treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,1920 DT_DIR, NULL) == path_none)1921break;/* do not recurse into it */1922if(len <= baselen) {1923 rc =1;1924break;/* finished checking */1925}1926}1927strbuf_release(&sb);1928 dir->flags = old_flags;1929return rc;1930}19311932static const char*get_ident_string(void)1933{1934static struct strbuf sb = STRBUF_INIT;1935struct utsname uts;19361937if(sb.len)1938return sb.buf;1939if(uname(&uts) <0)1940die_errno(_("failed to get kernel name and information"));1941strbuf_addf(&sb,"Location%s, system%s",get_git_work_tree(),1942 uts.sysname);1943return sb.buf;1944}19451946static intident_in_untracked(const struct untracked_cache *uc)1947{1948/*1949 * Previous git versions may have saved many NUL separated1950 * strings in the "ident" field, but it is insane to manage1951 * many locations, so just take care of the first one.1952 */19531954return!strcmp(uc->ident.buf,get_ident_string());1955}19561957static voidset_untracked_ident(struct untracked_cache *uc)1958{1959strbuf_reset(&uc->ident);1960strbuf_addstr(&uc->ident,get_ident_string());19611962/*1963 * This strbuf used to contain a list of NUL separated1964 * strings, so save NUL too for backward compatibility.1965 */1966strbuf_addch(&uc->ident,0);1967}19681969static voidnew_untracked_cache(struct index_state *istate)1970{1971struct untracked_cache *uc =xcalloc(1,sizeof(*uc));1972strbuf_init(&uc->ident,100);1973 uc->exclude_per_dir =".gitignore";1974/* should be the same flags used by git-status */1975 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;1976set_untracked_ident(uc);1977 istate->untracked = uc;1978 istate->cache_changed |= UNTRACKED_CHANGED;1979}19801981voidadd_untracked_cache(struct index_state *istate)1982{1983if(!istate->untracked) {1984new_untracked_cache(istate);1985}else{1986if(!ident_in_untracked(istate->untracked)) {1987free_untracked_cache(istate->untracked);1988new_untracked_cache(istate);1989}1990}1991}19921993voidremove_untracked_cache(struct index_state *istate)1994{1995if(istate->untracked) {1996free_untracked_cache(istate->untracked);1997 istate->untracked = NULL;1998 istate->cache_changed |= UNTRACKED_CHANGED;1999}2000}20012002static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,2003int base_len,2004const struct pathspec *pathspec)2005{2006struct untracked_cache_dir *root;20072008if(!dir->untracked ||getenv("GIT_DISABLE_UNTRACKED_CACHE"))2009return NULL;20102011/*2012 * We only support $GIT_DIR/info/exclude and core.excludesfile2013 * as the global ignore rule files. Any other additions2014 * (e.g. from command line) invalidate the cache. This2015 * condition also catches running setup_standard_excludes()2016 * before setting dir->untracked!2017 */2018if(dir->unmanaged_exclude_files)2019return NULL;20202021/*2022 * Optimize for the main use case only: whole-tree git2023 * status. More work involved in treat_leading_path() if we2024 * use cache on just a subset of the worktree. pathspec2025 * support could make the matter even worse.2026 */2027if(base_len || (pathspec && pathspec->nr))2028return NULL;20292030/* Different set of flags may produce different results */2031if(dir->flags != dir->untracked->dir_flags ||2032/*2033 * See treat_directory(), case index_nonexistent. Without2034 * this flag, we may need to also cache .git file content2035 * for the resolve_gitlink_ref() call, which we don't.2036 */2037!(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2038/* We don't support collecting ignore files */2039(dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2040 DIR_COLLECT_IGNORED)))2041return NULL;20422043/*2044 * If we use .gitignore in the cache and now you change it to2045 * .gitexclude, everything will go wrong.2046 */2047if(dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2048strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2049return NULL;20502051/*2052 * EXC_CMDL is not considered in the cache. If people set it,2053 * skip the cache.2054 */2055if(dir->exclude_list_group[EXC_CMDL].nr)2056return NULL;20572058if(!ident_in_untracked(dir->untracked)) {2059warning(_("Untracked cache is disabled on this system or location."));2060return NULL;2061}20622063if(!dir->untracked->root) {2064const int len =sizeof(*dir->untracked->root);2065 dir->untracked->root =xmalloc(len);2066memset(dir->untracked->root,0, len);2067}20682069/* Validate $GIT_DIR/info/exclude and core.excludesfile */2070 root = dir->untracked->root;2071if(hashcmp(dir->ss_info_exclude.sha1,2072 dir->untracked->ss_info_exclude.sha1)) {2073invalidate_gitignore(dir->untracked, root);2074 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2075}2076if(hashcmp(dir->ss_excludes_file.sha1,2077 dir->untracked->ss_excludes_file.sha1)) {2078invalidate_gitignore(dir->untracked, root);2079 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2080}20812082/* Make sure this directory is not dropped out at saving phase */2083 root->recurse =1;2084return root;2085}20862087intread_directory(struct dir_struct *dir,struct index_state *istate,2088const char*path,int len,const struct pathspec *pathspec)2089{2090struct untracked_cache_dir *untracked;20912092if(has_symlink_leading_path(path, len))2093return dir->nr;20942095 untracked =validate_untracked_cache(dir, len, pathspec);2096if(!untracked)2097/*2098 * make sure untracked cache code path is disabled,2099 * e.g. prep_exclude()2100 */2101 dir->untracked = NULL;2102if(!len ||treat_leading_path(dir, istate, path, len, pathspec))2103read_directory_recursive(dir, istate, path, len, untracked,0, pathspec);2104QSORT(dir->entries, dir->nr, cmp_dir_entry);2105QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);21062107/*2108 * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will2109 * also pick up untracked contents of untracked dirs; by default2110 * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.2111 */2112if((dir->flags & DIR_SHOW_IGNORED_TOO) &&2113!(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {2114int i, j;21152116/* remove from dir->entries untracked contents of untracked dirs */2117for(i = j =0; j < dir->nr; j++) {2118if(i &&2119check_dir_entry_contains(dir->entries[i -1], dir->entries[j])) {2120free(dir->entries[j]);2121 dir->entries[j] = NULL;2122}else{2123 dir->entries[i++] = dir->entries[j];2124}2125}21262127 dir->nr = i;2128}21292130if(dir->untracked) {2131static struct trace_key trace_untracked_stats =TRACE_KEY_INIT(UNTRACKED_STATS);2132trace_printf_key(&trace_untracked_stats,2133"node creation:%u\n"2134"gitignore invalidation:%u\n"2135"directory invalidation:%u\n"2136"opendir:%u\n",2137 dir->untracked->dir_created,2138 dir->untracked->gitignore_invalidated,2139 dir->untracked->dir_invalidated,2140 dir->untracked->dir_opened);2141if(dir->untracked == istate->untracked &&2142(dir->untracked->dir_opened ||2143 dir->untracked->gitignore_invalidated ||2144 dir->untracked->dir_invalidated))2145 istate->cache_changed |= UNTRACKED_CHANGED;2146if(dir->untracked != istate->untracked) {2147free(dir->untracked);2148 dir->untracked = NULL;2149}2150}2151return dir->nr;2152}21532154intfile_exists(const char*f)2155{2156struct stat sb;2157returnlstat(f, &sb) ==0;2158}21592160static intcmp_icase(char a,char b)2161{2162if(a == b)2163return0;2164if(ignore_case)2165returntoupper(a) -toupper(b);2166return a - b;2167}21682169/*2170 * Given two normalized paths (a trailing slash is ok), if subdir is2171 * outside dir, return -1. Otherwise return the offset in subdir that2172 * can be used as relative path to dir.2173 */2174intdir_inside_of(const char*subdir,const char*dir)2175{2176int offset =0;21772178assert(dir && subdir && *dir && *subdir);21792180while(*dir && *subdir && !cmp_icase(*dir, *subdir)) {2181 dir++;2182 subdir++;2183 offset++;2184}21852186/* hel[p]/me vs hel[l]/yeah */2187if(*dir && *subdir)2188return-1;21892190if(!*subdir)2191return!*dir ? offset : -1;/* same dir */21922193/* foo/[b]ar vs foo/[] */2194if(is_dir_sep(dir[-1]))2195returnis_dir_sep(subdir[-1]) ? offset : -1;21962197/* foo[/]bar vs foo[] */2198returnis_dir_sep(*subdir) ? offset +1: -1;2199}22002201intis_inside_dir(const char*dir)2202{2203char*cwd;2204int rc;22052206if(!dir)2207return0;22082209 cwd =xgetcwd();2210 rc = (dir_inside_of(cwd, dir) >=0);2211free(cwd);2212return rc;2213}22142215intis_empty_dir(const char*path)2216{2217DIR*dir =opendir(path);2218struct dirent *e;2219int ret =1;22202221if(!dir)2222return0;22232224while((e =readdir(dir)) != NULL)2225if(!is_dot_or_dotdot(e->d_name)) {2226 ret =0;2227break;2228}22292230closedir(dir);2231return ret;2232}22332234static intremove_dir_recurse(struct strbuf *path,int flag,int*kept_up)2235{2236DIR*dir;2237struct dirent *e;2238int ret =0, original_len = path->len, len, kept_down =0;2239int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2240int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2241unsigned char submodule_head[20];22422243if((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2244!resolve_gitlink_ref(path->buf,"HEAD", submodule_head)) {2245/* Do not descend and nuke a nested git work tree. */2246if(kept_up)2247*kept_up =1;2248return0;2249}22502251 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2252 dir =opendir(path->buf);2253if(!dir) {2254if(errno == ENOENT)2255return keep_toplevel ? -1:0;2256else if(errno == EACCES && !keep_toplevel)2257/*2258 * An empty dir could be removable even if it2259 * is unreadable:2260 */2261returnrmdir(path->buf);2262else2263return-1;2264}2265strbuf_complete(path,'/');22662267 len = path->len;2268while((e =readdir(dir)) != NULL) {2269struct stat st;2270if(is_dot_or_dotdot(e->d_name))2271continue;22722273strbuf_setlen(path, len);2274strbuf_addstr(path, e->d_name);2275if(lstat(path->buf, &st)) {2276if(errno == ENOENT)2277/*2278 * file disappeared, which is what we2279 * wanted anyway2280 */2281continue;2282/* fall thru */2283}else if(S_ISDIR(st.st_mode)) {2284if(!remove_dir_recurse(path, flag, &kept_down))2285continue;/* happy */2286}else if(!only_empty &&2287(!unlink(path->buf) || errno == ENOENT)) {2288continue;/* happy, too */2289}22902291/* path too long, stat fails, or non-directory still exists */2292 ret = -1;2293break;2294}2295closedir(dir);22962297strbuf_setlen(path, original_len);2298if(!ret && !keep_toplevel && !kept_down)2299 ret = (!rmdir(path->buf) || errno == ENOENT) ?0: -1;2300else if(kept_up)2301/*2302 * report the uplevel that it is not an error that we2303 * did not rmdir() our directory.2304 */2305*kept_up = !ret;2306return ret;2307}23082309intremove_dir_recursively(struct strbuf *path,int flag)2310{2311returnremove_dir_recurse(path, flag, NULL);2312}23132314staticGIT_PATH_FUNC(git_path_info_exclude,"info/exclude")23152316voidsetup_standard_excludes(struct dir_struct *dir)2317{2318 dir->exclude_per_dir =".gitignore";23192320/* core.excludefile defaulting to $XDG_HOME/git/ignore */2321if(!excludes_file)2322 excludes_file =xdg_config_home("ignore");2323if(excludes_file && !access_or_warn(excludes_file, R_OK,0))2324add_excludes_from_file_1(dir, excludes_file,2325 dir->untracked ? &dir->ss_excludes_file : NULL);23262327/* per repository user preference */2328if(startup_info->have_repository) {2329const char*path =git_path_info_exclude();2330if(!access_or_warn(path, R_OK,0))2331add_excludes_from_file_1(dir, path,2332 dir->untracked ? &dir->ss_info_exclude : NULL);2333}2334}23352336intremove_path(const char*name)2337{2338char*slash;23392340if(unlink(name) && !is_missing_file_error(errno))2341return-1;23422343 slash =strrchr(name,'/');2344if(slash) {2345char*dirs =xstrdup(name);2346 slash = dirs + (slash - name);2347do{2348*slash ='\0';2349}while(rmdir(dirs) ==0&& (slash =strrchr(dirs,'/')));2350free(dirs);2351}2352return0;2353}23542355/*2356 * Frees memory within dir which was allocated for exclude lists and2357 * the exclude_stack. Does not free dir itself.2358 */2359voidclear_directory(struct dir_struct *dir)2360{2361int i, j;2362struct exclude_list_group *group;2363struct exclude_list *el;2364struct exclude_stack *stk;23652366for(i = EXC_CMDL; i <= EXC_FILE; i++) {2367 group = &dir->exclude_list_group[i];2368for(j =0; j < group->nr; j++) {2369 el = &group->el[j];2370if(i == EXC_DIRS)2371free((char*)el->src);2372clear_exclude_list(el);2373}2374free(group->el);2375}23762377 stk = dir->exclude_stack;2378while(stk) {2379struct exclude_stack *prev = stk->prev;2380free(stk);2381 stk = prev;2382}2383strbuf_release(&dir->basebuf);2384}23852386struct ondisk_untracked_cache {2387struct stat_data info_exclude_stat;2388struct stat_data excludes_file_stat;2389uint32_t dir_flags;2390unsigned char info_exclude_sha1[20];2391unsigned char excludes_file_sha1[20];2392char exclude_per_dir[FLEX_ARRAY];2393};23942395#define ouc_size(len) (offsetof(struct ondisk_untracked_cache, exclude_per_dir) + len + 1)23962397struct write_data {2398int index;/* number of written untracked_cache_dir */2399struct ewah_bitmap *check_only;/* from untracked_cache_dir */2400struct ewah_bitmap *valid;/* from untracked_cache_dir */2401struct ewah_bitmap *sha1_valid;/* set if exclude_sha1 is not null */2402struct strbuf out;2403struct strbuf sb_stat;2404struct strbuf sb_sha1;2405};24062407static voidstat_data_to_disk(struct stat_data *to,const struct stat_data *from)2408{2409 to->sd_ctime.sec =htonl(from->sd_ctime.sec);2410 to->sd_ctime.nsec =htonl(from->sd_ctime.nsec);2411 to->sd_mtime.sec =htonl(from->sd_mtime.sec);2412 to->sd_mtime.nsec =htonl(from->sd_mtime.nsec);2413 to->sd_dev =htonl(from->sd_dev);2414 to->sd_ino =htonl(from->sd_ino);2415 to->sd_uid =htonl(from->sd_uid);2416 to->sd_gid =htonl(from->sd_gid);2417 to->sd_size =htonl(from->sd_size);2418}24192420static voidwrite_one_dir(struct untracked_cache_dir *untracked,2421struct write_data *wd)2422{2423struct stat_data stat_data;2424struct strbuf *out = &wd->out;2425unsigned char intbuf[16];2426unsigned int intlen, value;2427int i = wd->index++;24282429/*2430 * untracked_nr should be reset whenever valid is clear, but2431 * for safety..2432 */2433if(!untracked->valid) {2434 untracked->untracked_nr =0;2435 untracked->check_only =0;2436}24372438if(untracked->check_only)2439ewah_set(wd->check_only, i);2440if(untracked->valid) {2441ewah_set(wd->valid, i);2442stat_data_to_disk(&stat_data, &untracked->stat_data);2443strbuf_add(&wd->sb_stat, &stat_data,sizeof(stat_data));2444}2445if(!is_null_sha1(untracked->exclude_sha1)) {2446ewah_set(wd->sha1_valid, i);2447strbuf_add(&wd->sb_sha1, untracked->exclude_sha1,20);2448}24492450 intlen =encode_varint(untracked->untracked_nr, intbuf);2451strbuf_add(out, intbuf, intlen);24522453/* skip non-recurse directories */2454for(i =0, value =0; i < untracked->dirs_nr; i++)2455if(untracked->dirs[i]->recurse)2456 value++;2457 intlen =encode_varint(value, intbuf);2458strbuf_add(out, intbuf, intlen);24592460strbuf_add(out, untracked->name,strlen(untracked->name) +1);24612462for(i =0; i < untracked->untracked_nr; i++)2463strbuf_add(out, untracked->untracked[i],2464strlen(untracked->untracked[i]) +1);24652466for(i =0; i < untracked->dirs_nr; i++)2467if(untracked->dirs[i]->recurse)2468write_one_dir(untracked->dirs[i], wd);2469}24702471voidwrite_untracked_extension(struct strbuf *out,struct untracked_cache *untracked)2472{2473struct ondisk_untracked_cache *ouc;2474struct write_data wd;2475unsigned char varbuf[16];2476int varint_len;2477size_t len =strlen(untracked->exclude_per_dir);24782479FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2480stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2481stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2482hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);2483hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.sha1);2484 ouc->dir_flags =htonl(untracked->dir_flags);24852486 varint_len =encode_varint(untracked->ident.len, varbuf);2487strbuf_add(out, varbuf, varint_len);2488strbuf_addbuf(out, &untracked->ident);24892490strbuf_add(out, ouc,ouc_size(len));2491free(ouc);2492 ouc = NULL;24932494if(!untracked->root) {2495 varint_len =encode_varint(0, varbuf);2496strbuf_add(out, varbuf, varint_len);2497return;2498}24992500 wd.index =0;2501 wd.check_only =ewah_new();2502 wd.valid =ewah_new();2503 wd.sha1_valid =ewah_new();2504strbuf_init(&wd.out,1024);2505strbuf_init(&wd.sb_stat,1024);2506strbuf_init(&wd.sb_sha1,1024);2507write_one_dir(untracked->root, &wd);25082509 varint_len =encode_varint(wd.index, varbuf);2510strbuf_add(out, varbuf, varint_len);2511strbuf_addbuf(out, &wd.out);2512ewah_serialize_strbuf(wd.valid, out);2513ewah_serialize_strbuf(wd.check_only, out);2514ewah_serialize_strbuf(wd.sha1_valid, out);2515strbuf_addbuf(out, &wd.sb_stat);2516strbuf_addbuf(out, &wd.sb_sha1);2517strbuf_addch(out,'\0');/* safe guard for string lists */25182519ewah_free(wd.valid);2520ewah_free(wd.check_only);2521ewah_free(wd.sha1_valid);2522strbuf_release(&wd.out);2523strbuf_release(&wd.sb_stat);2524strbuf_release(&wd.sb_sha1);2525}25262527static voidfree_untracked(struct untracked_cache_dir *ucd)2528{2529int i;2530if(!ucd)2531return;2532for(i =0; i < ucd->dirs_nr; i++)2533free_untracked(ucd->dirs[i]);2534for(i =0; i < ucd->untracked_nr; i++)2535free(ucd->untracked[i]);2536free(ucd->untracked);2537free(ucd->dirs);2538free(ucd);2539}25402541voidfree_untracked_cache(struct untracked_cache *uc)2542{2543if(uc)2544free_untracked(uc->root);2545free(uc);2546}25472548struct read_data {2549int index;2550struct untracked_cache_dir **ucd;2551struct ewah_bitmap *check_only;2552struct ewah_bitmap *valid;2553struct ewah_bitmap *sha1_valid;2554const unsigned char*data;2555const unsigned char*end;2556};25572558static voidstat_data_from_disk(struct stat_data *to,const struct stat_data *from)2559{2560 to->sd_ctime.sec =get_be32(&from->sd_ctime.sec);2561 to->sd_ctime.nsec =get_be32(&from->sd_ctime.nsec);2562 to->sd_mtime.sec =get_be32(&from->sd_mtime.sec);2563 to->sd_mtime.nsec =get_be32(&from->sd_mtime.nsec);2564 to->sd_dev =get_be32(&from->sd_dev);2565 to->sd_ino =get_be32(&from->sd_ino);2566 to->sd_uid =get_be32(&from->sd_uid);2567 to->sd_gid =get_be32(&from->sd_gid);2568 to->sd_size =get_be32(&from->sd_size);2569}25702571static intread_one_dir(struct untracked_cache_dir **untracked_,2572struct read_data *rd)2573{2574struct untracked_cache_dir ud, *untracked;2575const unsigned char*next, *data = rd->data, *end = rd->end;2576unsigned int value;2577int i, len;25782579memset(&ud,0,sizeof(ud));25802581 next = data;2582 value =decode_varint(&next);2583if(next > end)2584return-1;2585 ud.recurse =1;2586 ud.untracked_alloc = value;2587 ud.untracked_nr = value;2588if(ud.untracked_nr)2589ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2590 data = next;25912592 next = data;2593 ud.dirs_alloc = ud.dirs_nr =decode_varint(&next);2594if(next > end)2595return-1;2596ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2597 data = next;25982599 len =strlen((const char*)data);2600 next = data + len +1;2601if(next > rd->end)2602return-1;2603*untracked_ = untracked =xmalloc(st_add(sizeof(*untracked), len));2604memcpy(untracked, &ud,sizeof(ud));2605memcpy(untracked->name, data, len +1);2606 data = next;26072608for(i =0; i < untracked->untracked_nr; i++) {2609 len =strlen((const char*)data);2610 next = data + len +1;2611if(next > rd->end)2612return-1;2613 untracked->untracked[i] =xstrdup((const char*)data);2614 data = next;2615}26162617 rd->ucd[rd->index++] = untracked;2618 rd->data = data;26192620for(i =0; i < untracked->dirs_nr; i++) {2621 len =read_one_dir(untracked->dirs + i, rd);2622if(len <0)2623return-1;2624}2625return0;2626}26272628static voidset_check_only(size_t pos,void*cb)2629{2630struct read_data *rd = cb;2631struct untracked_cache_dir *ud = rd->ucd[pos];2632 ud->check_only =1;2633}26342635static voidread_stat(size_t pos,void*cb)2636{2637struct read_data *rd = cb;2638struct untracked_cache_dir *ud = rd->ucd[pos];2639if(rd->data +sizeof(struct stat_data) > rd->end) {2640 rd->data = rd->end +1;2641return;2642}2643stat_data_from_disk(&ud->stat_data, (struct stat_data *)rd->data);2644 rd->data +=sizeof(struct stat_data);2645 ud->valid =1;2646}26472648static voidread_sha1(size_t pos,void*cb)2649{2650struct read_data *rd = cb;2651struct untracked_cache_dir *ud = rd->ucd[pos];2652if(rd->data +20> rd->end) {2653 rd->data = rd->end +1;2654return;2655}2656hashcpy(ud->exclude_sha1, rd->data);2657 rd->data +=20;2658}26592660static voidload_sha1_stat(struct sha1_stat *sha1_stat,2661const struct stat_data *stat,2662const unsigned char*sha1)2663{2664stat_data_from_disk(&sha1_stat->stat, stat);2665hashcpy(sha1_stat->sha1, sha1);2666 sha1_stat->valid =1;2667}26682669struct untracked_cache *read_untracked_extension(const void*data,unsigned long sz)2670{2671const struct ondisk_untracked_cache *ouc;2672struct untracked_cache *uc;2673struct read_data rd;2674const unsigned char*next = data, *end = (const unsigned char*)data + sz;2675const char*ident;2676int ident_len, len;26772678if(sz <=1|| end[-1] !='\0')2679return NULL;2680 end--;26812682 ident_len =decode_varint(&next);2683if(next + ident_len > end)2684return NULL;2685 ident = (const char*)next;2686 next += ident_len;26872688 ouc = (const struct ondisk_untracked_cache *)next;2689if(next +ouc_size(0) > end)2690return NULL;26912692 uc =xcalloc(1,sizeof(*uc));2693strbuf_init(&uc->ident, ident_len);2694strbuf_add(&uc->ident, ident, ident_len);2695load_sha1_stat(&uc->ss_info_exclude, &ouc->info_exclude_stat,2696 ouc->info_exclude_sha1);2697load_sha1_stat(&uc->ss_excludes_file, &ouc->excludes_file_stat,2698 ouc->excludes_file_sha1);2699 uc->dir_flags =get_be32(&ouc->dir_flags);2700 uc->exclude_per_dir =xstrdup(ouc->exclude_per_dir);2701/* NUL after exclude_per_dir is covered by sizeof(*ouc) */2702 next +=ouc_size(strlen(ouc->exclude_per_dir));2703if(next >= end)2704goto done2;27052706 len =decode_varint(&next);2707if(next > end || len ==0)2708goto done2;27092710 rd.valid =ewah_new();2711 rd.check_only =ewah_new();2712 rd.sha1_valid =ewah_new();2713 rd.data = next;2714 rd.end = end;2715 rd.index =0;2716ALLOC_ARRAY(rd.ucd, len);27172718if(read_one_dir(&uc->root, &rd) || rd.index != len)2719goto done;27202721 next = rd.data;2722 len =ewah_read_mmap(rd.valid, next, end - next);2723if(len <0)2724goto done;27252726 next += len;2727 len =ewah_read_mmap(rd.check_only, next, end - next);2728if(len <0)2729goto done;27302731 next += len;2732 len =ewah_read_mmap(rd.sha1_valid, next, end - next);2733if(len <0)2734goto done;27352736ewah_each_bit(rd.check_only, set_check_only, &rd);2737 rd.data = next + len;2738ewah_each_bit(rd.valid, read_stat, &rd);2739ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2740 next = rd.data;27412742done:2743free(rd.ucd);2744ewah_free(rd.valid);2745ewah_free(rd.check_only);2746ewah_free(rd.sha1_valid);2747done2:2748if(next != end) {2749free_untracked_cache(uc);2750 uc = NULL;2751}2752return uc;2753}27542755static voidinvalidate_one_directory(struct untracked_cache *uc,2756struct untracked_cache_dir *ucd)2757{2758 uc->dir_invalidated++;2759 ucd->valid =0;2760 ucd->untracked_nr =0;2761}27622763/*2764 * Normally when an entry is added or removed from a directory,2765 * invalidating that directory is enough. No need to touch its2766 * ancestors. When a directory is shown as "foo/bar/" in git-status2767 * however, deleting or adding an entry may have cascading effect.2768 *2769 * Say the "foo/bar/file" has become untracked, we need to tell the2770 * untracked_cache_dir of "foo" that "bar/" is not an untracked2771 * directory any more (because "bar" is managed by foo as an untracked2772 * "file").2773 *2774 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2775 * was the last untracked entry in the entire "foo", we should show2776 * "foo/" instead. Which means we have to invalidate past "bar" up to2777 * "foo".2778 *2779 * This function traverses all directories from root to leaf. If there2780 * is a chance of one of the above cases happening, we invalidate back2781 * to root. Otherwise we just invalidate the leaf. There may be a more2782 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2783 * detect these cases and avoid unnecessary invalidation, for example,2784 * checking for the untracked entry named "bar/" in "foo", but for now2785 * stick to something safe and simple.2786 */2787static intinvalidate_one_component(struct untracked_cache *uc,2788struct untracked_cache_dir *dir,2789const char*path,int len)2790{2791const char*rest =strchr(path,'/');27922793if(rest) {2794int component_len = rest - path;2795struct untracked_cache_dir *d =2796lookup_untracked(uc, dir, path, component_len);2797int ret =2798invalidate_one_component(uc, d, rest +1,2799 len - (component_len +1));2800if(ret)2801invalidate_one_directory(uc, dir);2802return ret;2803}28042805invalidate_one_directory(uc, dir);2806return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2807}28082809voiduntracked_cache_invalidate_path(struct index_state *istate,2810const char*path)2811{2812if(!istate->untracked || !istate->untracked->root)2813return;2814invalidate_one_component(istate->untracked, istate->untracked->root,2815 path,strlen(path));2816}28172818voiduntracked_cache_remove_from_index(struct index_state *istate,2819const char*path)2820{2821untracked_cache_invalidate_path(istate, path);2822}28232824voiduntracked_cache_add_to_index(struct index_state *istate,2825const char*path)2826{2827untracked_cache_invalidate_path(istate, path);2828}28292830/* Update gitfile and core.worktree setting to connect work tree and git dir */2831voidconnect_work_tree_and_git_dir(const char*work_tree_,const char*git_dir_)2832{2833struct strbuf gitfile_sb = STRBUF_INIT;2834struct strbuf cfg_sb = STRBUF_INIT;2835struct strbuf rel_path = STRBUF_INIT;2836char*git_dir, *work_tree;28372838/* Prepare .git file */2839strbuf_addf(&gitfile_sb,"%s/.git", work_tree_);2840if(safe_create_leading_directories_const(gitfile_sb.buf))2841die(_("could not create directories for%s"), gitfile_sb.buf);28422843/* Prepare config file */2844strbuf_addf(&cfg_sb,"%s/config", git_dir_);2845if(safe_create_leading_directories_const(cfg_sb.buf))2846die(_("could not create directories for%s"), cfg_sb.buf);28472848 git_dir =real_pathdup(git_dir_,1);2849 work_tree =real_pathdup(work_tree_,1);28502851/* Write .git file */2852write_file(gitfile_sb.buf,"gitdir:%s",2853relative_path(git_dir, work_tree, &rel_path));2854/* Update core.worktree setting */2855git_config_set_in_file(cfg_sb.buf,"core.worktree",2856relative_path(work_tree, git_dir, &rel_path));28572858strbuf_release(&gitfile_sb);2859strbuf_release(&cfg_sb);2860strbuf_release(&rel_path);2861free(work_tree);2862free(git_dir);2863}28642865/*2866 * Migrate the git directory of the given path from old_git_dir to new_git_dir.2867 */2868voidrelocate_gitdir(const char*path,const char*old_git_dir,const char*new_git_dir)2869{2870if(rename(old_git_dir, new_git_dir) <0)2871die_errno(_("could not migrate git directory from '%s' to '%s'"),2872 old_git_dir, new_git_dir);28732874connect_work_tree_and_git_dir(path, new_git_dir);2875}