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, 49const char*path,int len,struct untracked_cache_dir *untracked, 50int check_only,const struct pathspec *pathspec); 51static intget_dtype(struct dirent *de,struct index_state *istate, 52const char*path,int len); 53 54intfspathcmp(const char*a,const char*b) 55{ 56return ignore_case ?strcasecmp(a, b) :strcmp(a, b); 57} 58 59intfspathncmp(const char*a,const char*b,size_t count) 60{ 61return ignore_case ?strncasecmp(a, b, count) :strncmp(a, b, count); 62} 63 64intgit_fnmatch(const struct pathspec_item *item, 65const char*pattern,const char*string, 66int prefix) 67{ 68if(prefix >0) { 69if(ps_strncmp(item, pattern, string, prefix)) 70return WM_NOMATCH; 71 pattern += prefix; 72 string += prefix; 73} 74if(item->flags & PATHSPEC_ONESTAR) { 75int pattern_len =strlen(++pattern); 76int string_len =strlen(string); 77return string_len < pattern_len || 78ps_strcmp(item, pattern, 79 string + string_len - pattern_len); 80} 81if(item->magic & PATHSPEC_GLOB) 82returnwildmatch(pattern, string, 83 WM_PATHNAME | 84(item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0), 85 NULL); 86else 87/* wildmatch has not learned no FNM_PATHNAME mode yet */ 88returnwildmatch(pattern, string, 89 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD :0, 90 NULL); 91} 92 93static intfnmatch_icase_mem(const char*pattern,int patternlen, 94const char*string,int stringlen, 95int flags) 96{ 97int match_status; 98struct strbuf pat_buf = STRBUF_INIT; 99struct strbuf str_buf = STRBUF_INIT; 100const char*use_pat = pattern; 101const char*use_str = string; 102 103if(pattern[patternlen]) { 104strbuf_add(&pat_buf, pattern, patternlen); 105 use_pat = pat_buf.buf; 106} 107if(string[stringlen]) { 108strbuf_add(&str_buf, string, stringlen); 109 use_str = str_buf.buf; 110} 111 112if(ignore_case) 113 flags |= WM_CASEFOLD; 114 match_status =wildmatch(use_pat, use_str, flags, NULL); 115 116strbuf_release(&pat_buf); 117strbuf_release(&str_buf); 118 119return match_status; 120} 121 122static size_tcommon_prefix_len(const struct pathspec *pathspec) 123{ 124int n; 125size_t max =0; 126 127/* 128 * ":(icase)path" is treated as a pathspec full of 129 * wildcard. In other words, only prefix is considered common 130 * prefix. If the pathspec is abc/foo abc/bar, running in 131 * subdir xyz, the common prefix is still xyz, not xuz/abc as 132 * in non-:(icase). 133 */ 134GUARD_PATHSPEC(pathspec, 135 PATHSPEC_FROMTOP | 136 PATHSPEC_MAXDEPTH | 137 PATHSPEC_LITERAL | 138 PATHSPEC_GLOB | 139 PATHSPEC_ICASE | 140 PATHSPEC_EXCLUDE | 141 PATHSPEC_ATTR); 142 143for(n =0; n < pathspec->nr; n++) { 144size_t i =0, len =0, item_len; 145if(pathspec->items[n].magic & PATHSPEC_EXCLUDE) 146continue; 147if(pathspec->items[n].magic & PATHSPEC_ICASE) 148 item_len = pathspec->items[n].prefix; 149else 150 item_len = pathspec->items[n].nowildcard_len; 151while(i < item_len && (n ==0|| i < max)) { 152char c = pathspec->items[n].match[i]; 153if(c != pathspec->items[0].match[i]) 154break; 155if(c =='/') 156 len = i +1; 157 i++; 158} 159if(n ==0|| len < max) { 160 max = len; 161if(!max) 162break; 163} 164} 165return max; 166} 167 168/* 169 * Returns a copy of the longest leading path common among all 170 * pathspecs. 171 */ 172char*common_prefix(const struct pathspec *pathspec) 173{ 174unsigned long len =common_prefix_len(pathspec); 175 176return len ?xmemdupz(pathspec->items[0].match, len) : NULL; 177} 178 179intfill_directory(struct dir_struct *dir,const struct pathspec *pathspec) 180{ 181const char*prefix; 182size_t prefix_len; 183 184/* 185 * Calculate common prefix for the pathspec, and 186 * use that to optimize the directory walk 187 */ 188 prefix_len =common_prefix_len(pathspec); 189 prefix = prefix_len ? pathspec->items[0].match :""; 190 191/* Read the directory and prune it */ 192read_directory(dir, prefix, prefix_len, pathspec); 193 194return prefix_len; 195} 196 197intwithin_depth(const char*name,int namelen, 198int depth,int max_depth) 199{ 200const char*cp = name, *cpe = name + namelen; 201 202while(cp < cpe) { 203if(*cp++ !='/') 204continue; 205 depth++; 206if(depth > max_depth) 207return0; 208} 209return1; 210} 211 212#define DO_MATCH_EXCLUDE (1<<0) 213#define DO_MATCH_DIRECTORY (1<<1) 214#define DO_MATCH_SUBMODULE (1<<2) 215 216static intmatch_attrs(const char*name,int namelen, 217const struct pathspec_item *item) 218{ 219int i; 220 221git_check_attr(name, item->attr_check); 222for(i =0; i < item->attr_match_nr; i++) { 223const char*value; 224int matched; 225enum attr_match_mode match_mode; 226 227 value = item->attr_check->items[i].value; 228 match_mode = item->attr_match[i].match_mode; 229 230if(ATTR_TRUE(value)) 231 matched = (match_mode == MATCH_SET); 232else if(ATTR_FALSE(value)) 233 matched = (match_mode == MATCH_UNSET); 234else if(ATTR_UNSET(value)) 235 matched = (match_mode == MATCH_UNSPECIFIED); 236else 237 matched = (match_mode == MATCH_VALUE && 238!strcmp(item->attr_match[i].value, value)); 239if(!matched) 240return0; 241} 242 243return1; 244} 245 246/* 247 * Does 'match' match the given name? 248 * A match is found if 249 * 250 * (1) the 'match' string is leading directory of 'name', or 251 * (2) the 'match' string is a wildcard and matches 'name', or 252 * (3) the 'match' string is exactly the same as 'name'. 253 * 254 * and the return value tells which case it was. 255 * 256 * It returns 0 when there is no match. 257 */ 258static intmatch_pathspec_item(const struct pathspec_item *item,int prefix, 259const char*name,int namelen,unsigned flags) 260{ 261/* name/namelen has prefix cut off by caller */ 262const char*match = item->match + prefix; 263int matchlen = item->len - prefix; 264 265/* 266 * The normal call pattern is: 267 * 1. prefix = common_prefix_len(ps); 268 * 2. prune something, or fill_directory 269 * 3. match_pathspec() 270 * 271 * 'prefix' at #1 may be shorter than the command's prefix and 272 * it's ok for #2 to match extra files. Those extras will be 273 * trimmed at #3. 274 * 275 * Suppose the pathspec is 'foo' and '../bar' running from 276 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 277 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 278 * user does not want XYZ/foo, only the "foo" part should be 279 * case-insensitive. We need to filter out XYZ/foo here. In 280 * other words, we do not trust the caller on comparing the 281 * prefix part when :(icase) is involved. We do exact 282 * comparison ourselves. 283 * 284 * Normally the caller (common_prefix_len() in fact) does 285 * _exact_ matching on name[-prefix+1..-1] and we do not need 286 * to check that part. Be defensive and check it anyway, in 287 * case common_prefix_len is changed, or a new caller is 288 * introduced that does not use common_prefix_len. 289 * 290 * If the penalty turns out too high when prefix is really 291 * long, maybe change it to 292 * strncmp(match, name, item->prefix - prefix) 293 */ 294if(item->prefix && (item->magic & PATHSPEC_ICASE) && 295strncmp(item->match, name - prefix, item->prefix)) 296return0; 297 298if(item->attr_match_nr && !match_attrs(name, namelen, item)) 299return0; 300 301/* If the match was just the prefix, we matched */ 302if(!*match) 303return MATCHED_RECURSIVELY; 304 305if(matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 306if(matchlen == namelen) 307return MATCHED_EXACTLY; 308 309if(match[matchlen-1] =='/'|| name[matchlen] =='/') 310return MATCHED_RECURSIVELY; 311}else if((flags & DO_MATCH_DIRECTORY) && 312 match[matchlen -1] =='/'&& 313 namelen == matchlen -1&& 314!ps_strncmp(item, match, name, namelen)) 315return MATCHED_EXACTLY; 316 317if(item->nowildcard_len < item->len && 318!git_fnmatch(item, match, name, 319 item->nowildcard_len - prefix)) 320return MATCHED_FNMATCH; 321 322/* Perform checks to see if "name" is a super set of the pathspec */ 323if(flags & DO_MATCH_SUBMODULE) { 324/* name is a literal prefix of the pathspec */ 325if((namelen < matchlen) && 326(match[namelen] =='/') && 327!ps_strncmp(item, match, name, namelen)) 328return MATCHED_RECURSIVELY; 329 330/* name" doesn't match up to the first wild character */ 331if(item->nowildcard_len < item->len && 332ps_strncmp(item, match, name, 333 item->nowildcard_len - prefix)) 334return0; 335 336/* 337 * Here is where we would perform a wildmatch to check if 338 * "name" can be matched as a directory (or a prefix) against 339 * the pathspec. Since wildmatch doesn't have this capability 340 * at the present we have to punt and say that it is a match, 341 * potentially returning a false positive 342 * The submodules themselves will be able to perform more 343 * accurate matching to determine if the pathspec matches. 344 */ 345return MATCHED_RECURSIVELY; 346} 347 348return0; 349} 350 351/* 352 * Given a name and a list of pathspecs, returns the nature of the 353 * closest (i.e. most specific) match of the name to any of the 354 * pathspecs. 355 * 356 * The caller typically calls this multiple times with the same 357 * pathspec and seen[] array but with different name/namelen 358 * (e.g. entries from the index) and is interested in seeing if and 359 * how each pathspec matches all the names it calls this function 360 * with. A mark is left in the seen[] array for each pathspec element 361 * indicating the closest type of match that element achieved, so if 362 * seen[n] remains zero after multiple invocations, that means the nth 363 * pathspec did not match any names, which could indicate that the 364 * user mistyped the nth pathspec. 365 */ 366static intdo_match_pathspec(const struct pathspec *ps, 367const char*name,int namelen, 368int prefix,char*seen, 369unsigned flags) 370{ 371int i, retval =0, exclude = flags & DO_MATCH_EXCLUDE; 372 373GUARD_PATHSPEC(ps, 374 PATHSPEC_FROMTOP | 375 PATHSPEC_MAXDEPTH | 376 PATHSPEC_LITERAL | 377 PATHSPEC_GLOB | 378 PATHSPEC_ICASE | 379 PATHSPEC_EXCLUDE | 380 PATHSPEC_ATTR); 381 382if(!ps->nr) { 383if(!ps->recursive || 384!(ps->magic & PATHSPEC_MAXDEPTH) || 385 ps->max_depth == -1) 386return MATCHED_RECURSIVELY; 387 388if(within_depth(name, namelen,0, ps->max_depth)) 389return MATCHED_EXACTLY; 390else 391return0; 392} 393 394 name += prefix; 395 namelen -= prefix; 396 397for(i = ps->nr -1; i >=0; i--) { 398int how; 399 400if((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 401( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 402continue; 403 404if(seen && seen[i] == MATCHED_EXACTLY) 405continue; 406/* 407 * Make exclude patterns optional and never report 408 * "pathspec ':(exclude)foo' matches no files" 409 */ 410if(seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 411 seen[i] = MATCHED_FNMATCH; 412 how =match_pathspec_item(ps->items+i, prefix, name, 413 namelen, flags); 414if(ps->recursive && 415(ps->magic & PATHSPEC_MAXDEPTH) && 416 ps->max_depth != -1&& 417 how && how != MATCHED_FNMATCH) { 418int len = ps->items[i].len; 419if(name[len] =='/') 420 len++; 421if(within_depth(name+len, namelen-len,0, ps->max_depth)) 422 how = MATCHED_EXACTLY; 423else 424 how =0; 425} 426if(how) { 427if(retval < how) 428 retval = how; 429if(seen && seen[i] < how) 430 seen[i] = how; 431} 432} 433return retval; 434} 435 436intmatch_pathspec(const struct pathspec *ps, 437const char*name,int namelen, 438int prefix,char*seen,int is_dir) 439{ 440int positive, negative; 441unsigned flags = is_dir ? DO_MATCH_DIRECTORY :0; 442 positive =do_match_pathspec(ps, name, namelen, 443 prefix, seen, flags); 444if(!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 445return positive; 446 negative =do_match_pathspec(ps, name, namelen, 447 prefix, seen, 448 flags | DO_MATCH_EXCLUDE); 449return negative ?0: positive; 450} 451 452/** 453 * Check if a submodule is a superset of the pathspec 454 */ 455intsubmodule_path_match(const struct pathspec *ps, 456const char*submodule_name, 457char*seen) 458{ 459int matched =do_match_pathspec(ps, submodule_name, 460strlen(submodule_name), 4610, seen, 462 DO_MATCH_DIRECTORY | 463 DO_MATCH_SUBMODULE); 464return matched; 465} 466 467intreport_path_error(const char*ps_matched, 468const struct pathspec *pathspec, 469const char*prefix) 470{ 471/* 472 * Make sure all pathspec matched; otherwise it is an error. 473 */ 474int num, errors =0; 475for(num =0; num < pathspec->nr; num++) { 476int other, found_dup; 477 478if(ps_matched[num]) 479continue; 480/* 481 * The caller might have fed identical pathspec 482 * twice. Do not barf on such a mistake. 483 * FIXME: parse_pathspec should have eliminated 484 * duplicate pathspec. 485 */ 486for(found_dup = other =0; 487!found_dup && other < pathspec->nr; 488 other++) { 489if(other == num || !ps_matched[other]) 490continue; 491if(!strcmp(pathspec->items[other].original, 492 pathspec->items[num].original)) 493/* 494 * Ok, we have a match already. 495 */ 496 found_dup =1; 497} 498if(found_dup) 499continue; 500 501error("pathspec '%s' did not match any file(s) known to git.", 502 pathspec->items[num].original); 503 errors++; 504} 505return errors; 506} 507 508/* 509 * Return the length of the "simple" part of a path match limiter. 510 */ 511intsimple_length(const char*match) 512{ 513int len = -1; 514 515for(;;) { 516unsigned char c = *match++; 517 len++; 518if(c =='\0'||is_glob_special(c)) 519return len; 520} 521} 522 523intno_wildcard(const char*string) 524{ 525return string[simple_length(string)] =='\0'; 526} 527 528voidparse_exclude_pattern(const char**pattern, 529int*patternlen, 530unsigned*flags, 531int*nowildcardlen) 532{ 533const char*p = *pattern; 534size_t i, len; 535 536*flags =0; 537if(*p =='!') { 538*flags |= EXC_FLAG_NEGATIVE; 539 p++; 540} 541 len =strlen(p); 542if(len && p[len -1] =='/') { 543 len--; 544*flags |= EXC_FLAG_MUSTBEDIR; 545} 546for(i =0; i < len; i++) { 547if(p[i] =='/') 548break; 549} 550if(i == len) 551*flags |= EXC_FLAG_NODIR; 552*nowildcardlen =simple_length(p); 553/* 554 * we should have excluded the trailing slash from 'p' too, 555 * but that's one more allocation. Instead just make sure 556 * nowildcardlen does not exceed real patternlen 557 */ 558if(*nowildcardlen > len) 559*nowildcardlen = len; 560if(*p =='*'&&no_wildcard(p +1)) 561*flags |= EXC_FLAG_ENDSWITH; 562*pattern = p; 563*patternlen = len; 564} 565 566voidadd_exclude(const char*string,const char*base, 567int baselen,struct exclude_list *el,int srcpos) 568{ 569struct exclude *x; 570int patternlen; 571unsigned flags; 572int nowildcardlen; 573 574parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 575if(flags & EXC_FLAG_MUSTBEDIR) { 576FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 577}else{ 578 x =xmalloc(sizeof(*x)); 579 x->pattern = string; 580} 581 x->patternlen = patternlen; 582 x->nowildcardlen = nowildcardlen; 583 x->base = base; 584 x->baselen = baselen; 585 x->flags = flags; 586 x->srcpos = srcpos; 587ALLOC_GROW(el->excludes, el->nr +1, el->alloc); 588 el->excludes[el->nr++] = x; 589 x->el = el; 590} 591 592static void*read_skip_worktree_file_from_index(const struct index_state *istate, 593const char*path,size_t*size, 594struct sha1_stat *sha1_stat) 595{ 596int pos, len; 597unsigned long sz; 598enum object_type type; 599void*data; 600 601 len =strlen(path); 602 pos =index_name_pos(istate, path, len); 603if(pos <0) 604return NULL; 605if(!ce_skip_worktree(istate->cache[pos])) 606return NULL; 607 data =read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz); 608if(!data || type != OBJ_BLOB) { 609free(data); 610return NULL; 611} 612*size =xsize_t(sz); 613if(sha1_stat) { 614memset(&sha1_stat->stat,0,sizeof(sha1_stat->stat)); 615hashcpy(sha1_stat->sha1, istate->cache[pos]->oid.hash); 616} 617return data; 618} 619 620/* 621 * Frees memory within el which was allocated for exclude patterns and 622 * the file buffer. Does not free el itself. 623 */ 624voidclear_exclude_list(struct exclude_list *el) 625{ 626int i; 627 628for(i =0; i < el->nr; i++) 629free(el->excludes[i]); 630free(el->excludes); 631free(el->filebuf); 632 633memset(el,0,sizeof(*el)); 634} 635 636static voidtrim_trailing_spaces(char*buf) 637{ 638char*p, *last_space = NULL; 639 640for(p = buf; *p; p++) 641switch(*p) { 642case' ': 643if(!last_space) 644 last_space = p; 645break; 646case'\\': 647 p++; 648if(!*p) 649return; 650/* fallthrough */ 651default: 652 last_space = NULL; 653} 654 655if(last_space) 656*last_space ='\0'; 657} 658 659/* 660 * Given a subdirectory name and "dir" of the current directory, 661 * search the subdir in "dir" and return it, or create a new one if it 662 * does not exist in "dir". 663 * 664 * If "name" has the trailing slash, it'll be excluded in the search. 665 */ 666static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 667struct untracked_cache_dir *dir, 668const char*name,int len) 669{ 670int first, last; 671struct untracked_cache_dir *d; 672if(!dir) 673return NULL; 674if(len && name[len -1] =='/') 675 len--; 676 first =0; 677 last = dir->dirs_nr; 678while(last > first) { 679int cmp, next = (last + first) >>1; 680 d = dir->dirs[next]; 681 cmp =strncmp(name, d->name, len); 682if(!cmp &&strlen(d->name) > len) 683 cmp = -1; 684if(!cmp) 685return d; 686if(cmp <0) { 687 last = next; 688continue; 689} 690 first = next+1; 691} 692 693 uc->dir_created++; 694FLEX_ALLOC_MEM(d, name, name, len); 695 696ALLOC_GROW(dir->dirs, dir->dirs_nr +1, dir->dirs_alloc); 697memmove(dir->dirs + first +1, dir->dirs + first, 698(dir->dirs_nr - first) *sizeof(*dir->dirs)); 699 dir->dirs_nr++; 700 dir->dirs[first] = d; 701return d; 702} 703 704static voiddo_invalidate_gitignore(struct untracked_cache_dir *dir) 705{ 706int i; 707 dir->valid =0; 708 dir->untracked_nr =0; 709for(i =0; i < dir->dirs_nr; i++) 710do_invalidate_gitignore(dir->dirs[i]); 711} 712 713static voidinvalidate_gitignore(struct untracked_cache *uc, 714struct untracked_cache_dir *dir) 715{ 716 uc->gitignore_invalidated++; 717do_invalidate_gitignore(dir); 718} 719 720static voidinvalidate_directory(struct untracked_cache *uc, 721struct untracked_cache_dir *dir) 722{ 723int i; 724 uc->dir_invalidated++; 725 dir->valid =0; 726 dir->untracked_nr =0; 727for(i =0; i < dir->dirs_nr; i++) 728 dir->dirs[i]->recurse =0; 729} 730 731/* 732 * Given a file with name "fname", read it (either from disk, or from 733 * the index if "check_index" is non-zero), parse it and store the 734 * exclude rules in "el". 735 * 736 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 737 * stat data from disk (only valid if add_excludes returns zero). If 738 * ss_valid is non-zero, "ss" must contain good value as input. 739 */ 740static intadd_excludes(const char*fname,const char*base,int baselen, 741struct exclude_list *el,int check_index, 742struct sha1_stat *sha1_stat) 743{ 744struct stat st; 745int fd, i, lineno =1; 746size_t size =0; 747char*buf, *entry; 748 749 fd =open(fname, O_RDONLY); 750if(fd <0||fstat(fd, &st) <0) { 751if(errno != ENOENT) 752warn_on_inaccessible(fname); 753if(0<= fd) 754close(fd); 755if(!check_index || 756(buf =read_skip_worktree_file_from_index(&the_index, fname, &size, sha1_stat)) == NULL) 757return-1; 758if(size ==0) { 759free(buf); 760return0; 761} 762if(buf[size-1] !='\n') { 763 buf =xrealloc(buf,st_add(size,1)); 764 buf[size++] ='\n'; 765} 766}else{ 767 size =xsize_t(st.st_size); 768if(size ==0) { 769if(sha1_stat) { 770fill_stat_data(&sha1_stat->stat, &st); 771hashcpy(sha1_stat->sha1, EMPTY_BLOB_SHA1_BIN); 772 sha1_stat->valid =1; 773} 774close(fd); 775return0; 776} 777 buf =xmallocz(size); 778if(read_in_full(fd, buf, size) != size) { 779free(buf); 780close(fd); 781return-1; 782} 783 buf[size++] ='\n'; 784close(fd); 785if(sha1_stat) { 786int pos; 787if(sha1_stat->valid && 788!match_stat_data_racy(&the_index, &sha1_stat->stat, &st)) 789;/* no content change, ss->sha1 still good */ 790else if(check_index && 791(pos =index_name_pos(&the_index, fname,strlen(fname))) >=0&& 792!ce_stage(the_index.cache[pos]) && 793ce_uptodate(the_index.cache[pos]) && 794!would_convert_to_git(fname)) 795hashcpy(sha1_stat->sha1, 796 the_index.cache[pos]->oid.hash); 797else 798hash_sha1_file(buf, size,"blob", sha1_stat->sha1); 799fill_stat_data(&sha1_stat->stat, &st); 800 sha1_stat->valid =1; 801} 802} 803 804 el->filebuf = buf; 805 806if(skip_utf8_bom(&buf, size)) 807 size -= buf - el->filebuf; 808 809 entry = buf; 810 811for(i =0; i < size; i++) { 812if(buf[i] =='\n') { 813if(entry != buf + i && entry[0] !='#') { 814 buf[i - (i && buf[i-1] =='\r')] =0; 815trim_trailing_spaces(entry); 816add_exclude(entry, base, baselen, el, lineno); 817} 818 lineno++; 819 entry = buf + i +1; 820} 821} 822return0; 823} 824 825intadd_excludes_from_file_to_list(const char*fname,const char*base, 826int baselen,struct exclude_list *el, 827int check_index) 828{ 829returnadd_excludes(fname, base, baselen, el, check_index, NULL); 830} 831 832struct exclude_list *add_exclude_list(struct dir_struct *dir, 833int group_type,const char*src) 834{ 835struct exclude_list *el; 836struct exclude_list_group *group; 837 838 group = &dir->exclude_list_group[group_type]; 839ALLOC_GROW(group->el, group->nr +1, group->alloc); 840 el = &group->el[group->nr++]; 841memset(el,0,sizeof(*el)); 842 el->src = src; 843return el; 844} 845 846/* 847 * Used to set up core.excludesfile and .git/info/exclude lists. 848 */ 849static voidadd_excludes_from_file_1(struct dir_struct *dir,const char*fname, 850struct sha1_stat *sha1_stat) 851{ 852struct exclude_list *el; 853/* 854 * catch setup_standard_excludes() that's called before 855 * dir->untracked is assigned. That function behaves 856 * differently when dir->untracked is non-NULL. 857 */ 858if(!dir->untracked) 859 dir->unmanaged_exclude_files++; 860 el =add_exclude_list(dir, EXC_FILE, fname); 861if(add_excludes(fname,"",0, el,0, sha1_stat) <0) 862die("cannot use%sas an exclude file", fname); 863} 864 865voidadd_excludes_from_file(struct dir_struct *dir,const char*fname) 866{ 867 dir->unmanaged_exclude_files++;/* see validate_untracked_cache() */ 868add_excludes_from_file_1(dir, fname, NULL); 869} 870 871intmatch_basename(const char*basename,int basenamelen, 872const char*pattern,int prefix,int patternlen, 873unsigned flags) 874{ 875if(prefix == patternlen) { 876if(patternlen == basenamelen && 877!fspathncmp(pattern, basename, basenamelen)) 878return1; 879}else if(flags & EXC_FLAG_ENDSWITH) { 880/* "*literal" matching against "fooliteral" */ 881if(patternlen -1<= basenamelen && 882!fspathncmp(pattern +1, 883 basename + basenamelen - (patternlen -1), 884 patternlen -1)) 885return1; 886}else{ 887if(fnmatch_icase_mem(pattern, patternlen, 888 basename, basenamelen, 8890) ==0) 890return1; 891} 892return0; 893} 894 895intmatch_pathname(const char*pathname,int pathlen, 896const char*base,int baselen, 897const char*pattern,int prefix,int patternlen, 898unsigned flags) 899{ 900const char*name; 901int namelen; 902 903/* 904 * match with FNM_PATHNAME; the pattern has base implicitly 905 * in front of it. 906 */ 907if(*pattern =='/') { 908 pattern++; 909 patternlen--; 910 prefix--; 911} 912 913/* 914 * baselen does not count the trailing slash. base[] may or 915 * may not end with a trailing slash though. 916 */ 917if(pathlen < baselen +1|| 918(baselen && pathname[baselen] !='/') || 919fspathncmp(pathname, base, baselen)) 920return0; 921 922 namelen = baselen ? pathlen - baselen -1: pathlen; 923 name = pathname + pathlen - namelen; 924 925if(prefix) { 926/* 927 * if the non-wildcard part is longer than the 928 * remaining pathname, surely it cannot match. 929 */ 930if(prefix > namelen) 931return0; 932 933if(fspathncmp(pattern, name, prefix)) 934return0; 935 pattern += prefix; 936 patternlen -= prefix; 937 name += prefix; 938 namelen -= prefix; 939 940/* 941 * If the whole pattern did not have a wildcard, 942 * then our prefix match is all we need; we 943 * do not need to call fnmatch at all. 944 */ 945if(!patternlen && !namelen) 946return1; 947} 948 949returnfnmatch_icase_mem(pattern, patternlen, 950 name, namelen, 951 WM_PATHNAME) ==0; 952} 953 954/* 955 * Scan the given exclude list in reverse to see whether pathname 956 * should be ignored. The first match (i.e. the last on the list), if 957 * any, determines the fate. Returns the exclude_list element which 958 * matched, or NULL for undecided. 959 */ 960static struct exclude *last_exclude_matching_from_list(const char*pathname, 961int pathlen, 962const char*basename, 963int*dtype, 964struct exclude_list *el) 965{ 966struct exclude *exc = NULL;/* undecided */ 967int i; 968 969if(!el->nr) 970return NULL;/* undefined */ 971 972for(i = el->nr -1;0<= i; i--) { 973struct exclude *x = el->excludes[i]; 974const char*exclude = x->pattern; 975int prefix = x->nowildcardlen; 976 977if(x->flags & EXC_FLAG_MUSTBEDIR) { 978if(*dtype == DT_UNKNOWN) 979*dtype =get_dtype(NULL, &the_index, pathname, pathlen); 980if(*dtype != DT_DIR) 981continue; 982} 983 984if(x->flags & EXC_FLAG_NODIR) { 985if(match_basename(basename, 986 pathlen - (basename - pathname), 987 exclude, prefix, x->patternlen, 988 x->flags)) { 989 exc = x; 990break; 991} 992continue; 993} 994 995assert(x->baselen ==0|| x->base[x->baselen -1] =='/'); 996if(match_pathname(pathname, pathlen, 997 x->base, x->baselen ? x->baselen -1:0, 998 exclude, prefix, x->patternlen, x->flags)) { 999 exc = x;1000break;1001}1002}1003return exc;1004}10051006/*1007 * Scan the list and let the last match determine the fate.1008 * Return 1 for exclude, 0 for include and -1 for undecided.1009 */1010intis_excluded_from_list(const char*pathname,1011int pathlen,const char*basename,int*dtype,1012struct exclude_list *el)1013{1014struct exclude *exclude;1015 exclude =last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el);1016if(exclude)1017return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1018return-1;/* undecided */1019}10201021static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1022const char*pathname,int pathlen,const char*basename,1023int*dtype_p)1024{1025int i, j;1026struct exclude_list_group *group;1027struct exclude *exclude;1028for(i = EXC_CMDL; i <= EXC_FILE; i++) {1029 group = &dir->exclude_list_group[i];1030for(j = group->nr -1; j >=0; j--) {1031 exclude =last_exclude_matching_from_list(1032 pathname, pathlen, basename, dtype_p,1033&group->el[j]);1034if(exclude)1035return exclude;1036}1037}1038return NULL;1039}10401041/*1042 * Loads the per-directory exclude list for the substring of base1043 * which has a char length of baselen.1044 */1045static voidprep_exclude(struct dir_struct *dir,const char*base,int baselen)1046{1047struct exclude_list_group *group;1048struct exclude_list *el;1049struct exclude_stack *stk = NULL;1050struct untracked_cache_dir *untracked;1051int current;10521053 group = &dir->exclude_list_group[EXC_DIRS];10541055/*1056 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1057 * which originate from directories not in the prefix of the1058 * path being checked.1059 */1060while((stk = dir->exclude_stack) != NULL) {1061if(stk->baselen <= baselen &&1062!strncmp(dir->basebuf.buf, base, stk->baselen))1063break;1064 el = &group->el[dir->exclude_stack->exclude_ix];1065 dir->exclude_stack = stk->prev;1066 dir->exclude = NULL;1067free((char*)el->src);/* see strbuf_detach() below */1068clear_exclude_list(el);1069free(stk);1070 group->nr--;1071}10721073/* Skip traversing into sub directories if the parent is excluded */1074if(dir->exclude)1075return;10761077/*1078 * Lazy initialization. All call sites currently just1079 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1080 * them seems lots of work for little benefit.1081 */1082if(!dir->basebuf.buf)1083strbuf_init(&dir->basebuf, PATH_MAX);10841085/* Read from the parent directories and push them down. */1086 current = stk ? stk->baselen : -1;1087strbuf_setlen(&dir->basebuf, current <0?0: current);1088if(dir->untracked)1089 untracked = stk ? stk->ucd : dir->untracked->root;1090else1091 untracked = NULL;10921093while(current < baselen) {1094const char*cp;1095struct sha1_stat sha1_stat;10961097 stk =xcalloc(1,sizeof(*stk));1098if(current <0) {1099 cp = base;1100 current =0;1101}else{1102 cp =strchr(base + current +1,'/');1103if(!cp)1104die("oops in prep_exclude");1105 cp++;1106 untracked =1107lookup_untracked(dir->untracked, untracked,1108 base + current,1109 cp - base - current);1110}1111 stk->prev = dir->exclude_stack;1112 stk->baselen = cp - base;1113 stk->exclude_ix = group->nr;1114 stk->ucd = untracked;1115 el =add_exclude_list(dir, EXC_DIRS, NULL);1116strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1117assert(stk->baselen == dir->basebuf.len);11181119/* Abort if the directory is excluded */1120if(stk->baselen) {1121int dt = DT_DIR;1122 dir->basebuf.buf[stk->baselen -1] =0;1123 dir->exclude =last_exclude_matching_from_lists(dir,1124 dir->basebuf.buf, stk->baselen -1,1125 dir->basebuf.buf + current, &dt);1126 dir->basebuf.buf[stk->baselen -1] ='/';1127if(dir->exclude &&1128 dir->exclude->flags & EXC_FLAG_NEGATIVE)1129 dir->exclude = NULL;1130if(dir->exclude) {1131 dir->exclude_stack = stk;1132return;1133}1134}11351136/* Try to read per-directory file */1137hashclr(sha1_stat.sha1);1138 sha1_stat.valid =0;1139if(dir->exclude_per_dir &&1140/*1141 * If we know that no files have been added in1142 * this directory (i.e. valid_cached_dir() has1143 * been executed and set untracked->valid) ..1144 */1145(!untracked || !untracked->valid ||1146/*1147 * .. and .gitignore does not exist before1148 * (i.e. null exclude_sha1). Then we can skip1149 * loading .gitignore, which would result in1150 * ENOENT anyway.1151 */1152!is_null_sha1(untracked->exclude_sha1))) {1153/*1154 * dir->basebuf gets reused by the traversal, but we1155 * need fname to remain unchanged to ensure the src1156 * member of each struct exclude correctly1157 * back-references its source file. Other invocations1158 * of add_exclude_list provide stable strings, so we1159 * strbuf_detach() and free() here in the caller.1160 */1161struct strbuf sb = STRBUF_INIT;1162strbuf_addbuf(&sb, &dir->basebuf);1163strbuf_addstr(&sb, dir->exclude_per_dir);1164 el->src =strbuf_detach(&sb, NULL);1165add_excludes(el->src, el->src, stk->baselen, el,1,1166 untracked ? &sha1_stat : NULL);1167}1168/*1169 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1170 * will first be called in valid_cached_dir() then maybe many1171 * times more in last_exclude_matching(). When the cache is1172 * used, last_exclude_matching() will not be called and1173 * reading .gitignore content will be a waste.1174 *1175 * So when it's called by valid_cached_dir() and we can get1176 * .gitignore SHA-1 from the index (i.e. .gitignore is not1177 * modified on work tree), we could delay reading the1178 * .gitignore content until we absolutely need it in1179 * last_exclude_matching(). Be careful about ignore rule1180 * order, though, if you do that.1181 */1182if(untracked &&1183hashcmp(sha1_stat.sha1, untracked->exclude_sha1)) {1184invalidate_gitignore(dir->untracked, untracked);1185hashcpy(untracked->exclude_sha1, sha1_stat.sha1);1186}1187 dir->exclude_stack = stk;1188 current = stk->baselen;1189}1190strbuf_setlen(&dir->basebuf, baselen);1191}11921193/*1194 * Loads the exclude lists for the directory containing pathname, then1195 * scans all exclude lists to determine whether pathname is excluded.1196 * Returns the exclude_list element which matched, or NULL for1197 * undecided.1198 */1199struct exclude *last_exclude_matching(struct dir_struct *dir,1200const char*pathname,1201int*dtype_p)1202{1203int pathlen =strlen(pathname);1204const char*basename =strrchr(pathname,'/');1205 basename = (basename) ? basename+1: pathname;12061207prep_exclude(dir, pathname, basename-pathname);12081209if(dir->exclude)1210return dir->exclude;12111212returnlast_exclude_matching_from_lists(dir, pathname, pathlen,1213 basename, dtype_p);1214}12151216/*1217 * Loads the exclude lists for the directory containing pathname, then1218 * scans all exclude lists to determine whether pathname is excluded.1219 * Returns 1 if true, otherwise 0.1220 */1221intis_excluded(struct dir_struct *dir,const char*pathname,int*dtype_p)1222{1223struct exclude *exclude =1224last_exclude_matching(dir, pathname, dtype_p);1225if(exclude)1226return exclude->flags & EXC_FLAG_NEGATIVE ?0:1;1227return0;1228}12291230static struct dir_entry *dir_entry_new(const char*pathname,int len)1231{1232struct dir_entry *ent;12331234FLEX_ALLOC_MEM(ent, name, pathname, len);1235 ent->len = len;1236return ent;1237}12381239static struct dir_entry *dir_add_name(struct dir_struct *dir,1240struct index_state *istate,1241const char*pathname,int len)1242{1243if(index_file_exists(istate, pathname, len, ignore_case))1244return NULL;12451246ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1247return dir->entries[dir->nr++] =dir_entry_new(pathname, len);1248}12491250struct dir_entry *dir_add_ignored(struct dir_struct *dir,1251struct index_state *istate,1252const char*pathname,int len)1253{1254if(!index_name_is_other(istate, pathname, len))1255return NULL;12561257ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1258return dir->ignored[dir->ignored_nr++] =dir_entry_new(pathname, len);1259}12601261enum exist_status {1262 index_nonexistent =0,1263 index_directory,1264 index_gitdir1265};12661267/*1268 * Do not use the alphabetically sorted index to look up1269 * the directory name; instead, use the case insensitive1270 * directory hash.1271 */1272static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1273const char*dirname,int len)1274{1275struct cache_entry *ce;12761277if(index_dir_exists(istate, dirname, len))1278return index_directory;12791280 ce =index_file_exists(istate, dirname, len, ignore_case);1281if(ce &&S_ISGITLINK(ce->ce_mode))1282return index_gitdir;12831284return index_nonexistent;1285}12861287/*1288 * The index sorts alphabetically by entry name, which1289 * means that a gitlink sorts as '\0' at the end, while1290 * a directory (which is defined not as an entry, but as1291 * the files it contains) will sort with the '/' at the1292 * end.1293 */1294static enum exist_status directory_exists_in_index(struct index_state *istate,1295const char*dirname,int len)1296{1297int pos;12981299if(ignore_case)1300returndirectory_exists_in_index_icase(istate, dirname, len);13011302 pos =index_name_pos(istate, dirname, len);1303if(pos <0)1304 pos = -pos-1;1305while(pos < istate->cache_nr) {1306const struct cache_entry *ce = istate->cache[pos++];1307unsigned char endchar;13081309if(strncmp(ce->name, dirname, len))1310break;1311 endchar = ce->name[len];1312if(endchar >'/')1313break;1314if(endchar =='/')1315return index_directory;1316if(!endchar &&S_ISGITLINK(ce->ce_mode))1317return index_gitdir;1318}1319return index_nonexistent;1320}13211322/*1323 * When we find a directory when traversing the filesystem, we1324 * have three distinct cases:1325 *1326 * - ignore it1327 * - see it as a directory1328 * - recurse into it1329 *1330 * and which one we choose depends on a combination of existing1331 * git index contents and the flags passed into the directory1332 * traversal routine.1333 *1334 * Case 1: If we *already* have entries in the index under that1335 * directory name, we always recurse into the directory to see1336 * all the files.1337 *1338 * Case 2: If we *already* have that directory name as a gitlink,1339 * we always continue to see it as a gitlink, regardless of whether1340 * there is an actual git directory there or not (it might not1341 * be checked out as a subproject!)1342 *1343 * Case 3: if we didn't have it in the index previously, we1344 * have a few sub-cases:1345 *1346 * (a) if "show_other_directories" is true, we show it as1347 * just a directory, unless "hide_empty_directories" is1348 * also true, in which case we need to check if it contains any1349 * untracked and / or ignored files.1350 * (b) if it looks like a git directory, and we don't have1351 * 'no_gitlinks' set we treat it as a gitlink, and show it1352 * as a directory.1353 * (c) otherwise, we recurse into it.1354 */1355static enum path_treatment treat_directory(struct dir_struct *dir,1356struct untracked_cache_dir *untracked,1357const char*dirname,int len,int baselen,int exclude,1358const struct pathspec *pathspec)1359{1360/* The "len-1" is to strip the final '/' */1361switch(directory_exists_in_index(&the_index, dirname, len-1)) {1362case index_directory:1363return path_recurse;13641365case index_gitdir:1366return path_none;13671368case index_nonexistent:1369if(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1370break;1371if(!(dir->flags & DIR_NO_GITLINKS)) {1372unsigned char sha1[20];1373if(resolve_gitlink_ref(dirname,"HEAD", sha1) ==0)1374return path_untracked;1375}1376return path_recurse;1377}13781379/* This is the "show_other_directories" case */13801381if(!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1382return exclude ? path_excluded : path_untracked;13831384 untracked =lookup_untracked(dir->untracked, untracked,1385 dirname + baselen, len - baselen);1386returnread_directory_recursive(dir, dirname, len,1387 untracked,1, pathspec);1388}13891390/*1391 * This is an inexact early pruning of any recursive directory1392 * reading - if the path cannot possibly be in the pathspec,1393 * return true, and we'll skip it early.1394 */1395static intsimplify_away(const char*path,int pathlen,1396const struct pathspec *pathspec)1397{1398int i;13991400if(!pathspec || !pathspec->nr)1401return0;14021403GUARD_PATHSPEC(pathspec,1404 PATHSPEC_FROMTOP |1405 PATHSPEC_MAXDEPTH |1406 PATHSPEC_LITERAL |1407 PATHSPEC_GLOB |1408 PATHSPEC_ICASE |1409 PATHSPEC_EXCLUDE |1410 PATHSPEC_ATTR);14111412for(i =0; i < pathspec->nr; i++) {1413const struct pathspec_item *item = &pathspec->items[i];1414int len = item->nowildcard_len;14151416if(len > pathlen)1417 len = pathlen;1418if(!ps_strncmp(item, item->match, path, len))1419return0;1420}14211422return1;1423}14241425/*1426 * This function tells us whether an excluded path matches a1427 * list of "interesting" pathspecs. That is, whether a path matched1428 * by any of the pathspecs could possibly be ignored by excluding1429 * the specified path. This can happen if:1430 *1431 * 1. the path is mentioned explicitly in the pathspec1432 *1433 * 2. the path is a directory prefix of some element in the1434 * pathspec1435 */1436static intexclude_matches_pathspec(const char*path,int pathlen,1437const struct pathspec *pathspec)1438{1439int i;14401441if(!pathspec || !pathspec->nr)1442return0;14431444GUARD_PATHSPEC(pathspec,1445 PATHSPEC_FROMTOP |1446 PATHSPEC_MAXDEPTH |1447 PATHSPEC_LITERAL |1448 PATHSPEC_GLOB |1449 PATHSPEC_ICASE |1450 PATHSPEC_EXCLUDE);14511452for(i =0; i < pathspec->nr; i++) {1453const struct pathspec_item *item = &pathspec->items[i];1454int len = item->nowildcard_len;14551456if(len == pathlen &&1457!ps_strncmp(item, item->match, path, pathlen))1458return1;1459if(len > pathlen &&1460 item->match[pathlen] =='/'&&1461!ps_strncmp(item, item->match, path, pathlen))1462return1;1463}1464return0;1465}14661467static intget_index_dtype(struct index_state *istate,1468const char*path,int len)1469{1470int pos;1471const struct cache_entry *ce;14721473 ce =index_file_exists(istate, path, len,0);1474if(ce) {1475if(!ce_uptodate(ce))1476return DT_UNKNOWN;1477if(S_ISGITLINK(ce->ce_mode))1478return DT_DIR;1479/*1480 * Nobody actually cares about the1481 * difference between DT_LNK and DT_REG1482 */1483return DT_REG;1484}14851486/* Try to look it up as a directory */1487 pos =index_name_pos(istate, path, len);1488if(pos >=0)1489return DT_UNKNOWN;1490 pos = -pos-1;1491while(pos < istate->cache_nr) {1492 ce = istate->cache[pos++];1493if(strncmp(ce->name, path, len))1494break;1495if(ce->name[len] >'/')1496break;1497if(ce->name[len] <'/')1498continue;1499if(!ce_uptodate(ce))1500break;/* continue? */1501return DT_DIR;1502}1503return DT_UNKNOWN;1504}15051506static intget_dtype(struct dirent *de,struct index_state *istate,1507const char*path,int len)1508{1509int dtype = de ?DTYPE(de) : DT_UNKNOWN;1510struct stat st;15111512if(dtype != DT_UNKNOWN)1513return dtype;1514 dtype =get_index_dtype(istate, path, len);1515if(dtype != DT_UNKNOWN)1516return dtype;1517if(lstat(path, &st))1518return dtype;1519if(S_ISREG(st.st_mode))1520return DT_REG;1521if(S_ISDIR(st.st_mode))1522return DT_DIR;1523if(S_ISLNK(st.st_mode))1524return DT_LNK;1525return dtype;1526}15271528static enum path_treatment treat_one_path(struct dir_struct *dir,1529struct untracked_cache_dir *untracked,1530struct strbuf *path,1531int baselen,1532const struct pathspec *pathspec,1533int dtype,struct dirent *de)1534{1535int exclude;1536int has_path_in_index = !!index_file_exists(&the_index, path->buf, path->len, ignore_case);15371538if(dtype == DT_UNKNOWN)1539 dtype =get_dtype(de, &the_index, path->buf, path->len);15401541/* Always exclude indexed files */1542if(dtype != DT_DIR && has_path_in_index)1543return path_none;15441545/*1546 * When we are looking at a directory P in the working tree,1547 * there are three cases:1548 *1549 * (1) P exists in the index. Everything inside the directory P in1550 * the working tree needs to go when P is checked out from the1551 * index.1552 *1553 * (2) P does not exist in the index, but there is P/Q in the index.1554 * We know P will stay a directory when we check out the contents1555 * of the index, but we do not know yet if there is a directory1556 * P/Q in the working tree to be killed, so we need to recurse.1557 *1558 * (3) P does not exist in the index, and there is no P/Q in the index1559 * to require P to be a directory, either. Only in this case, we1560 * know that everything inside P will not be killed without1561 * recursing.1562 */1563if((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1564(dtype == DT_DIR) &&1565!has_path_in_index &&1566(directory_exists_in_index(&the_index, path->buf, path->len) == index_nonexistent))1567return path_none;15681569 exclude =is_excluded(dir, path->buf, &dtype);15701571/*1572 * Excluded? If we don't explicitly want to show1573 * ignored files, ignore it1574 */1575if(exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1576return path_excluded;15771578switch(dtype) {1579default:1580return path_none;1581case DT_DIR:1582strbuf_addch(path,'/');1583returntreat_directory(dir, untracked, path->buf, path->len,1584 baselen, exclude, pathspec);1585case DT_REG:1586case DT_LNK:1587return exclude ? path_excluded : path_untracked;1588}1589}15901591static enum path_treatment treat_path_fast(struct dir_struct *dir,1592struct untracked_cache_dir *untracked,1593struct cached_dir *cdir,1594struct strbuf *path,1595int baselen,1596const struct pathspec *pathspec)1597{1598strbuf_setlen(path, baselen);1599if(!cdir->ucd) {1600strbuf_addstr(path, cdir->file);1601return path_untracked;1602}1603strbuf_addstr(path, cdir->ucd->name);1604/* treat_one_path() does this before it calls treat_directory() */1605strbuf_complete(path,'/');1606if(cdir->ucd->check_only)1607/*1608 * check_only is set as a result of treat_directory() getting1609 * to its bottom. Verify again the same set of directories1610 * with check_only set.1611 */1612returnread_directory_recursive(dir, path->buf, path->len,1613 cdir->ucd,1, pathspec);1614/*1615 * We get path_recurse in the first run when1616 * directory_exists_in_index() returns index_nonexistent. We1617 * are sure that new changes in the index does not impact the1618 * outcome. Return now.1619 */1620return path_recurse;1621}16221623static enum path_treatment treat_path(struct dir_struct *dir,1624struct untracked_cache_dir *untracked,1625struct cached_dir *cdir,1626struct strbuf *path,1627int baselen,1628const struct pathspec *pathspec)1629{1630int dtype;1631struct dirent *de = cdir->de;16321633if(!de)1634returntreat_path_fast(dir, untracked, cdir, path,1635 baselen, pathspec);1636if(is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name,".git"))1637return path_none;1638strbuf_setlen(path, baselen);1639strbuf_addstr(path, de->d_name);1640if(simplify_away(path->buf, path->len, pathspec))1641return path_none;16421643 dtype =DTYPE(de);1644returntreat_one_path(dir, untracked, path, baselen, pathspec, dtype, de);1645}16461647static voidadd_untracked(struct untracked_cache_dir *dir,const char*name)1648{1649if(!dir)1650return;1651ALLOC_GROW(dir->untracked, dir->untracked_nr +1,1652 dir->untracked_alloc);1653 dir->untracked[dir->untracked_nr++] =xstrdup(name);1654}16551656static intvalid_cached_dir(struct dir_struct *dir,1657struct untracked_cache_dir *untracked,1658struct strbuf *path,1659int check_only)1660{1661struct stat st;16621663if(!untracked)1664return0;16651666if(stat(path->len ? path->buf :".", &st)) {1667invalidate_directory(dir->untracked, untracked);1668memset(&untracked->stat_data,0,sizeof(untracked->stat_data));1669return0;1670}1671if(!untracked->valid ||1672match_stat_data_racy(&the_index, &untracked->stat_data, &st)) {1673if(untracked->valid)1674invalidate_directory(dir->untracked, untracked);1675fill_stat_data(&untracked->stat_data, &st);1676return0;1677}16781679if(untracked->check_only != !!check_only) {1680invalidate_directory(dir->untracked, untracked);1681return0;1682}16831684/*1685 * prep_exclude will be called eventually on this directory,1686 * but it's called much later in last_exclude_matching(). We1687 * need it now to determine the validity of the cache for this1688 * path. The next calls will be nearly no-op, the way1689 * prep_exclude() is designed.1690 */1691if(path->len && path->buf[path->len -1] !='/') {1692strbuf_addch(path,'/');1693prep_exclude(dir, path->buf, path->len);1694strbuf_setlen(path, path->len -1);1695}else1696prep_exclude(dir, path->buf, path->len);16971698/* hopefully prep_exclude() haven't invalidated this entry... */1699return untracked->valid;1700}17011702static intopen_cached_dir(struct cached_dir *cdir,1703struct dir_struct *dir,1704struct untracked_cache_dir *untracked,1705struct strbuf *path,1706int check_only)1707{1708memset(cdir,0,sizeof(*cdir));1709 cdir->untracked = untracked;1710if(valid_cached_dir(dir, untracked, path, check_only))1711return0;1712 cdir->fdir =opendir(path->len ? path->buf :".");1713if(dir->untracked)1714 dir->untracked->dir_opened++;1715if(!cdir->fdir)1716return-1;1717return0;1718}17191720static intread_cached_dir(struct cached_dir *cdir)1721{1722if(cdir->fdir) {1723 cdir->de =readdir(cdir->fdir);1724if(!cdir->de)1725return-1;1726return0;1727}1728while(cdir->nr_dirs < cdir->untracked->dirs_nr) {1729struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1730if(!d->recurse) {1731 cdir->nr_dirs++;1732continue;1733}1734 cdir->ucd = d;1735 cdir->nr_dirs++;1736return0;1737}1738 cdir->ucd = NULL;1739if(cdir->nr_files < cdir->untracked->untracked_nr) {1740struct untracked_cache_dir *d = cdir->untracked;1741 cdir->file = d->untracked[cdir->nr_files++];1742return0;1743}1744return-1;1745}17461747static voidclose_cached_dir(struct cached_dir *cdir)1748{1749if(cdir->fdir)1750closedir(cdir->fdir);1751/*1752 * We have gone through this directory and found no untracked1753 * entries. Mark it valid.1754 */1755if(cdir->untracked) {1756 cdir->untracked->valid =1;1757 cdir->untracked->recurse =1;1758}1759}17601761/*1762 * Read a directory tree. We currently ignore anything but1763 * directories, regular files and symlinks. That's because git1764 * doesn't handle them at all yet. Maybe that will change some1765 * day.1766 *1767 * Also, we ignore the name ".git" (even if it is not a directory).1768 * That likely will not change.1769 *1770 * Returns the most significant path_treatment value encountered in the scan.1771 */1772static enum path_treatment read_directory_recursive(struct dir_struct *dir,1773const char*base,int baselen,1774struct untracked_cache_dir *untracked,int check_only,1775const struct pathspec *pathspec)1776{1777struct cached_dir cdir;1778enum path_treatment state, subdir_state, dir_state = path_none;1779struct strbuf path = STRBUF_INIT;17801781strbuf_add(&path, base, baselen);17821783if(open_cached_dir(&cdir, dir, untracked, &path, check_only))1784goto out;17851786if(untracked)1787 untracked->check_only = !!check_only;17881789while(!read_cached_dir(&cdir)) {1790/* check how the file or directory should be treated */1791 state =treat_path(dir, untracked, &cdir, &path,1792 baselen, pathspec);17931794if(state > dir_state)1795 dir_state = state;17961797/* recurse into subdir if instructed by treat_path */1798if(state == path_recurse) {1799struct untracked_cache_dir *ud;1800 ud =lookup_untracked(dir->untracked, untracked,1801 path.buf + baselen,1802 path.len - baselen);1803 subdir_state =1804read_directory_recursive(dir, path.buf,1805 path.len, ud,1806 check_only, pathspec);1807if(subdir_state > dir_state)1808 dir_state = subdir_state;1809}18101811if(check_only) {1812/* abort early if maximum state has been reached */1813if(dir_state == path_untracked) {1814if(cdir.fdir)1815add_untracked(untracked, path.buf + baselen);1816break;1817}1818/* skip the dir_add_* part */1819continue;1820}18211822/* add the path to the appropriate result list */1823switch(state) {1824case path_excluded:1825if(dir->flags & DIR_SHOW_IGNORED)1826dir_add_name(dir, &the_index, path.buf, path.len);1827else if((dir->flags & DIR_SHOW_IGNORED_TOO) ||1828((dir->flags & DIR_COLLECT_IGNORED) &&1829exclude_matches_pathspec(path.buf, path.len,1830 pathspec)))1831dir_add_ignored(dir, &the_index, path.buf, path.len);1832break;18331834case path_untracked:1835if(dir->flags & DIR_SHOW_IGNORED)1836break;1837dir_add_name(dir, &the_index, path.buf, path.len);1838if(cdir.fdir)1839add_untracked(untracked, path.buf + baselen);1840break;18411842default:1843break;1844}1845}1846close_cached_dir(&cdir);1847 out:1848strbuf_release(&path);18491850return dir_state;1851}18521853static intcmp_name(const void*p1,const void*p2)1854{1855const struct dir_entry *e1 = *(const struct dir_entry **)p1;1856const struct dir_entry *e2 = *(const struct dir_entry **)p2;18571858returnname_compare(e1->name, e1->len, e2->name, e2->len);1859}18601861static inttreat_leading_path(struct dir_struct *dir,1862const char*path,int len,1863const struct pathspec *pathspec)1864{1865struct strbuf sb = STRBUF_INIT;1866int baselen, rc =0;1867const char*cp;1868int old_flags = dir->flags;18691870while(len && path[len -1] =='/')1871 len--;1872if(!len)1873return1;1874 baselen =0;1875 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1876while(1) {1877 cp = path + baselen + !!baselen;1878 cp =memchr(cp,'/', path + len - cp);1879if(!cp)1880 baselen = len;1881else1882 baselen = cp - path;1883strbuf_setlen(&sb,0);1884strbuf_add(&sb, path, baselen);1885if(!is_directory(sb.buf))1886break;1887if(simplify_away(sb.buf, sb.len, pathspec))1888break;1889if(treat_one_path(dir, NULL, &sb, baselen, pathspec,1890 DT_DIR, NULL) == path_none)1891break;/* do not recurse into it */1892if(len <= baselen) {1893 rc =1;1894break;/* finished checking */1895}1896}1897strbuf_release(&sb);1898 dir->flags = old_flags;1899return rc;1900}19011902static const char*get_ident_string(void)1903{1904static struct strbuf sb = STRBUF_INIT;1905struct utsname uts;19061907if(sb.len)1908return sb.buf;1909if(uname(&uts) <0)1910die_errno(_("failed to get kernel name and information"));1911strbuf_addf(&sb,"Location%s, system%s",get_git_work_tree(),1912 uts.sysname);1913return sb.buf;1914}19151916static intident_in_untracked(const struct untracked_cache *uc)1917{1918/*1919 * Previous git versions may have saved many NUL separated1920 * strings in the "ident" field, but it is insane to manage1921 * many locations, so just take care of the first one.1922 */19231924return!strcmp(uc->ident.buf,get_ident_string());1925}19261927static voidset_untracked_ident(struct untracked_cache *uc)1928{1929strbuf_reset(&uc->ident);1930strbuf_addstr(&uc->ident,get_ident_string());19311932/*1933 * This strbuf used to contain a list of NUL separated1934 * strings, so save NUL too for backward compatibility.1935 */1936strbuf_addch(&uc->ident,0);1937}19381939static voidnew_untracked_cache(struct index_state *istate)1940{1941struct untracked_cache *uc =xcalloc(1,sizeof(*uc));1942strbuf_init(&uc->ident,100);1943 uc->exclude_per_dir =".gitignore";1944/* should be the same flags used by git-status */1945 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;1946set_untracked_ident(uc);1947 istate->untracked = uc;1948 istate->cache_changed |= UNTRACKED_CHANGED;1949}19501951voidadd_untracked_cache(struct index_state *istate)1952{1953if(!istate->untracked) {1954new_untracked_cache(istate);1955}else{1956if(!ident_in_untracked(istate->untracked)) {1957free_untracked_cache(istate->untracked);1958new_untracked_cache(istate);1959}1960}1961}19621963voidremove_untracked_cache(struct index_state *istate)1964{1965if(istate->untracked) {1966free_untracked_cache(istate->untracked);1967 istate->untracked = NULL;1968 istate->cache_changed |= UNTRACKED_CHANGED;1969}1970}19711972static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,1973int base_len,1974const struct pathspec *pathspec)1975{1976struct untracked_cache_dir *root;19771978if(!dir->untracked ||getenv("GIT_DISABLE_UNTRACKED_CACHE"))1979return NULL;19801981/*1982 * We only support $GIT_DIR/info/exclude and core.excludesfile1983 * as the global ignore rule files. Any other additions1984 * (e.g. from command line) invalidate the cache. This1985 * condition also catches running setup_standard_excludes()1986 * before setting dir->untracked!1987 */1988if(dir->unmanaged_exclude_files)1989return NULL;19901991/*1992 * Optimize for the main use case only: whole-tree git1993 * status. More work involved in treat_leading_path() if we1994 * use cache on just a subset of the worktree. pathspec1995 * support could make the matter even worse.1996 */1997if(base_len || (pathspec && pathspec->nr))1998return NULL;19992000/* Different set of flags may produce different results */2001if(dir->flags != dir->untracked->dir_flags ||2002/*2003 * See treat_directory(), case index_nonexistent. Without2004 * this flag, we may need to also cache .git file content2005 * for the resolve_gitlink_ref() call, which we don't.2006 */2007!(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2008/* We don't support collecting ignore files */2009(dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2010 DIR_COLLECT_IGNORED)))2011return NULL;20122013/*2014 * If we use .gitignore in the cache and now you change it to2015 * .gitexclude, everything will go wrong.2016 */2017if(dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2018strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2019return NULL;20202021/*2022 * EXC_CMDL is not considered in the cache. If people set it,2023 * skip the cache.2024 */2025if(dir->exclude_list_group[EXC_CMDL].nr)2026return NULL;20272028if(!ident_in_untracked(dir->untracked)) {2029warning(_("Untracked cache is disabled on this system or location."));2030return NULL;2031}20322033if(!dir->untracked->root) {2034const int len =sizeof(*dir->untracked->root);2035 dir->untracked->root =xmalloc(len);2036memset(dir->untracked->root,0, len);2037}20382039/* Validate $GIT_DIR/info/exclude and core.excludesfile */2040 root = dir->untracked->root;2041if(hashcmp(dir->ss_info_exclude.sha1,2042 dir->untracked->ss_info_exclude.sha1)) {2043invalidate_gitignore(dir->untracked, root);2044 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2045}2046if(hashcmp(dir->ss_excludes_file.sha1,2047 dir->untracked->ss_excludes_file.sha1)) {2048invalidate_gitignore(dir->untracked, root);2049 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2050}20512052/* Make sure this directory is not dropped out at saving phase */2053 root->recurse =1;2054return root;2055}20562057intread_directory(struct dir_struct *dir,const char*path,2058int len,const struct pathspec *pathspec)2059{2060struct untracked_cache_dir *untracked;20612062if(has_symlink_leading_path(path, len))2063return dir->nr;20642065 untracked =validate_untracked_cache(dir, len, pathspec);2066if(!untracked)2067/*2068 * make sure untracked cache code path is disabled,2069 * e.g. prep_exclude()2070 */2071 dir->untracked = NULL;2072if(!len ||treat_leading_path(dir, path, len, pathspec))2073read_directory_recursive(dir, path, len, untracked,0, pathspec);2074QSORT(dir->entries, dir->nr, cmp_name);2075QSORT(dir->ignored, dir->ignored_nr, cmp_name);2076if(dir->untracked) {2077static struct trace_key trace_untracked_stats =TRACE_KEY_INIT(UNTRACKED_STATS);2078trace_printf_key(&trace_untracked_stats,2079"node creation:%u\n"2080"gitignore invalidation:%u\n"2081"directory invalidation:%u\n"2082"opendir:%u\n",2083 dir->untracked->dir_created,2084 dir->untracked->gitignore_invalidated,2085 dir->untracked->dir_invalidated,2086 dir->untracked->dir_opened);2087if(dir->untracked == the_index.untracked &&2088(dir->untracked->dir_opened ||2089 dir->untracked->gitignore_invalidated ||2090 dir->untracked->dir_invalidated))2091 the_index.cache_changed |= UNTRACKED_CHANGED;2092if(dir->untracked != the_index.untracked) {2093free(dir->untracked);2094 dir->untracked = NULL;2095}2096}2097return dir->nr;2098}20992100intfile_exists(const char*f)2101{2102struct stat sb;2103returnlstat(f, &sb) ==0;2104}21052106static intcmp_icase(char a,char b)2107{2108if(a == b)2109return0;2110if(ignore_case)2111returntoupper(a) -toupper(b);2112return a - b;2113}21142115/*2116 * Given two normalized paths (a trailing slash is ok), if subdir is2117 * outside dir, return -1. Otherwise return the offset in subdir that2118 * can be used as relative path to dir.2119 */2120intdir_inside_of(const char*subdir,const char*dir)2121{2122int offset =0;21232124assert(dir && subdir && *dir && *subdir);21252126while(*dir && *subdir && !cmp_icase(*dir, *subdir)) {2127 dir++;2128 subdir++;2129 offset++;2130}21312132/* hel[p]/me vs hel[l]/yeah */2133if(*dir && *subdir)2134return-1;21352136if(!*subdir)2137return!*dir ? offset : -1;/* same dir */21382139/* foo/[b]ar vs foo/[] */2140if(is_dir_sep(dir[-1]))2141returnis_dir_sep(subdir[-1]) ? offset : -1;21422143/* foo[/]bar vs foo[] */2144returnis_dir_sep(*subdir) ? offset +1: -1;2145}21462147intis_inside_dir(const char*dir)2148{2149char*cwd;2150int rc;21512152if(!dir)2153return0;21542155 cwd =xgetcwd();2156 rc = (dir_inside_of(cwd, dir) >=0);2157free(cwd);2158return rc;2159}21602161intis_empty_dir(const char*path)2162{2163DIR*dir =opendir(path);2164struct dirent *e;2165int ret =1;21662167if(!dir)2168return0;21692170while((e =readdir(dir)) != NULL)2171if(!is_dot_or_dotdot(e->d_name)) {2172 ret =0;2173break;2174}21752176closedir(dir);2177return ret;2178}21792180static intremove_dir_recurse(struct strbuf *path,int flag,int*kept_up)2181{2182DIR*dir;2183struct dirent *e;2184int ret =0, original_len = path->len, len, kept_down =0;2185int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2186int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2187unsigned char submodule_head[20];21882189if((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2190!resolve_gitlink_ref(path->buf,"HEAD", submodule_head)) {2191/* Do not descend and nuke a nested git work tree. */2192if(kept_up)2193*kept_up =1;2194return0;2195}21962197 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2198 dir =opendir(path->buf);2199if(!dir) {2200if(errno == ENOENT)2201return keep_toplevel ? -1:0;2202else if(errno == EACCES && !keep_toplevel)2203/*2204 * An empty dir could be removable even if it2205 * is unreadable:2206 */2207returnrmdir(path->buf);2208else2209return-1;2210}2211strbuf_complete(path,'/');22122213 len = path->len;2214while((e =readdir(dir)) != NULL) {2215struct stat st;2216if(is_dot_or_dotdot(e->d_name))2217continue;22182219strbuf_setlen(path, len);2220strbuf_addstr(path, e->d_name);2221if(lstat(path->buf, &st)) {2222if(errno == ENOENT)2223/*2224 * file disappeared, which is what we2225 * wanted anyway2226 */2227continue;2228/* fall thru */2229}else if(S_ISDIR(st.st_mode)) {2230if(!remove_dir_recurse(path, flag, &kept_down))2231continue;/* happy */2232}else if(!only_empty &&2233(!unlink(path->buf) || errno == ENOENT)) {2234continue;/* happy, too */2235}22362237/* path too long, stat fails, or non-directory still exists */2238 ret = -1;2239break;2240}2241closedir(dir);22422243strbuf_setlen(path, original_len);2244if(!ret && !keep_toplevel && !kept_down)2245 ret = (!rmdir(path->buf) || errno == ENOENT) ?0: -1;2246else if(kept_up)2247/*2248 * report the uplevel that it is not an error that we2249 * did not rmdir() our directory.2250 */2251*kept_up = !ret;2252return ret;2253}22542255intremove_dir_recursively(struct strbuf *path,int flag)2256{2257returnremove_dir_recurse(path, flag, NULL);2258}22592260staticGIT_PATH_FUNC(git_path_info_exclude,"info/exclude")22612262voidsetup_standard_excludes(struct dir_struct *dir)2263{2264 dir->exclude_per_dir =".gitignore";22652266/* core.excludefile defaulting to $XDG_HOME/git/ignore */2267if(!excludes_file)2268 excludes_file =xdg_config_home("ignore");2269if(excludes_file && !access_or_warn(excludes_file, R_OK,0))2270add_excludes_from_file_1(dir, excludes_file,2271 dir->untracked ? &dir->ss_excludes_file : NULL);22722273/* per repository user preference */2274if(startup_info->have_repository) {2275const char*path =git_path_info_exclude();2276if(!access_or_warn(path, R_OK,0))2277add_excludes_from_file_1(dir, path,2278 dir->untracked ? &dir->ss_info_exclude : NULL);2279}2280}22812282intremove_path(const char*name)2283{2284char*slash;22852286if(unlink(name) && errno != ENOENT && errno != ENOTDIR)2287return-1;22882289 slash =strrchr(name,'/');2290if(slash) {2291char*dirs =xstrdup(name);2292 slash = dirs + (slash - name);2293do{2294*slash ='\0';2295}while(rmdir(dirs) ==0&& (slash =strrchr(dirs,'/')));2296free(dirs);2297}2298return0;2299}23002301/*2302 * Frees memory within dir which was allocated for exclude lists and2303 * the exclude_stack. Does not free dir itself.2304 */2305voidclear_directory(struct dir_struct *dir)2306{2307int i, j;2308struct exclude_list_group *group;2309struct exclude_list *el;2310struct exclude_stack *stk;23112312for(i = EXC_CMDL; i <= EXC_FILE; i++) {2313 group = &dir->exclude_list_group[i];2314for(j =0; j < group->nr; j++) {2315 el = &group->el[j];2316if(i == EXC_DIRS)2317free((char*)el->src);2318clear_exclude_list(el);2319}2320free(group->el);2321}23222323 stk = dir->exclude_stack;2324while(stk) {2325struct exclude_stack *prev = stk->prev;2326free(stk);2327 stk = prev;2328}2329strbuf_release(&dir->basebuf);2330}23312332struct ondisk_untracked_cache {2333struct stat_data info_exclude_stat;2334struct stat_data excludes_file_stat;2335uint32_t dir_flags;2336unsigned char info_exclude_sha1[20];2337unsigned char excludes_file_sha1[20];2338char exclude_per_dir[FLEX_ARRAY];2339};23402341#define ouc_size(len) (offsetof(struct ondisk_untracked_cache, exclude_per_dir) + len + 1)23422343struct write_data {2344int index;/* number of written untracked_cache_dir */2345struct ewah_bitmap *check_only;/* from untracked_cache_dir */2346struct ewah_bitmap *valid;/* from untracked_cache_dir */2347struct ewah_bitmap *sha1_valid;/* set if exclude_sha1 is not null */2348struct strbuf out;2349struct strbuf sb_stat;2350struct strbuf sb_sha1;2351};23522353static voidstat_data_to_disk(struct stat_data *to,const struct stat_data *from)2354{2355 to->sd_ctime.sec =htonl(from->sd_ctime.sec);2356 to->sd_ctime.nsec =htonl(from->sd_ctime.nsec);2357 to->sd_mtime.sec =htonl(from->sd_mtime.sec);2358 to->sd_mtime.nsec =htonl(from->sd_mtime.nsec);2359 to->sd_dev =htonl(from->sd_dev);2360 to->sd_ino =htonl(from->sd_ino);2361 to->sd_uid =htonl(from->sd_uid);2362 to->sd_gid =htonl(from->sd_gid);2363 to->sd_size =htonl(from->sd_size);2364}23652366static voidwrite_one_dir(struct untracked_cache_dir *untracked,2367struct write_data *wd)2368{2369struct stat_data stat_data;2370struct strbuf *out = &wd->out;2371unsigned char intbuf[16];2372unsigned int intlen, value;2373int i = wd->index++;23742375/*2376 * untracked_nr should be reset whenever valid is clear, but2377 * for safety..2378 */2379if(!untracked->valid) {2380 untracked->untracked_nr =0;2381 untracked->check_only =0;2382}23832384if(untracked->check_only)2385ewah_set(wd->check_only, i);2386if(untracked->valid) {2387ewah_set(wd->valid, i);2388stat_data_to_disk(&stat_data, &untracked->stat_data);2389strbuf_add(&wd->sb_stat, &stat_data,sizeof(stat_data));2390}2391if(!is_null_sha1(untracked->exclude_sha1)) {2392ewah_set(wd->sha1_valid, i);2393strbuf_add(&wd->sb_sha1, untracked->exclude_sha1,20);2394}23952396 intlen =encode_varint(untracked->untracked_nr, intbuf);2397strbuf_add(out, intbuf, intlen);23982399/* skip non-recurse directories */2400for(i =0, value =0; i < untracked->dirs_nr; i++)2401if(untracked->dirs[i]->recurse)2402 value++;2403 intlen =encode_varint(value, intbuf);2404strbuf_add(out, intbuf, intlen);24052406strbuf_add(out, untracked->name,strlen(untracked->name) +1);24072408for(i =0; i < untracked->untracked_nr; i++)2409strbuf_add(out, untracked->untracked[i],2410strlen(untracked->untracked[i]) +1);24112412for(i =0; i < untracked->dirs_nr; i++)2413if(untracked->dirs[i]->recurse)2414write_one_dir(untracked->dirs[i], wd);2415}24162417voidwrite_untracked_extension(struct strbuf *out,struct untracked_cache *untracked)2418{2419struct ondisk_untracked_cache *ouc;2420struct write_data wd;2421unsigned char varbuf[16];2422int varint_len;2423size_t len =strlen(untracked->exclude_per_dir);24242425FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2426stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2427stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2428hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);2429hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.sha1);2430 ouc->dir_flags =htonl(untracked->dir_flags);24312432 varint_len =encode_varint(untracked->ident.len, varbuf);2433strbuf_add(out, varbuf, varint_len);2434strbuf_addbuf(out, &untracked->ident);24352436strbuf_add(out, ouc,ouc_size(len));2437free(ouc);2438 ouc = NULL;24392440if(!untracked->root) {2441 varint_len =encode_varint(0, varbuf);2442strbuf_add(out, varbuf, varint_len);2443return;2444}24452446 wd.index =0;2447 wd.check_only =ewah_new();2448 wd.valid =ewah_new();2449 wd.sha1_valid =ewah_new();2450strbuf_init(&wd.out,1024);2451strbuf_init(&wd.sb_stat,1024);2452strbuf_init(&wd.sb_sha1,1024);2453write_one_dir(untracked->root, &wd);24542455 varint_len =encode_varint(wd.index, varbuf);2456strbuf_add(out, varbuf, varint_len);2457strbuf_addbuf(out, &wd.out);2458ewah_serialize_strbuf(wd.valid, out);2459ewah_serialize_strbuf(wd.check_only, out);2460ewah_serialize_strbuf(wd.sha1_valid, out);2461strbuf_addbuf(out, &wd.sb_stat);2462strbuf_addbuf(out, &wd.sb_sha1);2463strbuf_addch(out,'\0');/* safe guard for string lists */24642465ewah_free(wd.valid);2466ewah_free(wd.check_only);2467ewah_free(wd.sha1_valid);2468strbuf_release(&wd.out);2469strbuf_release(&wd.sb_stat);2470strbuf_release(&wd.sb_sha1);2471}24722473static voidfree_untracked(struct untracked_cache_dir *ucd)2474{2475int i;2476if(!ucd)2477return;2478for(i =0; i < ucd->dirs_nr; i++)2479free_untracked(ucd->dirs[i]);2480for(i =0; i < ucd->untracked_nr; i++)2481free(ucd->untracked[i]);2482free(ucd->untracked);2483free(ucd->dirs);2484free(ucd);2485}24862487voidfree_untracked_cache(struct untracked_cache *uc)2488{2489if(uc)2490free_untracked(uc->root);2491free(uc);2492}24932494struct read_data {2495int index;2496struct untracked_cache_dir **ucd;2497struct ewah_bitmap *check_only;2498struct ewah_bitmap *valid;2499struct ewah_bitmap *sha1_valid;2500const unsigned char*data;2501const unsigned char*end;2502};25032504static voidstat_data_from_disk(struct stat_data *to,const struct stat_data *from)2505{2506 to->sd_ctime.sec =get_be32(&from->sd_ctime.sec);2507 to->sd_ctime.nsec =get_be32(&from->sd_ctime.nsec);2508 to->sd_mtime.sec =get_be32(&from->sd_mtime.sec);2509 to->sd_mtime.nsec =get_be32(&from->sd_mtime.nsec);2510 to->sd_dev =get_be32(&from->sd_dev);2511 to->sd_ino =get_be32(&from->sd_ino);2512 to->sd_uid =get_be32(&from->sd_uid);2513 to->sd_gid =get_be32(&from->sd_gid);2514 to->sd_size =get_be32(&from->sd_size);2515}25162517static intread_one_dir(struct untracked_cache_dir **untracked_,2518struct read_data *rd)2519{2520struct untracked_cache_dir ud, *untracked;2521const unsigned char*next, *data = rd->data, *end = rd->end;2522unsigned int value;2523int i, len;25242525memset(&ud,0,sizeof(ud));25262527 next = data;2528 value =decode_varint(&next);2529if(next > end)2530return-1;2531 ud.recurse =1;2532 ud.untracked_alloc = value;2533 ud.untracked_nr = value;2534if(ud.untracked_nr)2535ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2536 data = next;25372538 next = data;2539 ud.dirs_alloc = ud.dirs_nr =decode_varint(&next);2540if(next > end)2541return-1;2542ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2543 data = next;25442545 len =strlen((const char*)data);2546 next = data + len +1;2547if(next > rd->end)2548return-1;2549*untracked_ = untracked =xmalloc(st_add(sizeof(*untracked), len));2550memcpy(untracked, &ud,sizeof(ud));2551memcpy(untracked->name, data, len +1);2552 data = next;25532554for(i =0; i < untracked->untracked_nr; i++) {2555 len =strlen((const char*)data);2556 next = data + len +1;2557if(next > rd->end)2558return-1;2559 untracked->untracked[i] =xstrdup((const char*)data);2560 data = next;2561}25622563 rd->ucd[rd->index++] = untracked;2564 rd->data = data;25652566for(i =0; i < untracked->dirs_nr; i++) {2567 len =read_one_dir(untracked->dirs + i, rd);2568if(len <0)2569return-1;2570}2571return0;2572}25732574static voidset_check_only(size_t pos,void*cb)2575{2576struct read_data *rd = cb;2577struct untracked_cache_dir *ud = rd->ucd[pos];2578 ud->check_only =1;2579}25802581static voidread_stat(size_t pos,void*cb)2582{2583struct read_data *rd = cb;2584struct untracked_cache_dir *ud = rd->ucd[pos];2585if(rd->data +sizeof(struct stat_data) > rd->end) {2586 rd->data = rd->end +1;2587return;2588}2589stat_data_from_disk(&ud->stat_data, (struct stat_data *)rd->data);2590 rd->data +=sizeof(struct stat_data);2591 ud->valid =1;2592}25932594static voidread_sha1(size_t pos,void*cb)2595{2596struct read_data *rd = cb;2597struct untracked_cache_dir *ud = rd->ucd[pos];2598if(rd->data +20> rd->end) {2599 rd->data = rd->end +1;2600return;2601}2602hashcpy(ud->exclude_sha1, rd->data);2603 rd->data +=20;2604}26052606static voidload_sha1_stat(struct sha1_stat *sha1_stat,2607const struct stat_data *stat,2608const unsigned char*sha1)2609{2610stat_data_from_disk(&sha1_stat->stat, stat);2611hashcpy(sha1_stat->sha1, sha1);2612 sha1_stat->valid =1;2613}26142615struct untracked_cache *read_untracked_extension(const void*data,unsigned long sz)2616{2617const struct ondisk_untracked_cache *ouc;2618struct untracked_cache *uc;2619struct read_data rd;2620const unsigned char*next = data, *end = (const unsigned char*)data + sz;2621const char*ident;2622int ident_len, len;26232624if(sz <=1|| end[-1] !='\0')2625return NULL;2626 end--;26272628 ident_len =decode_varint(&next);2629if(next + ident_len > end)2630return NULL;2631 ident = (const char*)next;2632 next += ident_len;26332634 ouc = (const struct ondisk_untracked_cache *)next;2635if(next +ouc_size(0) > end)2636return NULL;26372638 uc =xcalloc(1,sizeof(*uc));2639strbuf_init(&uc->ident, ident_len);2640strbuf_add(&uc->ident, ident, ident_len);2641load_sha1_stat(&uc->ss_info_exclude, &ouc->info_exclude_stat,2642 ouc->info_exclude_sha1);2643load_sha1_stat(&uc->ss_excludes_file, &ouc->excludes_file_stat,2644 ouc->excludes_file_sha1);2645 uc->dir_flags =get_be32(&ouc->dir_flags);2646 uc->exclude_per_dir =xstrdup(ouc->exclude_per_dir);2647/* NUL after exclude_per_dir is covered by sizeof(*ouc) */2648 next +=ouc_size(strlen(ouc->exclude_per_dir));2649if(next >= end)2650goto done2;26512652 len =decode_varint(&next);2653if(next > end || len ==0)2654goto done2;26552656 rd.valid =ewah_new();2657 rd.check_only =ewah_new();2658 rd.sha1_valid =ewah_new();2659 rd.data = next;2660 rd.end = end;2661 rd.index =0;2662ALLOC_ARRAY(rd.ucd, len);26632664if(read_one_dir(&uc->root, &rd) || rd.index != len)2665goto done;26662667 next = rd.data;2668 len =ewah_read_mmap(rd.valid, next, end - next);2669if(len <0)2670goto done;26712672 next += len;2673 len =ewah_read_mmap(rd.check_only, next, end - next);2674if(len <0)2675goto done;26762677 next += len;2678 len =ewah_read_mmap(rd.sha1_valid, next, end - next);2679if(len <0)2680goto done;26812682ewah_each_bit(rd.check_only, set_check_only, &rd);2683 rd.data = next + len;2684ewah_each_bit(rd.valid, read_stat, &rd);2685ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2686 next = rd.data;26872688done:2689free(rd.ucd);2690ewah_free(rd.valid);2691ewah_free(rd.check_only);2692ewah_free(rd.sha1_valid);2693done2:2694if(next != end) {2695free_untracked_cache(uc);2696 uc = NULL;2697}2698return uc;2699}27002701static voidinvalidate_one_directory(struct untracked_cache *uc,2702struct untracked_cache_dir *ucd)2703{2704 uc->dir_invalidated++;2705 ucd->valid =0;2706 ucd->untracked_nr =0;2707}27082709/*2710 * Normally when an entry is added or removed from a directory,2711 * invalidating that directory is enough. No need to touch its2712 * ancestors. When a directory is shown as "foo/bar/" in git-status2713 * however, deleting or adding an entry may have cascading effect.2714 *2715 * Say the "foo/bar/file" has become untracked, we need to tell the2716 * untracked_cache_dir of "foo" that "bar/" is not an untracked2717 * directory any more (because "bar" is managed by foo as an untracked2718 * "file").2719 *2720 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2721 * was the last untracked entry in the entire "foo", we should show2722 * "foo/" instead. Which means we have to invalidate past "bar" up to2723 * "foo".2724 *2725 * This function traverses all directories from root to leaf. If there2726 * is a chance of one of the above cases happening, we invalidate back2727 * to root. Otherwise we just invalidate the leaf. There may be a more2728 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2729 * detect these cases and avoid unnecessary invalidation, for example,2730 * checking for the untracked entry named "bar/" in "foo", but for now2731 * stick to something safe and simple.2732 */2733static intinvalidate_one_component(struct untracked_cache *uc,2734struct untracked_cache_dir *dir,2735const char*path,int len)2736{2737const char*rest =strchr(path,'/');27382739if(rest) {2740int component_len = rest - path;2741struct untracked_cache_dir *d =2742lookup_untracked(uc, dir, path, component_len);2743int ret =2744invalidate_one_component(uc, d, rest +1,2745 len - (component_len +1));2746if(ret)2747invalidate_one_directory(uc, dir);2748return ret;2749}27502751invalidate_one_directory(uc, dir);2752return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2753}27542755voiduntracked_cache_invalidate_path(struct index_state *istate,2756const char*path)2757{2758if(!istate->untracked || !istate->untracked->root)2759return;2760invalidate_one_component(istate->untracked, istate->untracked->root,2761 path,strlen(path));2762}27632764voiduntracked_cache_remove_from_index(struct index_state *istate,2765const char*path)2766{2767untracked_cache_invalidate_path(istate, path);2768}27692770voiduntracked_cache_add_to_index(struct index_state *istate,2771const char*path)2772{2773untracked_cache_invalidate_path(istate, path);2774}27752776/* Update gitfile and core.worktree setting to connect work tree and git dir */2777voidconnect_work_tree_and_git_dir(const char*work_tree_,const char*git_dir_)2778{2779struct strbuf gitfile_sb = STRBUF_INIT;2780struct strbuf cfg_sb = STRBUF_INIT;2781struct strbuf rel_path = STRBUF_INIT;2782char*git_dir, *work_tree;27832784/* Prepare .git file */2785strbuf_addf(&gitfile_sb,"%s/.git", work_tree_);2786if(safe_create_leading_directories_const(gitfile_sb.buf))2787die(_("could not create directories for%s"), gitfile_sb.buf);27882789/* Prepare config file */2790strbuf_addf(&cfg_sb,"%s/config", git_dir_);2791if(safe_create_leading_directories_const(cfg_sb.buf))2792die(_("could not create directories for%s"), cfg_sb.buf);27932794 git_dir =real_pathdup(git_dir_,1);2795 work_tree =real_pathdup(work_tree_,1);27962797/* Write .git file */2798write_file(gitfile_sb.buf,"gitdir:%s",2799relative_path(git_dir, work_tree, &rel_path));2800/* Update core.worktree setting */2801git_config_set_in_file(cfg_sb.buf,"core.worktree",2802relative_path(work_tree, git_dir, &rel_path));28032804strbuf_release(&gitfile_sb);2805strbuf_release(&cfg_sb);2806strbuf_release(&rel_path);2807free(work_tree);2808free(git_dir);2809}28102811/*2812 * Migrate the git directory of the given path from old_git_dir to new_git_dir.2813 */2814voidrelocate_gitdir(const char*path,const char*old_git_dir,const char*new_git_dir)2815{2816if(rename(old_git_dir, new_git_dir) <0)2817die_errno(_("could not migrate git directory from '%s' to '%s'"),2818 old_git_dir, new_git_dir);28192820connect_work_tree_and_git_dir(path, new_git_dir);2821}