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,const struct pathspec *pathspec) 181{ 182const char*prefix; 183size_t prefix_len; 184 185/* 186 * Calculate common prefix for the pathspec, and 187 * use that to optimize the directory walk 188 */ 189 prefix_len =common_prefix_len(pathspec); 190 prefix = prefix_len ? pathspec->items[0].match :""; 191 192/* Read the directory and prune it */ 193read_directory(dir, &the_index, prefix, prefix_len, pathspec); 194 195return prefix_len; 196} 197 198intwithin_depth(const char*name,int namelen, 199int depth,int max_depth) 200{ 201const char*cp = name, *cpe = name + namelen; 202 203while(cp < cpe) { 204if(*cp++ !='/') 205continue; 206 depth++; 207if(depth > max_depth) 208return0; 209} 210return1; 211} 212 213#define DO_MATCH_EXCLUDE (1<<0) 214#define DO_MATCH_DIRECTORY (1<<1) 215#define DO_MATCH_SUBMODULE (1<<2) 216 217static intmatch_attrs(const char*name,int namelen, 218const struct pathspec_item *item) 219{ 220int i; 221 222git_check_attr(name, item->attr_check); 223for(i =0; i < item->attr_match_nr; i++) { 224const char*value; 225int matched; 226enum attr_match_mode match_mode; 227 228 value = item->attr_check->items[i].value; 229 match_mode = item->attr_match[i].match_mode; 230 231if(ATTR_TRUE(value)) 232 matched = (match_mode == MATCH_SET); 233else if(ATTR_FALSE(value)) 234 matched = (match_mode == MATCH_UNSET); 235else if(ATTR_UNSET(value)) 236 matched = (match_mode == MATCH_UNSPECIFIED); 237else 238 matched = (match_mode == MATCH_VALUE && 239!strcmp(item->attr_match[i].value, value)); 240if(!matched) 241return0; 242} 243 244return1; 245} 246 247/* 248 * Does 'match' match the given name? 249 * A match is found if 250 * 251 * (1) the 'match' string is leading directory of 'name', or 252 * (2) the 'match' string is a wildcard and matches 'name', or 253 * (3) the 'match' string is exactly the same as 'name'. 254 * 255 * and the return value tells which case it was. 256 * 257 * It returns 0 when there is no match. 258 */ 259static intmatch_pathspec_item(const struct pathspec_item *item,int prefix, 260const char*name,int namelen,unsigned flags) 261{ 262/* name/namelen has prefix cut off by caller */ 263const char*match = item->match + prefix; 264int matchlen = item->len - prefix; 265 266/* 267 * The normal call pattern is: 268 * 1. prefix = common_prefix_len(ps); 269 * 2. prune something, or fill_directory 270 * 3. match_pathspec() 271 * 272 * 'prefix' at #1 may be shorter than the command's prefix and 273 * it's ok for #2 to match extra files. Those extras will be 274 * trimmed at #3. 275 * 276 * Suppose the pathspec is 'foo' and '../bar' running from 277 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 278 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 279 * user does not want XYZ/foo, only the "foo" part should be 280 * case-insensitive. We need to filter out XYZ/foo here. In 281 * other words, we do not trust the caller on comparing the 282 * prefix part when :(icase) is involved. We do exact 283 * comparison ourselves. 284 * 285 * Normally the caller (common_prefix_len() in fact) does 286 * _exact_ matching on name[-prefix+1..-1] and we do not need 287 * to check that part. Be defensive and check it anyway, in 288 * case common_prefix_len is changed, or a new caller is 289 * introduced that does not use common_prefix_len. 290 * 291 * If the penalty turns out too high when prefix is really 292 * long, maybe change it to 293 * strncmp(match, name, item->prefix - prefix) 294 */ 295if(item->prefix && (item->magic & PATHSPEC_ICASE) && 296strncmp(item->match, name - prefix, item->prefix)) 297return0; 298 299if(item->attr_match_nr && !match_attrs(name, namelen, item)) 300return0; 301 302/* If the match was just the prefix, we matched */ 303if(!*match) 304return MATCHED_RECURSIVELY; 305 306if(matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 307if(matchlen == namelen) 308return MATCHED_EXACTLY; 309 310if(match[matchlen-1] =='/'|| name[matchlen] =='/') 311return MATCHED_RECURSIVELY; 312}else if((flags & DO_MATCH_DIRECTORY) && 313 match[matchlen -1] =='/'&& 314 namelen == matchlen -1&& 315!ps_strncmp(item, match, name, namelen)) 316return MATCHED_EXACTLY; 317 318if(item->nowildcard_len < item->len && 319!git_fnmatch(item, match, name, 320 item->nowildcard_len - prefix)) 321return MATCHED_FNMATCH; 322 323/* Perform checks to see if "name" is a super set of the pathspec */ 324if(flags & DO_MATCH_SUBMODULE) { 325/* name is a literal prefix of the pathspec */ 326if((namelen < matchlen) && 327(match[namelen] =='/') && 328!ps_strncmp(item, match, name, namelen)) 329return MATCHED_RECURSIVELY; 330 331/* name" doesn't match up to the first wild character */ 332if(item->nowildcard_len < item->len && 333ps_strncmp(item, match, name, 334 item->nowildcard_len - prefix)) 335return0; 336 337/* 338 * Here is where we would perform a wildmatch to check if 339 * "name" can be matched as a directory (or a prefix) against 340 * the pathspec. Since wildmatch doesn't have this capability 341 * at the present we have to punt and say that it is a match, 342 * potentially returning a false positive 343 * The submodules themselves will be able to perform more 344 * accurate matching to determine if the pathspec matches. 345 */ 346return MATCHED_RECURSIVELY; 347} 348 349return0; 350} 351 352/* 353 * Given a name and a list of pathspecs, returns the nature of the 354 * closest (i.e. most specific) match of the name to any of the 355 * pathspecs. 356 * 357 * The caller typically calls this multiple times with the same 358 * pathspec and seen[] array but with different name/namelen 359 * (e.g. entries from the index) and is interested in seeing if and 360 * how each pathspec matches all the names it calls this function 361 * with. A mark is left in the seen[] array for each pathspec element 362 * indicating the closest type of match that element achieved, so if 363 * seen[n] remains zero after multiple invocations, that means the nth 364 * pathspec did not match any names, which could indicate that the 365 * user mistyped the nth pathspec. 366 */ 367static intdo_match_pathspec(const struct pathspec *ps, 368const char*name,int namelen, 369int prefix,char*seen, 370unsigned flags) 371{ 372int i, retval =0, exclude = flags & DO_MATCH_EXCLUDE; 373 374GUARD_PATHSPEC(ps, 375 PATHSPEC_FROMTOP | 376 PATHSPEC_MAXDEPTH | 377 PATHSPEC_LITERAL | 378 PATHSPEC_GLOB | 379 PATHSPEC_ICASE | 380 PATHSPEC_EXCLUDE | 381 PATHSPEC_ATTR); 382 383if(!ps->nr) { 384if(!ps->recursive || 385!(ps->magic & PATHSPEC_MAXDEPTH) || 386 ps->max_depth == -1) 387return MATCHED_RECURSIVELY; 388 389if(within_depth(name, namelen,0, ps->max_depth)) 390return MATCHED_EXACTLY; 391else 392return0; 393} 394 395 name += prefix; 396 namelen -= prefix; 397 398for(i = ps->nr -1; i >=0; i--) { 399int how; 400 401if((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 402( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 403continue; 404 405if(seen && seen[i] == MATCHED_EXACTLY) 406continue; 407/* 408 * Make exclude patterns optional and never report 409 * "pathspec ':(exclude)foo' matches no files" 410 */ 411if(seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 412 seen[i] = MATCHED_FNMATCH; 413 how =match_pathspec_item(ps->items+i, prefix, name, 414 namelen, flags); 415if(ps->recursive && 416(ps->magic & PATHSPEC_MAXDEPTH) && 417 ps->max_depth != -1&& 418 how && how != MATCHED_FNMATCH) { 419int len = ps->items[i].len; 420if(name[len] =='/') 421 len++; 422if(within_depth(name+len, namelen-len,0, ps->max_depth)) 423 how = MATCHED_EXACTLY; 424else 425 how =0; 426} 427if(how) { 428if(retval < how) 429 retval = how; 430if(seen && seen[i] < how) 431 seen[i] = how; 432} 433} 434return retval; 435} 436 437intmatch_pathspec(const struct pathspec *ps, 438const char*name,int namelen, 439int prefix,char*seen,int is_dir) 440{ 441int positive, negative; 442unsigned flags = is_dir ? DO_MATCH_DIRECTORY :0; 443 positive =do_match_pathspec(ps, name, namelen, 444 prefix, seen, flags); 445if(!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 446return positive; 447 negative =do_match_pathspec(ps, name, namelen, 448 prefix, seen, 449 flags | DO_MATCH_EXCLUDE); 450return negative ?0: positive; 451} 452 453/** 454 * Check if a submodule is a superset of the pathspec 455 */ 456intsubmodule_path_match(const struct pathspec *ps, 457const char*submodule_name, 458char*seen) 459{ 460int matched =do_match_pathspec(ps, submodule_name, 461strlen(submodule_name), 4620, seen, 463 DO_MATCH_DIRECTORY | 464 DO_MATCH_SUBMODULE); 465return matched; 466} 467 468intreport_path_error(const char*ps_matched, 469const struct pathspec *pathspec, 470const char*prefix) 471{ 472/* 473 * Make sure all pathspec matched; otherwise it is an error. 474 */ 475int num, errors =0; 476for(num =0; num < pathspec->nr; num++) { 477int other, found_dup; 478 479if(ps_matched[num]) 480continue; 481/* 482 * The caller might have fed identical pathspec 483 * twice. Do not barf on such a mistake. 484 * FIXME: parse_pathspec should have eliminated 485 * duplicate pathspec. 486 */ 487for(found_dup = other =0; 488!found_dup && other < pathspec->nr; 489 other++) { 490if(other == num || !ps_matched[other]) 491continue; 492if(!strcmp(pathspec->items[other].original, 493 pathspec->items[num].original)) 494/* 495 * Ok, we have a match already. 496 */ 497 found_dup =1; 498} 499if(found_dup) 500continue; 501 502error("pathspec '%s' did not match any file(s) known to git.", 503 pathspec->items[num].original); 504 errors++; 505} 506return errors; 507} 508 509/* 510 * Return the length of the "simple" part of a path match limiter. 511 */ 512intsimple_length(const char*match) 513{ 514int len = -1; 515 516for(;;) { 517unsigned char c = *match++; 518 len++; 519if(c =='\0'||is_glob_special(c)) 520return len; 521} 522} 523 524intno_wildcard(const char*string) 525{ 526return string[simple_length(string)] =='\0'; 527} 528 529voidparse_exclude_pattern(const char**pattern, 530int*patternlen, 531unsigned*flags, 532int*nowildcardlen) 533{ 534const char*p = *pattern; 535size_t i, len; 536 537*flags =0; 538if(*p =='!') { 539*flags |= EXC_FLAG_NEGATIVE; 540 p++; 541} 542 len =strlen(p); 543if(len && p[len -1] =='/') { 544 len--; 545*flags |= EXC_FLAG_MUSTBEDIR; 546} 547for(i =0; i < len; i++) { 548if(p[i] =='/') 549break; 550} 551if(i == len) 552*flags |= EXC_FLAG_NODIR; 553*nowildcardlen =simple_length(p); 554/* 555 * we should have excluded the trailing slash from 'p' too, 556 * but that's one more allocation. Instead just make sure 557 * nowildcardlen does not exceed real patternlen 558 */ 559if(*nowildcardlen > len) 560*nowildcardlen = len; 561if(*p =='*'&&no_wildcard(p +1)) 562*flags |= EXC_FLAG_ENDSWITH; 563*pattern = p; 564*patternlen = len; 565} 566 567voidadd_exclude(const char*string,const char*base, 568int baselen,struct exclude_list *el,int srcpos) 569{ 570struct exclude *x; 571int patternlen; 572unsigned flags; 573int nowildcardlen; 574 575parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 576if(flags & EXC_FLAG_MUSTBEDIR) { 577FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 578}else{ 579 x =xmalloc(sizeof(*x)); 580 x->pattern = string; 581} 582 x->patternlen = patternlen; 583 x->nowildcardlen = nowildcardlen; 584 x->base = base; 585 x->baselen = baselen; 586 x->flags = flags; 587 x->srcpos = srcpos; 588ALLOC_GROW(el->excludes, el->nr +1, el->alloc); 589 el->excludes[el->nr++] = x; 590 x->el = el; 591} 592 593static void*read_skip_worktree_file_from_index(const struct index_state *istate, 594const char*path,size_t*size, 595struct sha1_stat *sha1_stat) 596{ 597int pos, len; 598unsigned long sz; 599enum object_type type; 600void*data; 601 602 len =strlen(path); 603 pos =index_name_pos(istate, path, len); 604if(pos <0) 605return NULL; 606if(!ce_skip_worktree(istate->cache[pos])) 607return NULL; 608 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz); 609if(!data || type != OBJ_BLOB) { 610free(data); 611return NULL; 612} 613*size =xsize_t(sz); 614if(sha1_stat) { 615memset(&sha1_stat->stat,0,sizeof(sha1_stat->stat)); 616hashcpy(sha1_stat->sha1, istate->cache[pos]->oid.hash); 617} 618return data; 619} 620 621/* 622 * Frees memory within el which was allocated for exclude patterns and 623 * the file buffer. Does not free el itself. 624 */ 625voidclear_exclude_list(struct exclude_list *el) 626{ 627int i; 628 629for(i =0; i < el->nr; i++) 630free(el->excludes[i]); 631free(el->excludes); 632free(el->filebuf); 633 634memset(el,0,sizeof(*el)); 635} 636 637static voidtrim_trailing_spaces(char*buf) 638{ 639char*p, *last_space = NULL; 640 641for(p = buf; *p; p++) 642switch(*p) { 643case' ': 644if(!last_space) 645 last_space = p; 646break; 647case'\\': 648 p++; 649if(!*p) 650return; 651/* fallthrough */ 652default: 653 last_space = NULL; 654} 655 656if(last_space) 657*last_space ='\0'; 658} 659 660/* 661 * Given a subdirectory name and "dir" of the current directory, 662 * search the subdir in "dir" and return it, or create a new one if it 663 * does not exist in "dir". 664 * 665 * If "name" has the trailing slash, it'll be excluded in the search. 666 */ 667static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 668struct untracked_cache_dir *dir, 669const char*name,int len) 670{ 671int first, last; 672struct untracked_cache_dir *d; 673if(!dir) 674return NULL; 675if(len && name[len -1] =='/') 676 len--; 677 first =0; 678 last = dir->dirs_nr; 679while(last > first) { 680int cmp, next = (last + first) >>1; 681 d = dir->dirs[next]; 682 cmp =strncmp(name, d->name, len); 683if(!cmp &&strlen(d->name) > len) 684 cmp = -1; 685if(!cmp) 686return d; 687if(cmp <0) { 688 last = next; 689continue; 690} 691 first = next+1; 692} 693 694 uc->dir_created++; 695FLEX_ALLOC_MEM(d, name, name, len); 696 697ALLOC_GROW(dir->dirs, dir->dirs_nr +1, dir->dirs_alloc); 698memmove(dir->dirs + first +1, dir->dirs + first, 699(dir->dirs_nr - first) *sizeof(*dir->dirs)); 700 dir->dirs_nr++; 701 dir->dirs[first] = d; 702return d; 703} 704 705static voiddo_invalidate_gitignore(struct untracked_cache_dir *dir) 706{ 707int i; 708 dir->valid =0; 709 dir->untracked_nr =0; 710for(i =0; i < dir->dirs_nr; i++) 711do_invalidate_gitignore(dir->dirs[i]); 712} 713 714static voidinvalidate_gitignore(struct untracked_cache *uc, 715struct untracked_cache_dir *dir) 716{ 717 uc->gitignore_invalidated++; 718do_invalidate_gitignore(dir); 719} 720 721static voidinvalidate_directory(struct untracked_cache *uc, 722struct untracked_cache_dir *dir) 723{ 724int i; 725 uc->dir_invalidated++; 726 dir->valid =0; 727 dir->untracked_nr =0; 728for(i =0; i < dir->dirs_nr; i++) 729 dir->dirs[i]->recurse =0; 730} 731 732/* 733 * Given a file with name "fname", read it (either from disk, or from 734 * an index if 'istate' is non-null), parse it and store the 735 * exclude rules in "el". 736 * 737 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 738 * stat data from disk (only valid if add_excludes returns zero). If 739 * ss_valid is non-zero, "ss" must contain good value as input. 740 */ 741static intadd_excludes(const char*fname,const char*base,int baselen, 742struct exclude_list *el, 743struct index_state *istate, 744struct sha1_stat *sha1_stat) 745{ 746struct stat st; 747int fd, i, lineno =1; 748size_t size =0; 749char*buf, *entry; 750 751 fd =open(fname, O_RDONLY); 752if(fd <0||fstat(fd, &st) <0) { 753if(errno != ENOENT) 754warn_on_inaccessible(fname); 755if(0<= fd) 756close(fd); 757if(!istate || 758(buf =read_skip_worktree_file_from_index(istate, fname, &size, sha1_stat)) == NULL) 759return-1; 760if(size ==0) { 761free(buf); 762return0; 763} 764if(buf[size-1] !='\n') { 765 buf =xrealloc(buf,st_add(size,1)); 766 buf[size++] ='\n'; 767} 768}else{ 769 size =xsize_t(st.st_size); 770if(size ==0) { 771if(sha1_stat) { 772fill_stat_data(&sha1_stat->stat, &st); 773hashcpy(sha1_stat->sha1, EMPTY_BLOB_SHA1_BIN); 774 sha1_stat->valid =1; 775} 776close(fd); 777return0; 778} 779 buf =xmallocz(size); 780if(read_in_full(fd, buf, size) != size) { 781free(buf); 782close(fd); 783return-1; 784} 785 buf[size++] ='\n'; 786close(fd); 787if(sha1_stat) { 788int pos; 789if(sha1_stat->valid && 790!match_stat_data_racy(istate, &sha1_stat->stat, &st)) 791;/* no content change, ss->sha1 still good */ 792else if(istate && 793(pos =index_name_pos(istate, fname,strlen(fname))) >=0&& 794!ce_stage(istate->cache[pos]) && 795ce_uptodate(istate->cache[pos]) && 796!would_convert_to_git(fname)) 797hashcpy(sha1_stat->sha1, 798 istate->cache[pos]->oid.hash); 799else 800hash_sha1_file(buf, size,"blob", sha1_stat->sha1); 801fill_stat_data(&sha1_stat->stat, &st); 802 sha1_stat->valid =1; 803} 804} 805 806 el->filebuf = buf; 807 808if(skip_utf8_bom(&buf, size)) 809 size -= buf - el->filebuf; 810 811 entry = buf; 812 813for(i =0; i < size; i++) { 814if(buf[i] =='\n') { 815if(entry != buf + i && entry[0] !='#') { 816 buf[i - (i && buf[i-1] =='\r')] =0; 817trim_trailing_spaces(entry); 818add_exclude(entry, base, baselen, el, lineno); 819} 820 lineno++; 821 entry = buf + i +1; 822} 823} 824return0; 825} 826 827intadd_excludes_from_file_to_list(const char*fname,const char*base, 828int baselen,struct exclude_list *el, 829struct index_state *istate) 830{ 831returnadd_excludes(fname, base, baselen, el, istate, NULL); 832} 833 834struct exclude_list *add_exclude_list(struct dir_struct *dir, 835int group_type,const char*src) 836{ 837struct exclude_list *el; 838struct exclude_list_group *group; 839 840 group = &dir->exclude_list_group[group_type]; 841ALLOC_GROW(group->el, group->nr +1, group->alloc); 842 el = &group->el[group->nr++]; 843memset(el,0,sizeof(*el)); 844 el->src = src; 845return el; 846} 847 848/* 849 * Used to set up core.excludesfile and .git/info/exclude lists. 850 */ 851static voidadd_excludes_from_file_1(struct dir_struct *dir,const char*fname, 852struct sha1_stat *sha1_stat) 853{ 854struct exclude_list *el; 855/* 856 * catch setup_standard_excludes() that's called before 857 * dir->untracked is assigned. That function behaves 858 * differently when dir->untracked is non-NULL. 859 */ 860if(!dir->untracked) 861 dir->unmanaged_exclude_files++; 862 el =add_exclude_list(dir, EXC_FILE, fname); 863if(add_excludes(fname,"",0, el, NULL, sha1_stat) <0) 864die("cannot use%sas an exclude file", fname); 865} 866 867voidadd_excludes_from_file(struct dir_struct *dir,const char*fname) 868{ 869 dir->unmanaged_exclude_files++;/* see validate_untracked_cache() */ 870add_excludes_from_file_1(dir, fname, NULL); 871} 872 873intmatch_basename(const char*basename,int basenamelen, 874const char*pattern,int prefix,int patternlen, 875unsigned flags) 876{ 877if(prefix == patternlen) { 878if(patternlen == basenamelen && 879!fspathncmp(pattern, basename, basenamelen)) 880return1; 881}else if(flags & EXC_FLAG_ENDSWITH) { 882/* "*literal" matching against "fooliteral" */ 883if(patternlen -1<= basenamelen && 884!fspathncmp(pattern +1, 885 basename + basenamelen - (patternlen -1), 886 patternlen -1)) 887return1; 888}else{ 889if(fnmatch_icase_mem(pattern, patternlen, 890 basename, basenamelen, 8910) ==0) 892return1; 893} 894return0; 895} 896 897intmatch_pathname(const char*pathname,int pathlen, 898const char*base,int baselen, 899const char*pattern,int prefix,int patternlen, 900unsigned flags) 901{ 902const char*name; 903int namelen; 904 905/* 906 * match with FNM_PATHNAME; the pattern has base implicitly 907 * in front of it. 908 */ 909if(*pattern =='/') { 910 pattern++; 911 patternlen--; 912 prefix--; 913} 914 915/* 916 * baselen does not count the trailing slash. base[] may or 917 * may not end with a trailing slash though. 918 */ 919if(pathlen < baselen +1|| 920(baselen && pathname[baselen] !='/') || 921fspathncmp(pathname, base, baselen)) 922return0; 923 924 namelen = baselen ? pathlen - baselen -1: pathlen; 925 name = pathname + pathlen - namelen; 926 927if(prefix) { 928/* 929 * if the non-wildcard part is longer than the 930 * remaining pathname, surely it cannot match. 931 */ 932if(prefix > namelen) 933return0; 934 935if(fspathncmp(pattern, name, prefix)) 936return0; 937 pattern += prefix; 938 patternlen -= prefix; 939 name += prefix; 940 namelen -= prefix; 941 942/* 943 * If the whole pattern did not have a wildcard, 944 * then our prefix match is all we need; we 945 * do not need to call fnmatch at all. 946 */ 947if(!patternlen && !namelen) 948return1; 949} 950 951returnfnmatch_icase_mem(pattern, patternlen, 952 name, namelen, 953 WM_PATHNAME) ==0; 954} 955 956/* 957 * Scan the given exclude list in reverse to see whether pathname 958 * should be ignored. The first match (i.e. the last on the list), if 959 * any, determines the fate. Returns the exclude_list element which 960 * matched, or NULL for undecided. 961 */ 962static struct exclude *last_exclude_matching_from_list(const char*pathname, 963int pathlen, 964const char*basename, 965int*dtype, 966struct exclude_list *el, 967struct index_state *istate) 968{ 969struct exclude *exc = NULL;/* undecided */ 970int i; 971 972if(!el->nr) 973return NULL;/* undefined */ 974 975for(i = el->nr -1;0<= i; i--) { 976struct exclude *x = el->excludes[i]; 977const char*exclude = x->pattern; 978int prefix = x->nowildcardlen; 979 980if(x->flags & EXC_FLAG_MUSTBEDIR) { 981if(*dtype == DT_UNKNOWN) 982*dtype =get_dtype(NULL, istate, pathname, pathlen); 983if(*dtype != DT_DIR) 984continue; 985} 986 987if(x->flags & EXC_FLAG_NODIR) { 988if(match_basename(basename, 989 pathlen - (basename - pathname), 990 exclude, prefix, x->patternlen, 991 x->flags)) { 992 exc = x; 993break; 994} 995continue; 996} 997 998assert(x->baselen ==0|| x->base[x->baselen -1] =='/'); 999if(match_pathname(pathname, pathlen,1000 x->base, x->baselen ? x->baselen -1:0,1001 exclude, prefix, x->patternlen, x->flags)) {1002 exc = x;1003break;1004}1005}1006return exc;1007}10081009/*1010 * Scan the list and let the last match determine the fate.1011 * Return 1 for exclude, 0 for include and -1 for undecided.1012 */1013intis_excluded_from_list(const char*pathname,1014int pathlen,const char*basename,int*dtype,1015struct exclude_list *el,struct index_state *istate)1016{1017struct exclude *exclude;1018 exclude =last_exclude_matching_from_list(pathname, pathlen, basename,1019 dtype, el, istate);1020if(exclude)1021return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1022return-1;/* undecided */1023}10241025static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1026struct index_state *istate,1027const char*pathname,int pathlen,const char*basename,1028int*dtype_p)1029{1030int i, j;1031struct exclude_list_group *group;1032struct exclude *exclude;1033for(i = EXC_CMDL; i <= EXC_FILE; i++) {1034 group = &dir->exclude_list_group[i];1035for(j = group->nr -1; j >=0; j--) {1036 exclude =last_exclude_matching_from_list(1037 pathname, pathlen, basename, dtype_p,1038&group->el[j], istate);1039if(exclude)1040return exclude;1041}1042}1043return NULL;1044}10451046/*1047 * Loads the per-directory exclude list for the substring of base1048 * which has a char length of baselen.1049 */1050static voidprep_exclude(struct dir_struct *dir,1051struct index_state *istate,1052const char*base,int baselen)1053{1054struct exclude_list_group *group;1055struct exclude_list *el;1056struct exclude_stack *stk = NULL;1057struct untracked_cache_dir *untracked;1058int current;10591060 group = &dir->exclude_list_group[EXC_DIRS];10611062/*1063 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1064 * which originate from directories not in the prefix of the1065 * path being checked.1066 */1067while((stk = dir->exclude_stack) != NULL) {1068if(stk->baselen <= baselen &&1069!strncmp(dir->basebuf.buf, base, stk->baselen))1070break;1071 el = &group->el[dir->exclude_stack->exclude_ix];1072 dir->exclude_stack = stk->prev;1073 dir->exclude = NULL;1074free((char*)el->src);/* see strbuf_detach() below */1075clear_exclude_list(el);1076free(stk);1077 group->nr--;1078}10791080/* Skip traversing into sub directories if the parent is excluded */1081if(dir->exclude)1082return;10831084/*1085 * Lazy initialization. All call sites currently just1086 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1087 * them seems lots of work for little benefit.1088 */1089if(!dir->basebuf.buf)1090strbuf_init(&dir->basebuf, PATH_MAX);10911092/* Read from the parent directories and push them down. */1093 current = stk ? stk->baselen : -1;1094strbuf_setlen(&dir->basebuf, current <0?0: current);1095if(dir->untracked)1096 untracked = stk ? stk->ucd : dir->untracked->root;1097else1098 untracked = NULL;10991100while(current < baselen) {1101const char*cp;1102struct sha1_stat sha1_stat;11031104 stk =xcalloc(1,sizeof(*stk));1105if(current <0) {1106 cp = base;1107 current =0;1108}else{1109 cp =strchr(base + current +1,'/');1110if(!cp)1111die("oops in prep_exclude");1112 cp++;1113 untracked =1114lookup_untracked(dir->untracked, untracked,1115 base + current,1116 cp - base - current);1117}1118 stk->prev = dir->exclude_stack;1119 stk->baselen = cp - base;1120 stk->exclude_ix = group->nr;1121 stk->ucd = untracked;1122 el =add_exclude_list(dir, EXC_DIRS, NULL);1123strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1124assert(stk->baselen == dir->basebuf.len);11251126/* Abort if the directory is excluded */1127if(stk->baselen) {1128int dt = DT_DIR;1129 dir->basebuf.buf[stk->baselen -1] =0;1130 dir->exclude =last_exclude_matching_from_lists(dir,1131 istate,1132 dir->basebuf.buf, stk->baselen -1,1133 dir->basebuf.buf + current, &dt);1134 dir->basebuf.buf[stk->baselen -1] ='/';1135if(dir->exclude &&1136 dir->exclude->flags & EXC_FLAG_NEGATIVE)1137 dir->exclude = NULL;1138if(dir->exclude) {1139 dir->exclude_stack = stk;1140return;1141}1142}11431144/* Try to read per-directory file */1145hashclr(sha1_stat.sha1);1146 sha1_stat.valid =0;1147if(dir->exclude_per_dir &&1148/*1149 * If we know that no files have been added in1150 * this directory (i.e. valid_cached_dir() has1151 * been executed and set untracked->valid) ..1152 */1153(!untracked || !untracked->valid ||1154/*1155 * .. and .gitignore does not exist before1156 * (i.e. null exclude_sha1). Then we can skip1157 * loading .gitignore, which would result in1158 * ENOENT anyway.1159 */1160!is_null_sha1(untracked->exclude_sha1))) {1161/*1162 * dir->basebuf gets reused by the traversal, but we1163 * need fname to remain unchanged to ensure the src1164 * member of each struct exclude correctly1165 * back-references its source file. Other invocations1166 * of add_exclude_list provide stable strings, so we1167 * strbuf_detach() and free() here in the caller.1168 */1169struct strbuf sb = STRBUF_INIT;1170strbuf_addbuf(&sb, &dir->basebuf);1171strbuf_addstr(&sb, dir->exclude_per_dir);1172 el->src =strbuf_detach(&sb, NULL);1173add_excludes(el->src, el->src, stk->baselen, el, istate,1174 untracked ? &sha1_stat : NULL);1175}1176/*1177 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1178 * will first be called in valid_cached_dir() then maybe many1179 * times more in last_exclude_matching(). When the cache is1180 * used, last_exclude_matching() will not be called and1181 * reading .gitignore content will be a waste.1182 *1183 * So when it's called by valid_cached_dir() and we can get1184 * .gitignore SHA-1 from the index (i.e. .gitignore is not1185 * modified on work tree), we could delay reading the1186 * .gitignore content until we absolutely need it in1187 * last_exclude_matching(). Be careful about ignore rule1188 * order, though, if you do that.1189 */1190if(untracked &&1191hashcmp(sha1_stat.sha1, untracked->exclude_sha1)) {1192invalidate_gitignore(dir->untracked, untracked);1193hashcpy(untracked->exclude_sha1, sha1_stat.sha1);1194}1195 dir->exclude_stack = stk;1196 current = stk->baselen;1197}1198strbuf_setlen(&dir->basebuf, baselen);1199}12001201/*1202 * Loads the exclude lists for the directory containing pathname, then1203 * scans all exclude lists to determine whether pathname is excluded.1204 * Returns the exclude_list element which matched, or NULL for1205 * undecided.1206 */1207struct exclude *last_exclude_matching(struct dir_struct *dir,1208struct index_state *istate,1209const char*pathname,1210int*dtype_p)1211{1212int pathlen =strlen(pathname);1213const char*basename =strrchr(pathname,'/');1214 basename = (basename) ? basename+1: pathname;12151216prep_exclude(dir, istate, pathname, basename-pathname);12171218if(dir->exclude)1219return dir->exclude;12201221returnlast_exclude_matching_from_lists(dir, istate, pathname, pathlen,1222 basename, dtype_p);1223}12241225/*1226 * Loads the exclude lists for the directory containing pathname, then1227 * scans all exclude lists to determine whether pathname is excluded.1228 * Returns 1 if true, otherwise 0.1229 */1230intis_excluded(struct dir_struct *dir,struct index_state *istate,1231const char*pathname,int*dtype_p)1232{1233struct exclude *exclude =1234last_exclude_matching(dir, istate, pathname, dtype_p);1235if(exclude)1236return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1237return0;1238}12391240static struct dir_entry *dir_entry_new(const char*pathname,int len)1241{1242struct dir_entry *ent;12431244FLEX_ALLOC_MEM(ent, name, pathname, len);1245 ent->len = len;1246return ent;1247}12481249static struct dir_entry *dir_add_name(struct dir_struct *dir,1250struct index_state *istate,1251const char*pathname,int len)1252{1253if(index_file_exists(istate, pathname, len, ignore_case))1254return NULL;12551256ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1257return dir->entries[dir->nr++] =dir_entry_new(pathname, len);1258}12591260struct dir_entry *dir_add_ignored(struct dir_struct *dir,1261struct index_state *istate,1262const char*pathname,int len)1263{1264if(!index_name_is_other(istate, pathname, len))1265return NULL;12661267ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1268return dir->ignored[dir->ignored_nr++] =dir_entry_new(pathname, len);1269}12701271enum exist_status {1272 index_nonexistent =0,1273 index_directory,1274 index_gitdir1275};12761277/*1278 * Do not use the alphabetically sorted index to look up1279 * the directory name; instead, use the case insensitive1280 * directory hash.1281 */1282static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1283const char*dirname,int len)1284{1285struct cache_entry *ce;12861287if(index_dir_exists(istate, dirname, len))1288return index_directory;12891290 ce =index_file_exists(istate, dirname, len, ignore_case);1291if(ce &&S_ISGITLINK(ce->ce_mode))1292return index_gitdir;12931294return index_nonexistent;1295}12961297/*1298 * The index sorts alphabetically by entry name, which1299 * means that a gitlink sorts as '\0' at the end, while1300 * a directory (which is defined not as an entry, but as1301 * the files it contains) will sort with the '/' at the1302 * end.1303 */1304static enum exist_status directory_exists_in_index(struct index_state *istate,1305const char*dirname,int len)1306{1307int pos;13081309if(ignore_case)1310returndirectory_exists_in_index_icase(istate, dirname, len);13111312 pos =index_name_pos(istate, dirname, len);1313if(pos <0)1314 pos = -pos-1;1315while(pos < istate->cache_nr) {1316const struct cache_entry *ce = istate->cache[pos++];1317unsigned char endchar;13181319if(strncmp(ce->name, dirname, len))1320break;1321 endchar = ce->name[len];1322if(endchar >'/')1323break;1324if(endchar =='/')1325return index_directory;1326if(!endchar &&S_ISGITLINK(ce->ce_mode))1327return index_gitdir;1328}1329return index_nonexistent;1330}13311332/*1333 * When we find a directory when traversing the filesystem, we1334 * have three distinct cases:1335 *1336 * - ignore it1337 * - see it as a directory1338 * - recurse into it1339 *1340 * and which one we choose depends on a combination of existing1341 * git index contents and the flags passed into the directory1342 * traversal routine.1343 *1344 * Case 1: If we *already* have entries in the index under that1345 * directory name, we always recurse into the directory to see1346 * all the files.1347 *1348 * Case 2: If we *already* have that directory name as a gitlink,1349 * we always continue to see it as a gitlink, regardless of whether1350 * there is an actual git directory there or not (it might not1351 * be checked out as a subproject!)1352 *1353 * Case 3: if we didn't have it in the index previously, we1354 * have a few sub-cases:1355 *1356 * (a) if "show_other_directories" is true, we show it as1357 * just a directory, unless "hide_empty_directories" is1358 * also true, in which case we need to check if it contains any1359 * untracked and / or ignored files.1360 * (b) if it looks like a git directory, and we don't have1361 * 'no_gitlinks' set we treat it as a gitlink, and show it1362 * as a directory.1363 * (c) otherwise, we recurse into it.1364 */1365static enum path_treatment treat_directory(struct dir_struct *dir,1366struct index_state *istate,1367struct untracked_cache_dir *untracked,1368const char*dirname,int len,int baselen,int exclude,1369const struct pathspec *pathspec)1370{1371/* The "len-1" is to strip the final '/' */1372switch(directory_exists_in_index(istate, dirname, len-1)) {1373case index_directory:1374return path_recurse;13751376case index_gitdir:1377return path_none;13781379case index_nonexistent:1380if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1381break;1382if(!(dir->flags & DIR_NO_GITLINKS)) {1383unsigned char sha1[20];1384if(resolve_gitlink_ref(dirname,"HEAD", sha1) ==0)1385return path_untracked;1386}1387return path_recurse;1388}13891390/* This is the "show_other_directories" case */13911392if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1393return exclude ? path_excluded : path_untracked;13941395 untracked =lookup_untracked(dir->untracked, untracked,1396 dirname + baselen, len - baselen);1397returnread_directory_recursive(dir, istate, dirname, len,1398 untracked,1, pathspec);1399}14001401/*1402 * This is an inexact early pruning of any recursive directory1403 * reading - if the path cannot possibly be in the pathspec,1404 * return true, and we'll skip it early.1405 */1406static intsimplify_away(const char*path,int pathlen,1407const struct pathspec *pathspec)1408{1409int i;14101411if(!pathspec || !pathspec->nr)1412return0;14131414GUARD_PATHSPEC(pathspec,1415 PATHSPEC_FROMTOP |1416 PATHSPEC_MAXDEPTH |1417 PATHSPEC_LITERAL |1418 PATHSPEC_GLOB |1419 PATHSPEC_ICASE |1420 PATHSPEC_EXCLUDE |1421 PATHSPEC_ATTR);14221423for(i =0; i < pathspec->nr; i++) {1424const struct pathspec_item *item = &pathspec->items[i];1425int len = item->nowildcard_len;14261427if(len > pathlen)1428 len = pathlen;1429if(!ps_strncmp(item, item->match, path, len))1430return0;1431}14321433return1;1434}14351436/*1437 * This function tells us whether an excluded path matches a1438 * list of "interesting" pathspecs. That is, whether a path matched1439 * by any of the pathspecs could possibly be ignored by excluding1440 * the specified path. This can happen if:1441 *1442 * 1. the path is mentioned explicitly in the pathspec1443 *1444 * 2. the path is a directory prefix of some element in the1445 * pathspec1446 */1447static intexclude_matches_pathspec(const char*path,int pathlen,1448const struct pathspec *pathspec)1449{1450int i;14511452if(!pathspec || !pathspec->nr)1453return0;14541455GUARD_PATHSPEC(pathspec,1456 PATHSPEC_FROMTOP |1457 PATHSPEC_MAXDEPTH |1458 PATHSPEC_LITERAL |1459 PATHSPEC_GLOB |1460 PATHSPEC_ICASE |1461 PATHSPEC_EXCLUDE);14621463for(i =0; i < pathspec->nr; i++) {1464const struct pathspec_item *item = &pathspec->items[i];1465int len = item->nowildcard_len;14661467if(len == pathlen &&1468!ps_strncmp(item, item->match, path, pathlen))1469return1;1470if(len > pathlen &&1471 item->match[pathlen] =='/'&&1472!ps_strncmp(item, item->match, path, pathlen))1473return1;1474}1475return0;1476}14771478static intget_index_dtype(struct index_state *istate,1479const char*path,int len)1480{1481int pos;1482const struct cache_entry *ce;14831484 ce =index_file_exists(istate, path, len,0);1485if(ce) {1486if(!ce_uptodate(ce))1487return DT_UNKNOWN;1488if(S_ISGITLINK(ce->ce_mode))1489return DT_DIR;1490/*1491 * Nobody actually cares about the1492 * difference between DT_LNK and DT_REG1493 */1494return DT_REG;1495}14961497/* Try to look it up as a directory */1498 pos =index_name_pos(istate, path, len);1499if(pos >=0)1500return DT_UNKNOWN;1501 pos = -pos-1;1502while(pos < istate->cache_nr) {1503 ce = istate->cache[pos++];1504if(strncmp(ce->name, path, len))1505break;1506if(ce->name[len] >'/')1507break;1508if(ce->name[len] <'/')1509continue;1510if(!ce_uptodate(ce))1511break;/* continue? */1512return DT_DIR;1513}1514return DT_UNKNOWN;1515}15161517static intget_dtype(struct dirent *de,struct index_state *istate,1518const char*path,int len)1519{1520int dtype = de ?DTYPE(de) : DT_UNKNOWN;1521struct stat st;15221523if(dtype != DT_UNKNOWN)1524return dtype;1525 dtype =get_index_dtype(istate, path, len);1526if(dtype != DT_UNKNOWN)1527return dtype;1528if(lstat(path, &st))1529return dtype;1530if(S_ISREG(st.st_mode))1531return DT_REG;1532if(S_ISDIR(st.st_mode))1533return DT_DIR;1534if(S_ISLNK(st.st_mode))1535return DT_LNK;1536return dtype;1537}15381539static enum path_treatment treat_one_path(struct dir_struct *dir,1540struct untracked_cache_dir *untracked,1541struct index_state *istate,1542struct strbuf *path,1543int baselen,1544const struct pathspec *pathspec,1545int dtype,struct dirent *de)1546{1547int exclude;1548int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);15491550if(dtype == DT_UNKNOWN)1551 dtype =get_dtype(de, istate, path->buf, path->len);15521553/* Always exclude indexed files */1554if(dtype != DT_DIR && has_path_in_index)1555return path_none;15561557/*1558 * When we are looking at a directory P in the working tree,1559 * there are three cases:1560 *1561 * (1) P exists in the index. Everything inside the directory P in1562 * the working tree needs to go when P is checked out from the1563 * index.1564 *1565 * (2) P does not exist in the index, but there is P/Q in the index.1566 * We know P will stay a directory when we check out the contents1567 * of the index, but we do not know yet if there is a directory1568 * P/Q in the working tree to be killed, so we need to recurse.1569 *1570 * (3) P does not exist in the index, and there is no P/Q in the index1571 * to require P to be a directory, either. Only in this case, we1572 * know that everything inside P will not be killed without1573 * recursing.1574 */1575if((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1576(dtype == DT_DIR) &&1577!has_path_in_index &&1578(directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))1579return path_none;15801581 exclude =is_excluded(dir, istate, path->buf, &dtype);15821583/*1584 * Excluded? If we don't explicitly want to show1585 * ignored files, ignore it1586 */1587if(exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1588return path_excluded;15891590switch(dtype) {1591default:1592return path_none;1593case DT_DIR:1594strbuf_addch(path,'/');1595returntreat_directory(dir, istate, untracked, path->buf, path->len,1596 baselen, exclude, pathspec);1597case DT_REG:1598case DT_LNK:1599return exclude ? path_excluded : path_untracked;1600}1601}16021603static enum path_treatment treat_path_fast(struct dir_struct *dir,1604struct untracked_cache_dir *untracked,1605struct cached_dir *cdir,1606struct index_state *istate,1607struct strbuf *path,1608int baselen,1609const struct pathspec *pathspec)1610{1611strbuf_setlen(path, baselen);1612if(!cdir->ucd) {1613strbuf_addstr(path, cdir->file);1614return path_untracked;1615}1616strbuf_addstr(path, cdir->ucd->name);1617/* treat_one_path() does this before it calls treat_directory() */1618strbuf_complete(path,'/');1619if(cdir->ucd->check_only)1620/*1621 * check_only is set as a result of treat_directory() getting1622 * to its bottom. Verify again the same set of directories1623 * with check_only set.1624 */1625returnread_directory_recursive(dir, istate, path->buf, path->len,1626 cdir->ucd,1, pathspec);1627/*1628 * We get path_recurse in the first run when1629 * directory_exists_in_index() returns index_nonexistent. We1630 * are sure that new changes in the index does not impact the1631 * outcome. Return now.1632 */1633return path_recurse;1634}16351636static enum path_treatment treat_path(struct dir_struct *dir,1637struct untracked_cache_dir *untracked,1638struct cached_dir *cdir,1639struct index_state *istate,1640struct strbuf *path,1641int baselen,1642const struct pathspec *pathspec)1643{1644int dtype;1645struct dirent *de = cdir->de;16461647if(!de)1648returntreat_path_fast(dir, untracked, cdir, istate, path,1649 baselen, pathspec);1650if(is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name,".git"))1651return path_none;1652strbuf_setlen(path, baselen);1653strbuf_addstr(path, de->d_name);1654if(simplify_away(path->buf, path->len, pathspec))1655return path_none;16561657 dtype =DTYPE(de);1658returntreat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1659}16601661static voidadd_untracked(struct untracked_cache_dir *dir,const char*name)1662{1663if(!dir)1664return;1665ALLOC_GROW(dir->untracked, dir->untracked_nr +1,1666 dir->untracked_alloc);1667 dir->untracked[dir->untracked_nr++] =xstrdup(name);1668}16691670static intvalid_cached_dir(struct dir_struct *dir,1671struct untracked_cache_dir *untracked,1672struct index_state *istate,1673struct strbuf *path,1674int check_only)1675{1676struct stat st;16771678if(!untracked)1679return0;16801681if(stat(path->len ? path->buf :".", &st)) {1682invalidate_directory(dir->untracked, untracked);1683memset(&untracked->stat_data,0,sizeof(untracked->stat_data));1684return0;1685}1686if(!untracked->valid ||1687match_stat_data_racy(istate, &untracked->stat_data, &st)) {1688if(untracked->valid)1689invalidate_directory(dir->untracked, untracked);1690fill_stat_data(&untracked->stat_data, &st);1691return0;1692}16931694if(untracked->check_only != !!check_only) {1695invalidate_directory(dir->untracked, untracked);1696return0;1697}16981699/*1700 * prep_exclude will be called eventually on this directory,1701 * but it's called much later in last_exclude_matching(). We1702 * need it now to determine the validity of the cache for this1703 * path. The next calls will be nearly no-op, the way1704 * prep_exclude() is designed.1705 */1706if(path->len && path->buf[path->len -1] !='/') {1707strbuf_addch(path,'/');1708prep_exclude(dir, istate, path->buf, path->len);1709strbuf_setlen(path, path->len -1);1710}else1711prep_exclude(dir, istate, path->buf, path->len);17121713/* hopefully prep_exclude() haven't invalidated this entry... */1714return untracked->valid;1715}17161717static intopen_cached_dir(struct cached_dir *cdir,1718struct dir_struct *dir,1719struct untracked_cache_dir *untracked,1720struct index_state *istate,1721struct strbuf *path,1722int check_only)1723{1724memset(cdir,0,sizeof(*cdir));1725 cdir->untracked = untracked;1726if(valid_cached_dir(dir, untracked, istate, path, check_only))1727return0;1728 cdir->fdir =opendir(path->len ? path->buf :".");1729if(dir->untracked)1730 dir->untracked->dir_opened++;1731if(!cdir->fdir)1732return-1;1733return0;1734}17351736static intread_cached_dir(struct cached_dir *cdir)1737{1738if(cdir->fdir) {1739 cdir->de =readdir(cdir->fdir);1740if(!cdir->de)1741return-1;1742return0;1743}1744while(cdir->nr_dirs < cdir->untracked->dirs_nr) {1745struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1746if(!d->recurse) {1747 cdir->nr_dirs++;1748continue;1749}1750 cdir->ucd = d;1751 cdir->nr_dirs++;1752return0;1753}1754 cdir->ucd = NULL;1755if(cdir->nr_files < cdir->untracked->untracked_nr) {1756struct untracked_cache_dir *d = cdir->untracked;1757 cdir->file = d->untracked[cdir->nr_files++];1758return0;1759}1760return-1;1761}17621763static voidclose_cached_dir(struct cached_dir *cdir)1764{1765if(cdir->fdir)1766closedir(cdir->fdir);1767/*1768 * We have gone through this directory and found no untracked1769 * entries. Mark it valid.1770 */1771if(cdir->untracked) {1772 cdir->untracked->valid =1;1773 cdir->untracked->recurse =1;1774}1775}17761777/*1778 * Read a directory tree. We currently ignore anything but1779 * directories, regular files and symlinks. That's because git1780 * doesn't handle them at all yet. Maybe that will change some1781 * day.1782 *1783 * Also, we ignore the name ".git" (even if it is not a directory).1784 * That likely will not change.1785 *1786 * Returns the most significant path_treatment value encountered in the scan.1787 */1788static enum path_treatment read_directory_recursive(struct dir_struct *dir,1789struct index_state *istate,const char*base,int baselen,1790struct untracked_cache_dir *untracked,int check_only,1791const struct pathspec *pathspec)1792{1793struct cached_dir cdir;1794enum path_treatment state, subdir_state, dir_state = path_none;1795struct strbuf path = STRBUF_INIT;17961797strbuf_add(&path, base, baselen);17981799if(open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1800goto out;18011802if(untracked)1803 untracked->check_only = !!check_only;18041805while(!read_cached_dir(&cdir)) {1806/* check how the file or directory should be treated */1807 state =treat_path(dir, untracked, &cdir, istate, &path,1808 baselen, pathspec);18091810if(state > dir_state)1811 dir_state = state;18121813/* recurse into subdir if instructed by treat_path */1814if(state == path_recurse) {1815struct untracked_cache_dir *ud;1816 ud =lookup_untracked(dir->untracked, untracked,1817 path.buf + baselen,1818 path.len - baselen);1819 subdir_state =1820read_directory_recursive(dir, istate, path.buf,1821 path.len, ud,1822 check_only, pathspec);1823if(subdir_state > dir_state)1824 dir_state = subdir_state;1825}18261827if(check_only) {1828/* abort early if maximum state has been reached */1829if(dir_state == path_untracked) {1830if(cdir.fdir)1831add_untracked(untracked, path.buf + baselen);1832break;1833}1834/* skip the dir_add_* part */1835continue;1836}18371838/* add the path to the appropriate result list */1839switch(state) {1840case path_excluded:1841if(dir->flags & DIR_SHOW_IGNORED)1842dir_add_name(dir, istate, path.buf, path.len);1843else if((dir->flags & DIR_SHOW_IGNORED_TOO) ||1844((dir->flags & DIR_COLLECT_IGNORED) &&1845exclude_matches_pathspec(path.buf, path.len,1846 pathspec)))1847dir_add_ignored(dir, istate, path.buf, path.len);1848break;18491850case path_untracked:1851if(dir->flags & DIR_SHOW_IGNORED)1852break;1853dir_add_name(dir, istate, path.buf, path.len);1854if(cdir.fdir)1855add_untracked(untracked, path.buf + baselen);1856break;18571858default:1859break;1860}1861}1862close_cached_dir(&cdir);1863 out:1864strbuf_release(&path);18651866return dir_state;1867}18681869static intcmp_name(const void*p1,const void*p2)1870{1871const struct dir_entry *e1 = *(const struct dir_entry **)p1;1872const struct dir_entry *e2 = *(const struct dir_entry **)p2;18731874returnname_compare(e1->name, e1->len, e2->name, e2->len);1875}18761877static inttreat_leading_path(struct dir_struct *dir,1878struct index_state *istate,1879const char*path,int len,1880const struct pathspec *pathspec)1881{1882struct strbuf sb = STRBUF_INIT;1883int baselen, rc =0;1884const char*cp;1885int old_flags = dir->flags;18861887while(len && path[len -1] =='/')1888 len--;1889if(!len)1890return1;1891 baselen =0;1892 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1893while(1) {1894 cp = path + baselen + !!baselen;1895 cp =memchr(cp,'/', path + len - cp);1896if(!cp)1897 baselen = len;1898else1899 baselen = cp - path;1900strbuf_setlen(&sb,0);1901strbuf_add(&sb, path, baselen);1902if(!is_directory(sb.buf))1903break;1904if(simplify_away(sb.buf, sb.len, pathspec))1905break;1906if(treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,1907 DT_DIR, NULL) == path_none)1908break;/* do not recurse into it */1909if(len <= baselen) {1910 rc =1;1911break;/* finished checking */1912}1913}1914strbuf_release(&sb);1915 dir->flags = old_flags;1916return rc;1917}19181919static const char*get_ident_string(void)1920{1921static struct strbuf sb = STRBUF_INIT;1922struct utsname uts;19231924if(sb.len)1925return sb.buf;1926if(uname(&uts) <0)1927die_errno(_("failed to get kernel name and information"));1928strbuf_addf(&sb,"Location%s, system%s",get_git_work_tree(),1929 uts.sysname);1930return sb.buf;1931}19321933static intident_in_untracked(const struct untracked_cache *uc)1934{1935/*1936 * Previous git versions may have saved many NUL separated1937 * strings in the "ident" field, but it is insane to manage1938 * many locations, so just take care of the first one.1939 */19401941return!strcmp(uc->ident.buf,get_ident_string());1942}19431944static voidset_untracked_ident(struct untracked_cache *uc)1945{1946strbuf_reset(&uc->ident);1947strbuf_addstr(&uc->ident,get_ident_string());19481949/*1950 * This strbuf used to contain a list of NUL separated1951 * strings, so save NUL too for backward compatibility.1952 */1953strbuf_addch(&uc->ident,0);1954}19551956static voidnew_untracked_cache(struct index_state *istate)1957{1958struct untracked_cache *uc =xcalloc(1,sizeof(*uc));1959strbuf_init(&uc->ident,100);1960 uc->exclude_per_dir =".gitignore";1961/* should be the same flags used by git-status */1962 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;1963set_untracked_ident(uc);1964 istate->untracked = uc;1965 istate->cache_changed |= UNTRACKED_CHANGED;1966}19671968voidadd_untracked_cache(struct index_state *istate)1969{1970if(!istate->untracked) {1971new_untracked_cache(istate);1972}else{1973if(!ident_in_untracked(istate->untracked)) {1974free_untracked_cache(istate->untracked);1975new_untracked_cache(istate);1976}1977}1978}19791980voidremove_untracked_cache(struct index_state *istate)1981{1982if(istate->untracked) {1983free_untracked_cache(istate->untracked);1984 istate->untracked = NULL;1985 istate->cache_changed |= UNTRACKED_CHANGED;1986}1987}19881989static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,1990int base_len,1991const struct pathspec *pathspec)1992{1993struct untracked_cache_dir *root;19941995if(!dir->untracked ||getenv("GIT_DISABLE_UNTRACKED_CACHE"))1996return NULL;19971998/*1999 * We only support $GIT_DIR/info/exclude and core.excludesfile2000 * as the global ignore rule files. Any other additions2001 * (e.g. from command line) invalidate the cache. This2002 * condition also catches running setup_standard_excludes()2003 * before setting dir->untracked!2004 */2005if(dir->unmanaged_exclude_files)2006return NULL;20072008/*2009 * Optimize for the main use case only: whole-tree git2010 * status. More work involved in treat_leading_path() if we2011 * use cache on just a subset of the worktree. pathspec2012 * support could make the matter even worse.2013 */2014if(base_len || (pathspec && pathspec->nr))2015return NULL;20162017/* Different set of flags may produce different results */2018if(dir->flags != dir->untracked->dir_flags ||2019/*2020 * See treat_directory(), case index_nonexistent. Without2021 * this flag, we may need to also cache .git file content2022 * for the resolve_gitlink_ref() call, which we don't.2023 */2024!(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2025/* We don't support collecting ignore files */2026(dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2027 DIR_COLLECT_IGNORED)))2028return NULL;20292030/*2031 * If we use .gitignore in the cache and now you change it to2032 * .gitexclude, everything will go wrong.2033 */2034if(dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2035strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2036return NULL;20372038/*2039 * EXC_CMDL is not considered in the cache. If people set it,2040 * skip the cache.2041 */2042if(dir->exclude_list_group[EXC_CMDL].nr)2043return NULL;20442045if(!ident_in_untracked(dir->untracked)) {2046warning(_("Untracked cache is disabled on this system or location."));2047return NULL;2048}20492050if(!dir->untracked->root) {2051const int len =sizeof(*dir->untracked->root);2052 dir->untracked->root =xmalloc(len);2053memset(dir->untracked->root,0, len);2054}20552056/* Validate $GIT_DIR/info/exclude and core.excludesfile */2057 root = dir->untracked->root;2058if(hashcmp(dir->ss_info_exclude.sha1,2059 dir->untracked->ss_info_exclude.sha1)) {2060invalidate_gitignore(dir->untracked, root);2061 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2062}2063if(hashcmp(dir->ss_excludes_file.sha1,2064 dir->untracked->ss_excludes_file.sha1)) {2065invalidate_gitignore(dir->untracked, root);2066 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2067}20682069/* Make sure this directory is not dropped out at saving phase */2070 root->recurse =1;2071return root;2072}20732074intread_directory(struct dir_struct *dir,struct index_state *istate,2075const char*path,int len,const struct pathspec *pathspec)2076{2077struct untracked_cache_dir *untracked;20782079if(has_symlink_leading_path(path, len))2080return dir->nr;20812082 untracked =validate_untracked_cache(dir, len, pathspec);2083if(!untracked)2084/*2085 * make sure untracked cache code path is disabled,2086 * e.g. prep_exclude()2087 */2088 dir->untracked = NULL;2089if(!len ||treat_leading_path(dir, istate, path, len, pathspec))2090read_directory_recursive(dir, istate, path, len, untracked,0, pathspec);2091QSORT(dir->entries, dir->nr, cmp_name);2092QSORT(dir->ignored, dir->ignored_nr, cmp_name);2093if(dir->untracked) {2094static struct trace_key trace_untracked_stats =TRACE_KEY_INIT(UNTRACKED_STATS);2095trace_printf_key(&trace_untracked_stats,2096"node creation:%u\n"2097"gitignore invalidation:%u\n"2098"directory invalidation:%u\n"2099"opendir:%u\n",2100 dir->untracked->dir_created,2101 dir->untracked->gitignore_invalidated,2102 dir->untracked->dir_invalidated,2103 dir->untracked->dir_opened);2104if(dir->untracked == istate->untracked &&2105(dir->untracked->dir_opened ||2106 dir->untracked->gitignore_invalidated ||2107 dir->untracked->dir_invalidated))2108 istate->cache_changed |= UNTRACKED_CHANGED;2109if(dir->untracked != istate->untracked) {2110free(dir->untracked);2111 dir->untracked = NULL;2112}2113}2114return dir->nr;2115}21162117intfile_exists(const char*f)2118{2119struct stat sb;2120returnlstat(f, &sb) ==0;2121}21222123static intcmp_icase(char a,char b)2124{2125if(a == b)2126return0;2127if(ignore_case)2128returntoupper(a) -toupper(b);2129return a - b;2130}21312132/*2133 * Given two normalized paths (a trailing slash is ok), if subdir is2134 * outside dir, return -1. Otherwise return the offset in subdir that2135 * can be used as relative path to dir.2136 */2137intdir_inside_of(const char*subdir,const char*dir)2138{2139int offset =0;21402141assert(dir && subdir && *dir && *subdir);21422143while(*dir && *subdir && !cmp_icase(*dir, *subdir)) {2144 dir++;2145 subdir++;2146 offset++;2147}21482149/* hel[p]/me vs hel[l]/yeah */2150if(*dir && *subdir)2151return-1;21522153if(!*subdir)2154return!*dir ? offset : -1;/* same dir */21552156/* foo/[b]ar vs foo/[] */2157if(is_dir_sep(dir[-1]))2158returnis_dir_sep(subdir[-1]) ? offset : -1;21592160/* foo[/]bar vs foo[] */2161returnis_dir_sep(*subdir) ? offset +1: -1;2162}21632164intis_inside_dir(const char*dir)2165{2166char*cwd;2167int rc;21682169if(!dir)2170return0;21712172 cwd =xgetcwd();2173 rc = (dir_inside_of(cwd, dir) >=0);2174free(cwd);2175return rc;2176}21772178intis_empty_dir(const char*path)2179{2180DIR*dir =opendir(path);2181struct dirent *e;2182int ret =1;21832184if(!dir)2185return0;21862187while((e =readdir(dir)) != NULL)2188if(!is_dot_or_dotdot(e->d_name)) {2189 ret =0;2190break;2191}21922193closedir(dir);2194return ret;2195}21962197static intremove_dir_recurse(struct strbuf *path,int flag,int*kept_up)2198{2199DIR*dir;2200struct dirent *e;2201int ret =0, original_len = path->len, len, kept_down =0;2202int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2203int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2204unsigned char submodule_head[20];22052206if((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2207!resolve_gitlink_ref(path->buf,"HEAD", submodule_head)) {2208/* Do not descend and nuke a nested git work tree. */2209if(kept_up)2210*kept_up =1;2211return0;2212}22132214 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2215 dir =opendir(path->buf);2216if(!dir) {2217if(errno == ENOENT)2218return keep_toplevel ? -1:0;2219else if(errno == EACCES && !keep_toplevel)2220/*2221 * An empty dir could be removable even if it2222 * is unreadable:2223 */2224returnrmdir(path->buf);2225else2226return-1;2227}2228strbuf_complete(path,'/');22292230 len = path->len;2231while((e =readdir(dir)) != NULL) {2232struct stat st;2233if(is_dot_or_dotdot(e->d_name))2234continue;22352236strbuf_setlen(path, len);2237strbuf_addstr(path, e->d_name);2238if(lstat(path->buf, &st)) {2239if(errno == ENOENT)2240/*2241 * file disappeared, which is what we2242 * wanted anyway2243 */2244continue;2245/* fall thru */2246}else if(S_ISDIR(st.st_mode)) {2247if(!remove_dir_recurse(path, flag, &kept_down))2248continue;/* happy */2249}else if(!only_empty &&2250(!unlink(path->buf) || errno == ENOENT)) {2251continue;/* happy, too */2252}22532254/* path too long, stat fails, or non-directory still exists */2255 ret = -1;2256break;2257}2258closedir(dir);22592260strbuf_setlen(path, original_len);2261if(!ret && !keep_toplevel && !kept_down)2262 ret = (!rmdir(path->buf) || errno == ENOENT) ?0: -1;2263else if(kept_up)2264/*2265 * report the uplevel that it is not an error that we2266 * did not rmdir() our directory.2267 */2268*kept_up = !ret;2269return ret;2270}22712272intremove_dir_recursively(struct strbuf *path,int flag)2273{2274returnremove_dir_recurse(path, flag, NULL);2275}22762277staticGIT_PATH_FUNC(git_path_info_exclude,"info/exclude")22782279voidsetup_standard_excludes(struct dir_struct *dir)2280{2281 dir->exclude_per_dir =".gitignore";22822283/* core.excludefile defaulting to $XDG_HOME/git/ignore */2284if(!excludes_file)2285 excludes_file =xdg_config_home("ignore");2286if(excludes_file && !access_or_warn(excludes_file, R_OK,0))2287add_excludes_from_file_1(dir, excludes_file,2288 dir->untracked ? &dir->ss_excludes_file : NULL);22892290/* per repository user preference */2291if(startup_info->have_repository) {2292const char*path =git_path_info_exclude();2293if(!access_or_warn(path, R_OK,0))2294add_excludes_from_file_1(dir, path,2295 dir->untracked ? &dir->ss_info_exclude : NULL);2296}2297}22982299intremove_path(const char*name)2300{2301char*slash;23022303if(unlink(name) && errno != ENOENT && errno != ENOTDIR)2304return-1;23052306 slash =strrchr(name,'/');2307if(slash) {2308char*dirs =xstrdup(name);2309 slash = dirs + (slash - name);2310do{2311*slash ='\0';2312}while(rmdir(dirs) ==0&& (slash =strrchr(dirs,'/')));2313free(dirs);2314}2315return0;2316}23172318/*2319 * Frees memory within dir which was allocated for exclude lists and2320 * the exclude_stack. Does not free dir itself.2321 */2322voidclear_directory(struct dir_struct *dir)2323{2324int i, j;2325struct exclude_list_group *group;2326struct exclude_list *el;2327struct exclude_stack *stk;23282329for(i = EXC_CMDL; i <= EXC_FILE; i++) {2330 group = &dir->exclude_list_group[i];2331for(j =0; j < group->nr; j++) {2332 el = &group->el[j];2333if(i == EXC_DIRS)2334free((char*)el->src);2335clear_exclude_list(el);2336}2337free(group->el);2338}23392340 stk = dir->exclude_stack;2341while(stk) {2342struct exclude_stack *prev = stk->prev;2343free(stk);2344 stk = prev;2345}2346strbuf_release(&dir->basebuf);2347}23482349struct ondisk_untracked_cache {2350struct stat_data info_exclude_stat;2351struct stat_data excludes_file_stat;2352uint32_t dir_flags;2353unsigned char info_exclude_sha1[20];2354unsigned char excludes_file_sha1[20];2355char exclude_per_dir[FLEX_ARRAY];2356};23572358#define ouc_size(len) (offsetof(struct ondisk_untracked_cache, exclude_per_dir) + len + 1)23592360struct write_data {2361int index;/* number of written untracked_cache_dir */2362struct ewah_bitmap *check_only;/* from untracked_cache_dir */2363struct ewah_bitmap *valid;/* from untracked_cache_dir */2364struct ewah_bitmap *sha1_valid;/* set if exclude_sha1 is not null */2365struct strbuf out;2366struct strbuf sb_stat;2367struct strbuf sb_sha1;2368};23692370static voidstat_data_to_disk(struct stat_data *to,const struct stat_data *from)2371{2372 to->sd_ctime.sec =htonl(from->sd_ctime.sec);2373 to->sd_ctime.nsec =htonl(from->sd_ctime.nsec);2374 to->sd_mtime.sec =htonl(from->sd_mtime.sec);2375 to->sd_mtime.nsec =htonl(from->sd_mtime.nsec);2376 to->sd_dev =htonl(from->sd_dev);2377 to->sd_ino =htonl(from->sd_ino);2378 to->sd_uid =htonl(from->sd_uid);2379 to->sd_gid =htonl(from->sd_gid);2380 to->sd_size =htonl(from->sd_size);2381}23822383static voidwrite_one_dir(struct untracked_cache_dir *untracked,2384struct write_data *wd)2385{2386struct stat_data stat_data;2387struct strbuf *out = &wd->out;2388unsigned char intbuf[16];2389unsigned int intlen, value;2390int i = wd->index++;23912392/*2393 * untracked_nr should be reset whenever valid is clear, but2394 * for safety..2395 */2396if(!untracked->valid) {2397 untracked->untracked_nr =0;2398 untracked->check_only =0;2399}24002401if(untracked->check_only)2402ewah_set(wd->check_only, i);2403if(untracked->valid) {2404ewah_set(wd->valid, i);2405stat_data_to_disk(&stat_data, &untracked->stat_data);2406strbuf_add(&wd->sb_stat, &stat_data,sizeof(stat_data));2407}2408if(!is_null_sha1(untracked->exclude_sha1)) {2409ewah_set(wd->sha1_valid, i);2410strbuf_add(&wd->sb_sha1, untracked->exclude_sha1,20);2411}24122413 intlen =encode_varint(untracked->untracked_nr, intbuf);2414strbuf_add(out, intbuf, intlen);24152416/* skip non-recurse directories */2417for(i =0, value =0; i < untracked->dirs_nr; i++)2418if(untracked->dirs[i]->recurse)2419 value++;2420 intlen =encode_varint(value, intbuf);2421strbuf_add(out, intbuf, intlen);24222423strbuf_add(out, untracked->name,strlen(untracked->name) +1);24242425for(i =0; i < untracked->untracked_nr; i++)2426strbuf_add(out, untracked->untracked[i],2427strlen(untracked->untracked[i]) +1);24282429for(i =0; i < untracked->dirs_nr; i++)2430if(untracked->dirs[i]->recurse)2431write_one_dir(untracked->dirs[i], wd);2432}24332434voidwrite_untracked_extension(struct strbuf *out,struct untracked_cache *untracked)2435{2436struct ondisk_untracked_cache *ouc;2437struct write_data wd;2438unsigned char varbuf[16];2439int varint_len;2440size_t len =strlen(untracked->exclude_per_dir);24412442FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2443stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2444stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2445hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);2446hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.sha1);2447 ouc->dir_flags =htonl(untracked->dir_flags);24482449 varint_len =encode_varint(untracked->ident.len, varbuf);2450strbuf_add(out, varbuf, varint_len);2451strbuf_addbuf(out, &untracked->ident);24522453strbuf_add(out, ouc,ouc_size(len));2454free(ouc);2455 ouc = NULL;24562457if(!untracked->root) {2458 varint_len =encode_varint(0, varbuf);2459strbuf_add(out, varbuf, varint_len);2460return;2461}24622463 wd.index =0;2464 wd.check_only =ewah_new();2465 wd.valid =ewah_new();2466 wd.sha1_valid =ewah_new();2467strbuf_init(&wd.out,1024);2468strbuf_init(&wd.sb_stat,1024);2469strbuf_init(&wd.sb_sha1,1024);2470write_one_dir(untracked->root, &wd);24712472 varint_len =encode_varint(wd.index, varbuf);2473strbuf_add(out, varbuf, varint_len);2474strbuf_addbuf(out, &wd.out);2475ewah_serialize_strbuf(wd.valid, out);2476ewah_serialize_strbuf(wd.check_only, out);2477ewah_serialize_strbuf(wd.sha1_valid, out);2478strbuf_addbuf(out, &wd.sb_stat);2479strbuf_addbuf(out, &wd.sb_sha1);2480strbuf_addch(out,'\0');/* safe guard for string lists */24812482ewah_free(wd.valid);2483ewah_free(wd.check_only);2484ewah_free(wd.sha1_valid);2485strbuf_release(&wd.out);2486strbuf_release(&wd.sb_stat);2487strbuf_release(&wd.sb_sha1);2488}24892490static voidfree_untracked(struct untracked_cache_dir *ucd)2491{2492int i;2493if(!ucd)2494return;2495for(i =0; i < ucd->dirs_nr; i++)2496free_untracked(ucd->dirs[i]);2497for(i =0; i < ucd->untracked_nr; i++)2498free(ucd->untracked[i]);2499free(ucd->untracked);2500free(ucd->dirs);2501free(ucd);2502}25032504voidfree_untracked_cache(struct untracked_cache *uc)2505{2506if(uc)2507free_untracked(uc->root);2508free(uc);2509}25102511struct read_data {2512int index;2513struct untracked_cache_dir **ucd;2514struct ewah_bitmap *check_only;2515struct ewah_bitmap *valid;2516struct ewah_bitmap *sha1_valid;2517const unsigned char*data;2518const unsigned char*end;2519};25202521static voidstat_data_from_disk(struct stat_data *to,const struct stat_data *from)2522{2523 to->sd_ctime.sec =get_be32(&from->sd_ctime.sec);2524 to->sd_ctime.nsec =get_be32(&from->sd_ctime.nsec);2525 to->sd_mtime.sec =get_be32(&from->sd_mtime.sec);2526 to->sd_mtime.nsec =get_be32(&from->sd_mtime.nsec);2527 to->sd_dev =get_be32(&from->sd_dev);2528 to->sd_ino =get_be32(&from->sd_ino);2529 to->sd_uid =get_be32(&from->sd_uid);2530 to->sd_gid =get_be32(&from->sd_gid);2531 to->sd_size =get_be32(&from->sd_size);2532}25332534static intread_one_dir(struct untracked_cache_dir **untracked_,2535struct read_data *rd)2536{2537struct untracked_cache_dir ud, *untracked;2538const unsigned char*next, *data = rd->data, *end = rd->end;2539unsigned int value;2540int i, len;25412542memset(&ud,0,sizeof(ud));25432544 next = data;2545 value =decode_varint(&next);2546if(next > end)2547return-1;2548 ud.recurse =1;2549 ud.untracked_alloc = value;2550 ud.untracked_nr = value;2551if(ud.untracked_nr)2552ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2553 data = next;25542555 next = data;2556 ud.dirs_alloc = ud.dirs_nr =decode_varint(&next);2557if(next > end)2558return-1;2559ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2560 data = next;25612562 len =strlen((const char*)data);2563 next = data + len +1;2564if(next > rd->end)2565return-1;2566*untracked_ = untracked =xmalloc(st_add(sizeof(*untracked), len));2567memcpy(untracked, &ud,sizeof(ud));2568memcpy(untracked->name, data, len +1);2569 data = next;25702571for(i =0; i < untracked->untracked_nr; i++) {2572 len =strlen((const char*)data);2573 next = data + len +1;2574if(next > rd->end)2575return-1;2576 untracked->untracked[i] =xstrdup((const char*)data);2577 data = next;2578}25792580 rd->ucd[rd->index++] = untracked;2581 rd->data = data;25822583for(i =0; i < untracked->dirs_nr; i++) {2584 len =read_one_dir(untracked->dirs + i, rd);2585if(len <0)2586return-1;2587}2588return0;2589}25902591static voidset_check_only(size_t pos,void*cb)2592{2593struct read_data *rd = cb;2594struct untracked_cache_dir *ud = rd->ucd[pos];2595 ud->check_only =1;2596}25972598static voidread_stat(size_t pos,void*cb)2599{2600struct read_data *rd = cb;2601struct untracked_cache_dir *ud = rd->ucd[pos];2602if(rd->data +sizeof(struct stat_data) > rd->end) {2603 rd->data = rd->end +1;2604return;2605}2606stat_data_from_disk(&ud->stat_data, (struct stat_data *)rd->data);2607 rd->data +=sizeof(struct stat_data);2608 ud->valid =1;2609}26102611static voidread_sha1(size_t pos,void*cb)2612{2613struct read_data *rd = cb;2614struct untracked_cache_dir *ud = rd->ucd[pos];2615if(rd->data +20> rd->end) {2616 rd->data = rd->end +1;2617return;2618}2619hashcpy(ud->exclude_sha1, rd->data);2620 rd->data +=20;2621}26222623static voidload_sha1_stat(struct sha1_stat *sha1_stat,2624const struct stat_data *stat,2625const unsigned char*sha1)2626{2627stat_data_from_disk(&sha1_stat->stat, stat);2628hashcpy(sha1_stat->sha1, sha1);2629 sha1_stat->valid =1;2630}26312632struct untracked_cache *read_untracked_extension(const void*data,unsigned long sz)2633{2634const struct ondisk_untracked_cache *ouc;2635struct untracked_cache *uc;2636struct read_data rd;2637const unsigned char*next = data, *end = (const unsigned char*)data + sz;2638const char*ident;2639int ident_len, len;26402641if(sz <=1|| end[-1] !='\0')2642return NULL;2643 end--;26442645 ident_len =decode_varint(&next);2646if(next + ident_len > end)2647return NULL;2648 ident = (const char*)next;2649 next += ident_len;26502651 ouc = (const struct ondisk_untracked_cache *)next;2652if(next +ouc_size(0) > end)2653return NULL;26542655 uc =xcalloc(1,sizeof(*uc));2656strbuf_init(&uc->ident, ident_len);2657strbuf_add(&uc->ident, ident, ident_len);2658load_sha1_stat(&uc->ss_info_exclude, &ouc->info_exclude_stat,2659 ouc->info_exclude_sha1);2660load_sha1_stat(&uc->ss_excludes_file, &ouc->excludes_file_stat,2661 ouc->excludes_file_sha1);2662 uc->dir_flags =get_be32(&ouc->dir_flags);2663 uc->exclude_per_dir =xstrdup(ouc->exclude_per_dir);2664/* NUL after exclude_per_dir is covered by sizeof(*ouc) */2665 next +=ouc_size(strlen(ouc->exclude_per_dir));2666if(next >= end)2667goto done2;26682669 len =decode_varint(&next);2670if(next > end || len ==0)2671goto done2;26722673 rd.valid =ewah_new();2674 rd.check_only =ewah_new();2675 rd.sha1_valid =ewah_new();2676 rd.data = next;2677 rd.end = end;2678 rd.index =0;2679ALLOC_ARRAY(rd.ucd, len);26802681if(read_one_dir(&uc->root, &rd) || rd.index != len)2682goto done;26832684 next = rd.data;2685 len =ewah_read_mmap(rd.valid, next, end - next);2686if(len <0)2687goto done;26882689 next += len;2690 len =ewah_read_mmap(rd.check_only, next, end - next);2691if(len <0)2692goto done;26932694 next += len;2695 len =ewah_read_mmap(rd.sha1_valid, next, end - next);2696if(len <0)2697goto done;26982699ewah_each_bit(rd.check_only, set_check_only, &rd);2700 rd.data = next + len;2701ewah_each_bit(rd.valid, read_stat, &rd);2702ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2703 next = rd.data;27042705done:2706free(rd.ucd);2707ewah_free(rd.valid);2708ewah_free(rd.check_only);2709ewah_free(rd.sha1_valid);2710done2:2711if(next != end) {2712free_untracked_cache(uc);2713 uc = NULL;2714}2715return uc;2716}27172718static voidinvalidate_one_directory(struct untracked_cache *uc,2719struct untracked_cache_dir *ucd)2720{2721 uc->dir_invalidated++;2722 ucd->valid =0;2723 ucd->untracked_nr =0;2724}27252726/*2727 * Normally when an entry is added or removed from a directory,2728 * invalidating that directory is enough. No need to touch its2729 * ancestors. When a directory is shown as "foo/bar/" in git-status2730 * however, deleting or adding an entry may have cascading effect.2731 *2732 * Say the "foo/bar/file" has become untracked, we need to tell the2733 * untracked_cache_dir of "foo" that "bar/" is not an untracked2734 * directory any more (because "bar" is managed by foo as an untracked2735 * "file").2736 *2737 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2738 * was the last untracked entry in the entire "foo", we should show2739 * "foo/" instead. Which means we have to invalidate past "bar" up to2740 * "foo".2741 *2742 * This function traverses all directories from root to leaf. If there2743 * is a chance of one of the above cases happening, we invalidate back2744 * to root. Otherwise we just invalidate the leaf. There may be a more2745 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2746 * detect these cases and avoid unnecessary invalidation, for example,2747 * checking for the untracked entry named "bar/" in "foo", but for now2748 * stick to something safe and simple.2749 */2750static intinvalidate_one_component(struct untracked_cache *uc,2751struct untracked_cache_dir *dir,2752const char*path,int len)2753{2754const char*rest =strchr(path,'/');27552756if(rest) {2757int component_len = rest - path;2758struct untracked_cache_dir *d =2759lookup_untracked(uc, dir, path, component_len);2760int ret =2761invalidate_one_component(uc, d, rest +1,2762 len - (component_len +1));2763if(ret)2764invalidate_one_directory(uc, dir);2765return ret;2766}27672768invalidate_one_directory(uc, dir);2769return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2770}27712772voiduntracked_cache_invalidate_path(struct index_state *istate,2773const char*path)2774{2775if(!istate->untracked || !istate->untracked->root)2776return;2777invalidate_one_component(istate->untracked, istate->untracked->root,2778 path,strlen(path));2779}27802781voiduntracked_cache_remove_from_index(struct index_state *istate,2782const char*path)2783{2784untracked_cache_invalidate_path(istate, path);2785}27862787voiduntracked_cache_add_to_index(struct index_state *istate,2788const char*path)2789{2790untracked_cache_invalidate_path(istate, path);2791}27922793/* Update gitfile and core.worktree setting to connect work tree and git dir */2794voidconnect_work_tree_and_git_dir(const char*work_tree_,const char*git_dir_)2795{2796struct strbuf gitfile_sb = STRBUF_INIT;2797struct strbuf cfg_sb = STRBUF_INIT;2798struct strbuf rel_path = STRBUF_INIT;2799char*git_dir, *work_tree;28002801/* Prepare .git file */2802strbuf_addf(&gitfile_sb,"%s/.git", work_tree_);2803if(safe_create_leading_directories_const(gitfile_sb.buf))2804die(_("could not create directories for%s"), gitfile_sb.buf);28052806/* Prepare config file */2807strbuf_addf(&cfg_sb,"%s/config", git_dir_);2808if(safe_create_leading_directories_const(cfg_sb.buf))2809die(_("could not create directories for%s"), cfg_sb.buf);28102811 git_dir =real_pathdup(git_dir_,1);2812 work_tree =real_pathdup(work_tree_,1);28132814/* Write .git file */2815write_file(gitfile_sb.buf,"gitdir:%s",2816relative_path(git_dir, work_tree, &rel_path));2817/* Update core.worktree setting */2818git_config_set_in_file(cfg_sb.buf,"core.worktree",2819relative_path(work_tree, git_dir, &rel_path));28202821strbuf_release(&gitfile_sb);2822strbuf_release(&cfg_sb);2823strbuf_release(&rel_path);2824free(work_tree);2825free(git_dir);2826}28272828/*2829 * Migrate the git directory of the given path from old_git_dir to new_git_dir.2830 */2831voidrelocate_gitdir(const char*path,const char*old_git_dir,const char*new_git_dir)2832{2833if(rename(old_git_dir, new_git_dir) <0)2834die_errno(_("could not migrate git directory from '%s' to '%s'"),2835 old_git_dir, new_git_dir);28362837connect_work_tree_and_git_dir(path, new_git_dir);2838}