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 { 38 DIR *fdir; 39 struct untracked_cache_dir *untracked; 40 int nr_files; 41 int nr_dirs; 42 43 struct dirent *de; 44 const char *file; 45 struct untracked_cache_dir *ucd; 46}; 47 48static enum path_treatment read_directory_recursive(struct dir_struct *dir, 49 struct index_state *istate, const char *path, int len, 50 struct untracked_cache_dir *untracked, 51 int check_only, const struct pathspec *pathspec); 52static int get_dtype(struct dirent *de, struct index_state *istate, 53 const char *path, int len); 54 55int fspathcmp(const char *a, const char *b) 56{ 57 return ignore_case ? strcasecmp(a, b) : strcmp(a, b); 58} 59 60int fspathncmp(const char *a, const char *b, size_t count) 61{ 62 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count); 63} 64 65int git_fnmatch(const struct pathspec_item *item, 66 const char *pattern, const char *string, 67 int prefix) 68{ 69 if (prefix > 0) { 70 if (ps_strncmp(item, pattern, string, prefix)) 71 return WM_NOMATCH; 72 pattern += prefix; 73 string += prefix; 74 } 75 if (item->flags & PATHSPEC_ONESTAR) { 76 int pattern_len = strlen(++pattern); 77 int string_len = strlen(string); 78 return string_len < pattern_len || 79 ps_strcmp(item, pattern, 80 string + string_len - pattern_len); 81 } 82 if (item->magic & PATHSPEC_GLOB) 83 return wildmatch(pattern, string, 84 WM_PATHNAME | 85 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0), 86 NULL); 87 else 88 /* wildmatch has not learned no FNM_PATHNAME mode yet */ 89 return wildmatch(pattern, string, 90 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0, 91 NULL); 92} 93 94static int fnmatch_icase_mem(const char *pattern, int patternlen, 95 const char *string, int stringlen, 96 int flags) 97{ 98 int match_status; 99 struct strbuf pat_buf = STRBUF_INIT; 100 struct strbuf str_buf = STRBUF_INIT; 101 const char *use_pat = pattern; 102 const char *use_str = string; 103 104 if (pattern[patternlen]) { 105 strbuf_add(&pat_buf, pattern, patternlen); 106 use_pat = pat_buf.buf; 107 } 108 if (string[stringlen]) { 109 strbuf_add(&str_buf, string, stringlen); 110 use_str = str_buf.buf; 111 } 112 113 if (ignore_case) 114 flags |= WM_CASEFOLD; 115 match_status = wildmatch(use_pat, use_str, flags, NULL); 116 117 strbuf_release(&pat_buf); 118 strbuf_release(&str_buf); 119 120 return match_status; 121} 122 123static size_t common_prefix_len(const struct pathspec *pathspec) 124{ 125 int n; 126 size_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 */ 135 GUARD_PATHSPEC(pathspec, 136 PATHSPEC_FROMTOP | 137 PATHSPEC_MAXDEPTH | 138 PATHSPEC_LITERAL | 139 PATHSPEC_GLOB | 140 PATHSPEC_ICASE | 141 PATHSPEC_EXCLUDE | 142 PATHSPEC_ATTR); 143 144 for (n = 0; n < pathspec->nr; n++) { 145 size_t i = 0, len = 0, item_len; 146 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE) 147 continue; 148 if (pathspec->items[n].magic & PATHSPEC_ICASE) 149 item_len = pathspec->items[n].prefix; 150 else 151 item_len = pathspec->items[n].nowildcard_len; 152 while (i < item_len && (n == 0 || i < max)) { 153 char c = pathspec->items[n].match[i]; 154 if (c != pathspec->items[0].match[i]) 155 break; 156 if (c == '/') 157 len = i + 1; 158 i++; 159 } 160 if (n == 0 || len < max) { 161 max = len; 162 if (!max) 163 break; 164 } 165 } 166 return 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{ 175 unsigned long len = common_prefix_len(pathspec); 176 177 return len ? xmemdupz(pathspec->items[0].match, len) : NULL; 178} 179 180int fill_directory(struct dir_struct *dir, const struct pathspec *pathspec) 181{ 182 const char *prefix; 183 size_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 */ 193 read_directory(dir, &the_index, prefix, prefix_len, pathspec); 194 195 return prefix_len; 196} 197 198int within_depth(const char *name, int namelen, 199 int depth, int max_depth) 200{ 201 const char *cp = name, *cpe = name + namelen; 202 203 while (cp < cpe) { 204 if (*cp++ != '/') 205 continue; 206 depth++; 207 if (depth > max_depth) 208 return 0; 209 } 210 return 1; 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 int match_attrs(const char *name, int namelen, 218 const struct pathspec_item *item) 219{ 220 int i; 221 222 git_check_attr(name, item->attr_check); 223 for (i = 0; i < item->attr_match_nr; i++) { 224 const char *value; 225 int matched; 226 enum attr_match_mode match_mode; 227 228 value = item->attr_check->items[i].value; 229 match_mode = item->attr_match[i].match_mode; 230 231 if (ATTR_TRUE(value)) 232 matched = (match_mode == MATCH_SET); 233 else if (ATTR_FALSE(value)) 234 matched = (match_mode == MATCH_UNSET); 235 else if (ATTR_UNSET(value)) 236 matched = (match_mode == MATCH_UNSPECIFIED); 237 else 238 matched = (match_mode == MATCH_VALUE && 239 !strcmp(item->attr_match[i].value, value)); 240 if (!matched) 241 return 0; 242 } 243 244 return 1; 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 int match_pathspec_item(const struct pathspec_item *item, int prefix, 260 const char *name, int namelen, unsigned flags) 261{ 262 /* name/namelen has prefix cut off by caller */ 263 const char *match = item->match + prefix; 264 int 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 */ 295 if (item->prefix && (item->magic & PATHSPEC_ICASE) && 296 strncmp(item->match, name - prefix, item->prefix)) 297 return 0; 298 299 if (item->attr_match_nr && !match_attrs(name, namelen, item)) 300 return 0; 301 302 /* If the match was just the prefix, we matched */ 303 if (!*match) 304 return MATCHED_RECURSIVELY; 305 306 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 307 if (matchlen == namelen) 308 return MATCHED_EXACTLY; 309 310 if (match[matchlen-1] == '/' || name[matchlen] == '/') 311 return MATCHED_RECURSIVELY; 312 } else if ((flags & DO_MATCH_DIRECTORY) && 313 match[matchlen - 1] == '/' && 314 namelen == matchlen - 1 && 315 !ps_strncmp(item, match, name, namelen)) 316 return MATCHED_EXACTLY; 317 318 if (item->nowildcard_len < item->len && 319 !git_fnmatch(item, match, name, 320 item->nowildcard_len - prefix)) 321 return MATCHED_FNMATCH; 322 323 /* Perform checks to see if "name" is a super set of the pathspec */ 324 if (flags & DO_MATCH_SUBMODULE) { 325 /* name is a literal prefix of the pathspec */ 326 if ((namelen < matchlen) && 327 (match[namelen] == '/') && 328 !ps_strncmp(item, match, name, namelen)) 329 return MATCHED_RECURSIVELY; 330 331 /* name" doesn't match up to the first wild character */ 332 if (item->nowildcard_len < item->len && 333 ps_strncmp(item, match, name, 334 item->nowildcard_len - prefix)) 335 return 0; 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 */ 346 return MATCHED_RECURSIVELY; 347 } 348 349 return 0; 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 int do_match_pathspec(const struct pathspec *ps, 368 const char *name, int namelen, 369 int prefix, char *seen, 370 unsigned flags) 371{ 372 int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE; 373 374 GUARD_PATHSPEC(ps, 375 PATHSPEC_FROMTOP | 376 PATHSPEC_MAXDEPTH | 377 PATHSPEC_LITERAL | 378 PATHSPEC_GLOB | 379 PATHSPEC_ICASE | 380 PATHSPEC_EXCLUDE | 381 PATHSPEC_ATTR); 382 383 if (!ps->nr) { 384 if (!ps->recursive || 385 !(ps->magic & PATHSPEC_MAXDEPTH) || 386 ps->max_depth == -1) 387 return MATCHED_RECURSIVELY; 388 389 if (within_depth(name, namelen, 0, ps->max_depth)) 390 return MATCHED_EXACTLY; 391 else 392 return 0; 393 } 394 395 name += prefix; 396 namelen -= prefix; 397 398 for (i = ps->nr - 1; i >= 0; i--) { 399 int how; 400 401 if ((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 402 ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 403 continue; 404 405 if (seen && seen[i] == MATCHED_EXACTLY) 406 continue; 407 /* 408 * Make exclude patterns optional and never report 409 * "pathspec ':(exclude)foo' matches no files" 410 */ 411 if (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); 415 if (ps->recursive && 416 (ps->magic & PATHSPEC_MAXDEPTH) && 417 ps->max_depth != -1 && 418 how && how != MATCHED_FNMATCH) { 419 int len = ps->items[i].len; 420 if (name[len] == '/') 421 len++; 422 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 423 how = MATCHED_EXACTLY; 424 else 425 how = 0; 426 } 427 if (how) { 428 if (retval < how) 429 retval = how; 430 if (seen && seen[i] < how) 431 seen[i] = how; 432 } 433 } 434 return retval; 435} 436 437int match_pathspec(const struct pathspec *ps, 438 const char *name, int namelen, 439 int prefix, char *seen, int is_dir) 440{ 441 int positive, negative; 442 unsigned flags = is_dir ? DO_MATCH_DIRECTORY : 0; 443 positive = do_match_pathspec(ps, name, namelen, 444 prefix, seen, flags); 445 if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 446 return positive; 447 negative = do_match_pathspec(ps, name, namelen, 448 prefix, seen, 449 flags | DO_MATCH_EXCLUDE); 450 return negative ? 0 : positive; 451} 452 453/** 454 * Check if a submodule is a superset of the pathspec 455 */ 456int submodule_path_match(const struct pathspec *ps, 457 const char *submodule_name, 458 char *seen) 459{ 460 int matched = do_match_pathspec(ps, submodule_name, 461 strlen(submodule_name), 462 0, seen, 463 DO_MATCH_DIRECTORY | 464 DO_MATCH_SUBMODULE); 465 return matched; 466} 467 468int report_path_error(const char *ps_matched, 469 const struct pathspec *pathspec, 470 const char *prefix) 471{ 472 /* 473 * Make sure all pathspec matched; otherwise it is an error. 474 */ 475 int num, errors = 0; 476 for (num = 0; num < pathspec->nr; num++) { 477 int other, found_dup; 478 479 if (ps_matched[num]) 480 continue; 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 */ 487 for (found_dup = other = 0; 488 !found_dup && other < pathspec->nr; 489 other++) { 490 if (other == num || !ps_matched[other]) 491 continue; 492 if (!strcmp(pathspec->items[other].original, 493 pathspec->items[num].original)) 494 /* 495 * Ok, we have a match already. 496 */ 497 found_dup = 1; 498 } 499 if (found_dup) 500 continue; 501 502 error("pathspec '%s' did not match any file(s) known to git.", 503 pathspec->items[num].original); 504 errors++; 505 } 506 return errors; 507} 508 509/* 510 * Return the length of the "simple" part of a path match limiter. 511 */ 512int simple_length(const char *match) 513{ 514 int len = -1; 515 516 for (;;) { 517 unsigned char c = *match++; 518 len++; 519 if (c == '\0' || is_glob_special(c)) 520 return len; 521 } 522} 523 524int no_wildcard(const char *string) 525{ 526 return string[simple_length(string)] == '\0'; 527} 528 529void parse_exclude_pattern(const char **pattern, 530 int *patternlen, 531 unsigned *flags, 532 int *nowildcardlen) 533{ 534 const char *p = *pattern; 535 size_t i, len; 536 537 *flags = 0; 538 if (*p == '!') { 539 *flags |= EXC_FLAG_NEGATIVE; 540 p++; 541 } 542 len = strlen(p); 543 if (len && p[len - 1] == '/') { 544 len--; 545 *flags |= EXC_FLAG_MUSTBEDIR; 546 } 547 for (i = 0; i < len; i++) { 548 if (p[i] == '/') 549 break; 550 } 551 if (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 */ 559 if (*nowildcardlen > len) 560 *nowildcardlen = len; 561 if (*p == '*' && no_wildcard(p + 1)) 562 *flags |= EXC_FLAG_ENDSWITH; 563 *pattern = p; 564 *patternlen = len; 565} 566 567void add_exclude(const char *string, const char *base, 568 int baselen, struct exclude_list *el, int srcpos) 569{ 570 struct exclude *x; 571 int patternlen; 572 unsigned flags; 573 int nowildcardlen; 574 575 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 576 if (flags & EXC_FLAG_MUSTBEDIR) { 577 FLEXPTR_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; 588 ALLOC_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, 594 const char *path, size_t *size, 595 struct sha1_stat *sha1_stat) 596{ 597 int pos, len; 598 unsigned long sz; 599 enum object_type type; 600 void *data; 601 602 len = strlen(path); 603 pos = index_name_pos(istate, path, len); 604 if (pos < 0) 605 return NULL; 606 if (!ce_skip_worktree(istate->cache[pos])) 607 return NULL; 608 data = read_sha1_file(istate->cache[pos]->oid.hash, &type, &sz); 609 if (!data || type != OBJ_BLOB) { 610 free(data); 611 return NULL; 612 } 613 *size = xsize_t(sz); 614 if (sha1_stat) { 615 memset(&sha1_stat->stat, 0, sizeof(sha1_stat->stat)); 616 hashcpy(sha1_stat->sha1, istate->cache[pos]->oid.hash); 617 } 618 return 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 */ 625void clear_exclude_list(struct exclude_list *el) 626{ 627 int i; 628 629 for (i = 0; i < el->nr; i++) 630 free(el->excludes[i]); 631 free(el->excludes); 632 free(el->filebuf); 633 634 memset(el, 0, sizeof(*el)); 635} 636 637static void trim_trailing_spaces(char *buf) 638{ 639 char *p, *last_space = NULL; 640 641 for (p = buf; *p; p++) 642 switch (*p) { 643 case ' ': 644 if (!last_space) 645 last_space = p; 646 break; 647 case '\\': 648 p++; 649 if (!*p) 650 return; 651 /* fallthrough */ 652 default: 653 last_space = NULL; 654 } 655 656 if (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, 668 struct untracked_cache_dir *dir, 669 const char *name, int len) 670{ 671 int first, last; 672 struct untracked_cache_dir *d; 673 if (!dir) 674 return NULL; 675 if (len && name[len - 1] == '/') 676 len--; 677 first = 0; 678 last = dir->dirs_nr; 679 while (last > first) { 680 int cmp, next = (last + first) >> 1; 681 d = dir->dirs[next]; 682 cmp = strncmp(name, d->name, len); 683 if (!cmp && strlen(d->name) > len) 684 cmp = -1; 685 if (!cmp) 686 return d; 687 if (cmp < 0) { 688 last = next; 689 continue; 690 } 691 first = next+1; 692 } 693 694 uc->dir_created++; 695 FLEX_ALLOC_MEM(d, name, name, len); 696 697 ALLOC_GROW(dir->dirs, dir->dirs_nr + 1, dir->dirs_alloc); 698 memmove(dir->dirs + first + 1, dir->dirs + first, 699 (dir->dirs_nr - first) * sizeof(*dir->dirs)); 700 dir->dirs_nr++; 701 dir->dirs[first] = d; 702 return d; 703} 704 705static void do_invalidate_gitignore(struct untracked_cache_dir *dir) 706{ 707 int i; 708 dir->valid = 0; 709 dir->untracked_nr = 0; 710 for (i = 0; i < dir->dirs_nr; i++) 711 do_invalidate_gitignore(dir->dirs[i]); 712} 713 714static void invalidate_gitignore(struct untracked_cache *uc, 715 struct untracked_cache_dir *dir) 716{ 717 uc->gitignore_invalidated++; 718 do_invalidate_gitignore(dir); 719} 720 721static void invalidate_directory(struct untracked_cache *uc, 722 struct untracked_cache_dir *dir) 723{ 724 int i; 725 uc->dir_invalidated++; 726 dir->valid = 0; 727 dir->untracked_nr = 0; 728 for (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 int add_excludes(const char *fname, const char *base, int baselen, 742 struct exclude_list *el, 743 struct index_state *istate, 744 struct sha1_stat *sha1_stat) 745{ 746 struct stat st; 747 int fd, i, lineno = 1; 748 size_t size = 0; 749 char *buf, *entry; 750 751 fd = open(fname, O_RDONLY); 752 if (fd < 0 || fstat(fd, &st) < 0) { 753 if (errno != ENOENT) 754 warn_on_inaccessible(fname); 755 if (0 <= fd) 756 close(fd); 757 if (!istate || 758 (buf = read_skip_worktree_file_from_index(istate, fname, &size, sha1_stat)) == NULL) 759 return -1; 760 if (size == 0) { 761 free(buf); 762 return 0; 763 } 764 if (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); 770 if (size == 0) { 771 if (sha1_stat) { 772 fill_stat_data(&sha1_stat->stat, &st); 773 hashcpy(sha1_stat->sha1, EMPTY_BLOB_SHA1_BIN); 774 sha1_stat->valid = 1; 775 } 776 close(fd); 777 return 0; 778 } 779 buf = xmallocz(size); 780 if (read_in_full(fd, buf, size) != size) { 781 free(buf); 782 close(fd); 783 return -1; 784 } 785 buf[size++] = '\n'; 786 close(fd); 787 if (sha1_stat) { 788 int pos; 789 if (sha1_stat->valid && 790 !match_stat_data_racy(istate, &sha1_stat->stat, &st)) 791 ; /* no content change, ss->sha1 still good */ 792 else if (istate && 793 (pos = index_name_pos(istate, fname, strlen(fname))) >= 0 && 794 !ce_stage(istate->cache[pos]) && 795 ce_uptodate(istate->cache[pos]) && 796 !would_convert_to_git(fname)) 797 hashcpy(sha1_stat->sha1, 798 istate->cache[pos]->oid.hash); 799 else 800 hash_sha1_file(buf, size, "blob", sha1_stat->sha1); 801 fill_stat_data(&sha1_stat->stat, &st); 802 sha1_stat->valid = 1; 803 } 804 } 805 806 el->filebuf = buf; 807 808 if (skip_utf8_bom(&buf, size)) 809 size -= buf - el->filebuf; 810 811 entry = buf; 812 813 for (i = 0; i < size; i++) { 814 if (buf[i] == '\n') { 815 if (entry != buf + i && entry[0] != '#') { 816 buf[i - (i && buf[i-1] == '\r')] = 0; 817 trim_trailing_spaces(entry); 818 add_exclude(entry, base, baselen, el, lineno); 819 } 820 lineno++; 821 entry = buf + i + 1; 822 } 823 } 824 return 0; 825} 826 827int add_excludes_from_file_to_list(const char *fname, const char *base, 828 int baselen, struct exclude_list *el, 829 struct index_state *istate) 830{ 831 return add_excludes(fname, base, baselen, el, istate, NULL); 832} 833 834struct exclude_list *add_exclude_list(struct dir_struct *dir, 835 int group_type, const char *src) 836{ 837 struct exclude_list *el; 838 struct exclude_list_group *group; 839 840 group = &dir->exclude_list_group[group_type]; 841 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 842 el = &group->el[group->nr++]; 843 memset(el, 0, sizeof(*el)); 844 el->src = src; 845 return el; 846} 847 848/* 849 * Used to set up core.excludesfile and .git/info/exclude lists. 850 */ 851static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname, 852 struct sha1_stat *sha1_stat) 853{ 854 struct 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 */ 860 if (!dir->untracked) 861 dir->unmanaged_exclude_files++; 862 el = add_exclude_list(dir, EXC_FILE, fname); 863 if (add_excludes(fname, "", 0, el, NULL, sha1_stat) < 0) 864 die("cannot use %s as an exclude file", fname); 865} 866 867void add_excludes_from_file(struct dir_struct *dir, const char *fname) 868{ 869 dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */ 870 add_excludes_from_file_1(dir, fname, NULL); 871} 872 873int match_basename(const char *basename, int basenamelen, 874 const char *pattern, int prefix, int patternlen, 875 unsigned flags) 876{ 877 if (prefix == patternlen) { 878 if (patternlen == basenamelen && 879 !fspathncmp(pattern, basename, basenamelen)) 880 return 1; 881 } else if (flags & EXC_FLAG_ENDSWITH) { 882 /* "*literal" matching against "fooliteral" */ 883 if (patternlen - 1 <= basenamelen && 884 !fspathncmp(pattern + 1, 885 basename + basenamelen - (patternlen - 1), 886 patternlen - 1)) 887 return 1; 888 } else { 889 if (fnmatch_icase_mem(pattern, patternlen, 890 basename, basenamelen, 891 0) == 0) 892 return 1; 893 } 894 return 0; 895} 896 897int match_pathname(const char *pathname, int pathlen, 898 const char *base, int baselen, 899 const char *pattern, int prefix, int patternlen, 900 unsigned flags) 901{ 902 const char *name; 903 int namelen; 904 905 /* 906 * match with FNM_PATHNAME; the pattern has base implicitly 907 * in front of it. 908 */ 909 if (*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 */ 919 if (pathlen < baselen + 1 || 920 (baselen && pathname[baselen] != '/') || 921 fspathncmp(pathname, base, baselen)) 922 return 0; 923 924 namelen = baselen ? pathlen - baselen - 1 : pathlen; 925 name = pathname + pathlen - namelen; 926 927 if (prefix) { 928 /* 929 * if the non-wildcard part is longer than the 930 * remaining pathname, surely it cannot match. 931 */ 932 if (prefix > namelen) 933 return 0; 934 935 if (fspathncmp(pattern, name, prefix)) 936 return 0; 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 */ 947 if (!patternlen && !namelen) 948 return 1; 949 } 950 951 return fnmatch_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, 963 int pathlen, 964 const char *basename, 965 int *dtype, 966 struct exclude_list *el, 967 struct index_state *istate) 968{ 969 struct exclude *exc = NULL; /* undecided */ 970 int i; 971 972 if (!el->nr) 973 return NULL; /* undefined */ 974 975 for (i = el->nr - 1; 0 <= i; i--) { 976 struct exclude *x = el->excludes[i]; 977 const char *exclude = x->pattern; 978 int prefix = x->nowildcardlen; 979 980 if (x->flags & EXC_FLAG_MUSTBEDIR) { 981 if (*dtype == DT_UNKNOWN) 982 *dtype = get_dtype(NULL, istate, pathname, pathlen); 983 if (*dtype != DT_DIR) 984 continue; 985 } 986 987 if (x->flags & EXC_FLAG_NODIR) { 988 if (match_basename(basename, 989 pathlen - (basename - pathname), 990 exclude, prefix, x->patternlen, 991 x->flags)) { 992 exc = x; 993 break; 994 } 995 continue; 996 } 997 998 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/'); 999 if (match_pathname(pathname, pathlen,1000 x->base, x->baselen ? x->baselen - 1 : 0,1001 exclude, prefix, x->patternlen, x->flags)) {1002 exc = x;1003 break;1004 }1005 }1006 return 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 */1013int is_excluded_from_list(const char *pathname,1014 int pathlen, const char *basename, int *dtype,1015 struct exclude_list *el, struct index_state *istate)1016{1017 struct exclude *exclude;1018 exclude = last_exclude_matching_from_list(pathname, pathlen, basename,1019 dtype, el, istate);1020 if (exclude)1021 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1022 return -1; /* undecided */1023}10241025static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1026 struct index_state *istate,1027 const char *pathname, int pathlen, const char *basename,1028 int *dtype_p)1029{1030 int i, j;1031 struct exclude_list_group *group;1032 struct exclude *exclude;1033 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1034 group = &dir->exclude_list_group[i];1035 for (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);1039 if (exclude)1040 return exclude;1041 }1042 }1043 return NULL;1044}10451046/*1047 * Loads the per-directory exclude list for the substring of base1048 * which has a char length of baselen.1049 */1050static void prep_exclude(struct dir_struct *dir,1051 struct index_state *istate,1052 const char *base, int baselen)1053{1054 struct exclude_list_group *group;1055 struct exclude_list *el;1056 struct exclude_stack *stk = NULL;1057 struct untracked_cache_dir *untracked;1058 int 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 */1067 while ((stk = dir->exclude_stack) != NULL) {1068 if (stk->baselen <= baselen &&1069 !strncmp(dir->basebuf.buf, base, stk->baselen))1070 break;1071 el = &group->el[dir->exclude_stack->exclude_ix];1072 dir->exclude_stack = stk->prev;1073 dir->exclude = NULL;1074 free((char *)el->src); /* see strbuf_detach() below */1075 clear_exclude_list(el);1076 free(stk);1077 group->nr--;1078 }10791080 /* Skip traversing into sub directories if the parent is excluded */1081 if (dir->exclude)1082 return;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 */1089 if (!dir->basebuf.buf)1090 strbuf_init(&dir->basebuf, PATH_MAX);10911092 /* Read from the parent directories and push them down. */1093 current = stk ? stk->baselen : -1;1094 strbuf_setlen(&dir->basebuf, current < 0 ? 0 : current);1095 if (dir->untracked)1096 untracked = stk ? stk->ucd : dir->untracked->root;1097 else1098 untracked = NULL;10991100 while (current < baselen) {1101 const char *cp;1102 struct sha1_stat sha1_stat;11031104 stk = xcalloc(1, sizeof(*stk));1105 if (current < 0) {1106 cp = base;1107 current = 0;1108 } else {1109 cp = strchr(base + current + 1, '/');1110 if (!cp)1111 die("oops in prep_exclude");1112 cp++;1113 untracked =1114 lookup_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);1123 strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1124 assert(stk->baselen == dir->basebuf.len);11251126 /* Abort if the directory is excluded */1127 if (stk->baselen) {1128 int 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] = '/';1135 if (dir->exclude &&1136 dir->exclude->flags & EXC_FLAG_NEGATIVE)1137 dir->exclude = NULL;1138 if (dir->exclude) {1139 dir->exclude_stack = stk;1140 return;1141 }1142 }11431144 /* Try to read per-directory file */1145 hashclr(sha1_stat.sha1);1146 sha1_stat.valid = 0;1147 if (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 */1169 struct strbuf sb = STRBUF_INIT;1170 strbuf_addbuf(&sb, &dir->basebuf);1171 strbuf_addstr(&sb, dir->exclude_per_dir);1172 el->src = strbuf_detach(&sb, NULL);1173 add_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 */1190 if (untracked &&1191 hashcmp(sha1_stat.sha1, untracked->exclude_sha1)) {1192 invalidate_gitignore(dir->untracked, untracked);1193 hashcpy(untracked->exclude_sha1, sha1_stat.sha1);1194 }1195 dir->exclude_stack = stk;1196 current = stk->baselen;1197 }1198 strbuf_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,1208 struct index_state *istate,1209 const char *pathname,1210 int *dtype_p)1211{1212 int pathlen = strlen(pathname);1213 const char *basename = strrchr(pathname, '/');1214 basename = (basename) ? basename+1 : pathname;12151216 prep_exclude(dir, istate, pathname, basename-pathname);12171218 if (dir->exclude)1219 return dir->exclude;12201221 return last_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 */1230int is_excluded(struct dir_struct *dir, struct index_state *istate,1231 const char *pathname, int *dtype_p)1232{1233 struct exclude *exclude =1234 last_exclude_matching(dir, istate, pathname, dtype_p);1235 if (exclude)1236 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1237 return 0;1238}12391240static struct dir_entry *dir_entry_new(const char *pathname, int len)1241{1242 struct dir_entry *ent;12431244 FLEX_ALLOC_MEM(ent, name, pathname, len);1245 ent->len = len;1246 return ent;1247}12481249static struct dir_entry *dir_add_name(struct dir_struct *dir,1250 struct index_state *istate,1251 const char *pathname, int len)1252{1253 if (index_file_exists(istate, pathname, len, ignore_case))1254 return NULL;12551256 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1257 return dir->entries[dir->nr++] = dir_entry_new(pathname, len);1258}12591260struct dir_entry *dir_add_ignored(struct dir_struct *dir,1261 struct index_state *istate,1262 const char *pathname, int len)1263{1264 if (!index_name_is_other(istate, pathname, len))1265 return NULL;12661267 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1268 return 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,1283 const char *dirname, int len)1284{1285 struct cache_entry *ce;12861287 if (index_dir_exists(istate, dirname, len))1288 return index_directory;12891290 ce = index_file_exists(istate, dirname, len, ignore_case);1291 if (ce && S_ISGITLINK(ce->ce_mode))1292 return index_gitdir;12931294 return 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,1305 const char *dirname, int len)1306{1307 int pos;13081309 if (ignore_case)1310 return directory_exists_in_index_icase(istate, dirname, len);13111312 pos = index_name_pos(istate, dirname, len);1313 if (pos < 0)1314 pos = -pos-1;1315 while (pos < istate->cache_nr) {1316 const struct cache_entry *ce = istate->cache[pos++];1317 unsigned char endchar;13181319 if (strncmp(ce->name, dirname, len))1320 break;1321 endchar = ce->name[len];1322 if (endchar > '/')1323 break;1324 if (endchar == '/')1325 return index_directory;1326 if (!endchar && S_ISGITLINK(ce->ce_mode))1327 return index_gitdir;1328 }1329 return 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,1366 struct index_state *istate,1367 struct untracked_cache_dir *untracked,1368 const char *dirname, int len, int baselen, int exclude,1369 const struct pathspec *pathspec)1370{1371 /* The "len-1" is to strip the final '/' */1372 switch (directory_exists_in_index(istate, dirname, len-1)) {1373 case index_directory:1374 return path_recurse;13751376 case index_gitdir:1377 return path_none;13781379 case index_nonexistent:1380 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1381 break;1382 if (!(dir->flags & DIR_NO_GITLINKS)) {1383 unsigned char sha1[20];1384 if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)1385 return path_untracked;1386 }1387 return path_recurse;1388 }13891390 /* This is the "show_other_directories" case */13911392 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1393 return exclude ? path_excluded : path_untracked;13941395 untracked = lookup_untracked(dir->untracked, untracked,1396 dirname + baselen, len - baselen);1397 return read_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 int simplify_away(const char *path, int pathlen,1407 const struct pathspec *pathspec)1408{1409 int i;14101411 if (!pathspec || !pathspec->nr)1412 return 0;14131414 GUARD_PATHSPEC(pathspec,1415 PATHSPEC_FROMTOP |1416 PATHSPEC_MAXDEPTH |1417 PATHSPEC_LITERAL |1418 PATHSPEC_GLOB |1419 PATHSPEC_ICASE |1420 PATHSPEC_EXCLUDE |1421 PATHSPEC_ATTR);14221423 for (i = 0; i < pathspec->nr; i++) {1424 const struct pathspec_item *item = &pathspec->items[i];1425 int len = item->nowildcard_len;14261427 if (len > pathlen)1428 len = pathlen;1429 if (!ps_strncmp(item, item->match, path, len))1430 return 0;1431 }14321433 return 1;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 int exclude_matches_pathspec(const char *path, int pathlen,1448 const struct pathspec *pathspec)1449{1450 int i;14511452 if (!pathspec || !pathspec->nr)1453 return 0;14541455 GUARD_PATHSPEC(pathspec,1456 PATHSPEC_FROMTOP |1457 PATHSPEC_MAXDEPTH |1458 PATHSPEC_LITERAL |1459 PATHSPEC_GLOB |1460 PATHSPEC_ICASE |1461 PATHSPEC_EXCLUDE);14621463 for (i = 0; i < pathspec->nr; i++) {1464 const struct pathspec_item *item = &pathspec->items[i];1465 int len = item->nowildcard_len;14661467 if (len == pathlen &&1468 !ps_strncmp(item, item->match, path, pathlen))1469 return 1;1470 if (len > pathlen &&1471 item->match[pathlen] == '/' &&1472 !ps_strncmp(item, item->match, path, pathlen))1473 return 1;1474 }1475 return 0;1476}14771478static int get_index_dtype(struct index_state *istate,1479 const char *path, int len)1480{1481 int pos;1482 const struct cache_entry *ce;14831484 ce = index_file_exists(istate, path, len, 0);1485 if (ce) {1486 if (!ce_uptodate(ce))1487 return DT_UNKNOWN;1488 if (S_ISGITLINK(ce->ce_mode))1489 return DT_DIR;1490 /*1491 * Nobody actually cares about the1492 * difference between DT_LNK and DT_REG1493 */1494 return DT_REG;1495 }14961497 /* Try to look it up as a directory */1498 pos = index_name_pos(istate, path, len);1499 if (pos >= 0)1500 return DT_UNKNOWN;1501 pos = -pos-1;1502 while (pos < istate->cache_nr) {1503 ce = istate->cache[pos++];1504 if (strncmp(ce->name, path, len))1505 break;1506 if (ce->name[len] > '/')1507 break;1508 if (ce->name[len] < '/')1509 continue;1510 if (!ce_uptodate(ce))1511 break; /* continue? */1512 return DT_DIR;1513 }1514 return DT_UNKNOWN;1515}15161517static int get_dtype(struct dirent *de, struct index_state *istate,1518 const char *path, int len)1519{1520 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1521 struct stat st;15221523 if (dtype != DT_UNKNOWN)1524 return dtype;1525 dtype = get_index_dtype(istate, path, len);1526 if (dtype != DT_UNKNOWN)1527 return dtype;1528 if (lstat(path, &st))1529 return dtype;1530 if (S_ISREG(st.st_mode))1531 return DT_REG;1532 if (S_ISDIR(st.st_mode))1533 return DT_DIR;1534 if (S_ISLNK(st.st_mode))1535 return DT_LNK;1536 return dtype;1537}15381539static enum path_treatment treat_one_path(struct dir_struct *dir,1540 struct untracked_cache_dir *untracked,1541 struct index_state *istate,1542 struct strbuf *path,1543 int baselen,1544 const struct pathspec *pathspec,1545 int dtype, struct dirent *de)1546{1547 int exclude;1548 int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);15491550 if (dtype == DT_UNKNOWN)1551 dtype = get_dtype(de, istate, path->buf, path->len);15521553 /* Always exclude indexed files */1554 if (dtype != DT_DIR && has_path_in_index)1555 return 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 */1575 if ((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))1579 return 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 */1587 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1588 return path_excluded;15891590 switch (dtype) {1591 default:1592 return path_none;1593 case DT_DIR:1594 strbuf_addch(path, '/');1595 return treat_directory(dir, istate, untracked, path->buf, path->len,1596 baselen, exclude, pathspec);1597 case DT_REG:1598 case DT_LNK:1599 return exclude ? path_excluded : path_untracked;1600 }1601}16021603static enum path_treatment treat_path_fast(struct dir_struct *dir,1604 struct untracked_cache_dir *untracked,1605 struct cached_dir *cdir,1606 struct index_state *istate,1607 struct strbuf *path,1608 int baselen,1609 const struct pathspec *pathspec)1610{1611 strbuf_setlen(path, baselen);1612 if (!cdir->ucd) {1613 strbuf_addstr(path, cdir->file);1614 return path_untracked;1615 }1616 strbuf_addstr(path, cdir->ucd->name);1617 /* treat_one_path() does this before it calls treat_directory() */1618 strbuf_complete(path, '/');1619 if (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 */1625 return read_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 */1633 return path_recurse;1634}16351636static enum path_treatment treat_path(struct dir_struct *dir,1637 struct untracked_cache_dir *untracked,1638 struct cached_dir *cdir,1639 struct index_state *istate,1640 struct strbuf *path,1641 int baselen,1642 const struct pathspec *pathspec)1643{1644 int dtype;1645 struct dirent *de = cdir->de;16461647 if (!de)1648 return treat_path_fast(dir, untracked, cdir, istate, path,1649 baselen, pathspec);1650 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))1651 return path_none;1652 strbuf_setlen(path, baselen);1653 strbuf_addstr(path, de->d_name);1654 if (simplify_away(path->buf, path->len, pathspec))1655 return path_none;16561657 dtype = DTYPE(de);1658 return treat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1659}16601661static void add_untracked(struct untracked_cache_dir *dir, const char *name)1662{1663 if (!dir)1664 return;1665 ALLOC_GROW(dir->untracked, dir->untracked_nr + 1,1666 dir->untracked_alloc);1667 dir->untracked[dir->untracked_nr++] = xstrdup(name);1668}16691670static int valid_cached_dir(struct dir_struct *dir,1671 struct untracked_cache_dir *untracked,1672 struct index_state *istate,1673 struct strbuf *path,1674 int check_only)1675{1676 struct stat st;16771678 if (!untracked)1679 return 0;16801681 if (stat(path->len ? path->buf : ".", &st)) {1682 invalidate_directory(dir->untracked, untracked);1683 memset(&untracked->stat_data, 0, sizeof(untracked->stat_data));1684 return 0;1685 }1686 if (!untracked->valid ||1687 match_stat_data_racy(istate, &untracked->stat_data, &st)) {1688 if (untracked->valid)1689 invalidate_directory(dir->untracked, untracked);1690 fill_stat_data(&untracked->stat_data, &st);1691 return 0;1692 }16931694 if (untracked->check_only != !!check_only) {1695 invalidate_directory(dir->untracked, untracked);1696 return 0;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 */1706 if (path->len && path->buf[path->len - 1] != '/') {1707 strbuf_addch(path, '/');1708 prep_exclude(dir, istate, path->buf, path->len);1709 strbuf_setlen(path, path->len - 1);1710 } else1711 prep_exclude(dir, istate, path->buf, path->len);17121713 /* hopefully prep_exclude() haven't invalidated this entry... */1714 return untracked->valid;1715}17161717static int open_cached_dir(struct cached_dir *cdir,1718 struct dir_struct *dir,1719 struct untracked_cache_dir *untracked,1720 struct index_state *istate,1721 struct strbuf *path,1722 int check_only)1723{1724 memset(cdir, 0, sizeof(*cdir));1725 cdir->untracked = untracked;1726 if (valid_cached_dir(dir, untracked, istate, path, check_only))1727 return 0;1728 cdir->fdir = opendir(path->len ? path->buf : ".");1729 if (dir->untracked)1730 dir->untracked->dir_opened++;1731 if (!cdir->fdir)1732 return -1;1733 return 0;1734}17351736static int read_cached_dir(struct cached_dir *cdir)1737{1738 if (cdir->fdir) {1739 cdir->de = readdir(cdir->fdir);1740 if (!cdir->de)1741 return -1;1742 return 0;1743 }1744 while (cdir->nr_dirs < cdir->untracked->dirs_nr) {1745 struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1746 if (!d->recurse) {1747 cdir->nr_dirs++;1748 continue;1749 }1750 cdir->ucd = d;1751 cdir->nr_dirs++;1752 return 0;1753 }1754 cdir->ucd = NULL;1755 if (cdir->nr_files < cdir->untracked->untracked_nr) {1756 struct untracked_cache_dir *d = cdir->untracked;1757 cdir->file = d->untracked[cdir->nr_files++];1758 return 0;1759 }1760 return -1;1761}17621763static void close_cached_dir(struct cached_dir *cdir)1764{1765 if (cdir->fdir)1766 closedir(cdir->fdir);1767 /*1768 * We have gone through this directory and found no untracked1769 * entries. Mark it valid.1770 */1771 if (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,1789 struct index_state *istate, const char *base, int baselen,1790 struct untracked_cache_dir *untracked, int check_only,1791 const struct pathspec *pathspec)1792{1793 struct cached_dir cdir;1794 enum path_treatment state, subdir_state, dir_state = path_none;1795 struct strbuf path = STRBUF_INIT;17961797 strbuf_add(&path, base, baselen);17981799 if (open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1800 goto out;18011802 if (untracked)1803 untracked->check_only = !!check_only;18041805 while (!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);18091810 if (state > dir_state)1811 dir_state = state;18121813 /* recurse into subdir if instructed by treat_path */1814 if (state == path_recurse) {1815 struct untracked_cache_dir *ud;1816 ud = lookup_untracked(dir->untracked, untracked,1817 path.buf + baselen,1818 path.len - baselen);1819 subdir_state =1820 read_directory_recursive(dir, istate, path.buf,1821 path.len, ud,1822 check_only, pathspec);1823 if (subdir_state > dir_state)1824 dir_state = subdir_state;1825 }18261827 if (check_only) {1828 /* abort early if maximum state has been reached */1829 if (dir_state == path_untracked) {1830 if (cdir.fdir)1831 add_untracked(untracked, path.buf + baselen);1832 break;1833 }1834 /* skip the dir_add_* part */1835 continue;1836 }18371838 /* add the path to the appropriate result list */1839 switch (state) {1840 case path_excluded:1841 if (dir->flags & DIR_SHOW_IGNORED)1842 dir_add_name(dir, istate, path.buf, path.len);1843 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||1844 ((dir->flags & DIR_COLLECT_IGNORED) &&1845 exclude_matches_pathspec(path.buf, path.len,1846 pathspec)))1847 dir_add_ignored(dir, istate, path.buf, path.len);1848 break;18491850 case path_untracked:1851 if (dir->flags & DIR_SHOW_IGNORED)1852 break;1853 dir_add_name(dir, istate, path.buf, path.len);1854 if (cdir.fdir)1855 add_untracked(untracked, path.buf + baselen);1856 break;18571858 default:1859 break;1860 }1861 }1862 close_cached_dir(&cdir);1863 out:1864 strbuf_release(&path);18651866 return dir_state;1867}18681869static int cmp_name(const void *p1, const void *p2)1870{1871 const struct dir_entry *e1 = *(const struct dir_entry **)p1;1872 const struct dir_entry *e2 = *(const struct dir_entry **)p2;18731874 return name_compare(e1->name, e1->len, e2->name, e2->len);1875}18761877static int treat_leading_path(struct dir_struct *dir,1878 struct index_state *istate,1879 const char *path, int len,1880 const struct pathspec *pathspec)1881{1882 struct strbuf sb = STRBUF_INIT;1883 int baselen, rc = 0;1884 const char *cp;1885 int old_flags = dir->flags;18861887 while (len && path[len - 1] == '/')1888 len--;1889 if (!len)1890 return 1;1891 baselen = 0;1892 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1893 while (1) {1894 cp = path + baselen + !!baselen;1895 cp = memchr(cp, '/', path + len - cp);1896 if (!cp)1897 baselen = len;1898 else1899 baselen = cp - path;1900 strbuf_setlen(&sb, 0);1901 strbuf_add(&sb, path, baselen);1902 if (!is_directory(sb.buf))1903 break;1904 if (simplify_away(sb.buf, sb.len, pathspec))1905 break;1906 if (treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,1907 DT_DIR, NULL) == path_none)1908 break; /* do not recurse into it */1909 if (len <= baselen) {1910 rc = 1;1911 break; /* finished checking */1912 }1913 }1914 strbuf_release(&sb);1915 dir->flags = old_flags;1916 return rc;1917}19181919static const char *get_ident_string(void)1920{1921 static struct strbuf sb = STRBUF_INIT;1922 struct utsname uts;19231924 if (sb.len)1925 return sb.buf;1926 if (uname(&uts) < 0)1927 die_errno(_("failed to get kernel name and information"));1928 strbuf_addf(&sb, "Location %s, system %s", get_git_work_tree(),1929 uts.sysname);1930 return sb.buf;1931}19321933static int ident_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 */19401941 return !strcmp(uc->ident.buf, get_ident_string());1942}19431944static void set_untracked_ident(struct untracked_cache *uc)1945{1946 strbuf_reset(&uc->ident);1947 strbuf_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 */1953 strbuf_addch(&uc->ident, 0);1954}19551956static void new_untracked_cache(struct index_state *istate)1957{1958 struct untracked_cache *uc = xcalloc(1, sizeof(*uc));1959 strbuf_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;1963 set_untracked_ident(uc);1964 istate->untracked = uc;1965 istate->cache_changed |= UNTRACKED_CHANGED;1966}19671968void add_untracked_cache(struct index_state *istate)1969{1970 if (!istate->untracked) {1971 new_untracked_cache(istate);1972 } else {1973 if (!ident_in_untracked(istate->untracked)) {1974 free_untracked_cache(istate->untracked);1975 new_untracked_cache(istate);1976 }1977 }1978}19791980void remove_untracked_cache(struct index_state *istate)1981{1982 if (istate->untracked) {1983 free_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,1990 int base_len,1991 const struct pathspec *pathspec)1992{1993 struct untracked_cache_dir *root;19941995 if (!dir->untracked || getenv("GIT_DISABLE_UNTRACKED_CACHE"))1996 return 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 */2005 if (dir->unmanaged_exclude_files)2006 return 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 */2014 if (base_len || (pathspec && pathspec->nr))2015 return NULL;20162017 /* Different set of flags may produce different results */2018 if (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)))2028 return NULL;20292030 /*2031 * If we use .gitignore in the cache and now you change it to2032 * .gitexclude, everything will go wrong.2033 */2034 if (dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2035 strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2036 return NULL;20372038 /*2039 * EXC_CMDL is not considered in the cache. If people set it,2040 * skip the cache.2041 */2042 if (dir->exclude_list_group[EXC_CMDL].nr)2043 return NULL;20442045 if (!ident_in_untracked(dir->untracked)) {2046 warning(_("Untracked cache is disabled on this system or location."));2047 return NULL;2048 }20492050 if (!dir->untracked->root) {2051 const int len = sizeof(*dir->untracked->root);2052 dir->untracked->root = xmalloc(len);2053 memset(dir->untracked->root, 0, len);2054 }20552056 /* Validate $GIT_DIR/info/exclude and core.excludesfile */2057 root = dir->untracked->root;2058 if (hashcmp(dir->ss_info_exclude.sha1,2059 dir->untracked->ss_info_exclude.sha1)) {2060 invalidate_gitignore(dir->untracked, root);2061 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2062 }2063 if (hashcmp(dir->ss_excludes_file.sha1,2064 dir->untracked->ss_excludes_file.sha1)) {2065 invalidate_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;2071 return root;2072}20732074int read_directory(struct dir_struct *dir, struct index_state *istate,2075 const char *path, int len, const struct pathspec *pathspec)2076{2077 struct untracked_cache_dir *untracked;20782079 if (has_symlink_leading_path(path, len))2080 return dir->nr;20812082 untracked = validate_untracked_cache(dir, len, pathspec);2083 if (!untracked)2084 /*2085 * make sure untracked cache code path is disabled,2086 * e.g. prep_exclude()2087 */2088 dir->untracked = NULL;2089 if (!len || treat_leading_path(dir, istate, path, len, pathspec))2090 read_directory_recursive(dir, istate, path, len, untracked, 0, pathspec);2091 QSORT(dir->entries, dir->nr, cmp_name);2092 QSORT(dir->ignored, dir->ignored_nr, cmp_name);2093 if (dir->untracked) {2094 static struct trace_key trace_untracked_stats = TRACE_KEY_INIT(UNTRACKED_STATS);2095 trace_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);2104 if (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;2109 if (dir->untracked != istate->untracked) {2110 free(dir->untracked);2111 dir->untracked = NULL;2112 }2113 }2114 return dir->nr;2115}21162117int file_exists(const char *f)2118{2119 struct stat sb;2120 return lstat(f, &sb) == 0;2121}21222123static int cmp_icase(char a, char b)2124{2125 if (a == b)2126 return 0;2127 if (ignore_case)2128 return toupper(a) - toupper(b);2129 return 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 */2137int dir_inside_of(const char *subdir, const char *dir)2138{2139 int offset = 0;21402141 assert(dir && subdir && *dir && *subdir);21422143 while (*dir && *subdir && !cmp_icase(*dir, *subdir)) {2144 dir++;2145 subdir++;2146 offset++;2147 }21482149 /* hel[p]/me vs hel[l]/yeah */2150 if (*dir && *subdir)2151 return -1;21522153 if (!*subdir)2154 return !*dir ? offset : -1; /* same dir */21552156 /* foo/[b]ar vs foo/[] */2157 if (is_dir_sep(dir[-1]))2158 return is_dir_sep(subdir[-1]) ? offset : -1;21592160 /* foo[/]bar vs foo[] */2161 return is_dir_sep(*subdir) ? offset + 1 : -1;2162}21632164int is_inside_dir(const char *dir)2165{2166 char *cwd;2167 int rc;21682169 if (!dir)2170 return 0;21712172 cwd = xgetcwd();2173 rc = (dir_inside_of(cwd, dir) >= 0);2174 free(cwd);2175 return rc;2176}21772178int is_empty_dir(const char *path)2179{2180 DIR *dir = opendir(path);2181 struct dirent *e;2182 int ret = 1;21832184 if (!dir)2185 return 0;21862187 while ((e = readdir(dir)) != NULL)2188 if (!is_dot_or_dotdot(e->d_name)) {2189 ret = 0;2190 break;2191 }21922193 closedir(dir);2194 return ret;2195}21962197static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)2198{2199 DIR *dir;2200 struct dirent *e;2201 int ret = 0, original_len = path->len, len, kept_down = 0;2202 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2203 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2204 unsigned char submodule_head[20];22052206 if ((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. */2209 if (kept_up)2210 *kept_up = 1;2211 return 0;2212 }22132214 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2215 dir = opendir(path->buf);2216 if (!dir) {2217 if (errno == ENOENT)2218 return keep_toplevel ? -1 : 0;2219 else if (errno == EACCES && !keep_toplevel)2220 /*2221 * An empty dir could be removable even if it2222 * is unreadable:2223 */2224 return rmdir(path->buf);2225 else2226 return -1;2227 }2228 strbuf_complete(path, '/');22292230 len = path->len;2231 while ((e = readdir(dir)) != NULL) {2232 struct stat st;2233 if (is_dot_or_dotdot(e->d_name))2234 continue;22352236 strbuf_setlen(path, len);2237 strbuf_addstr(path, e->d_name);2238 if (lstat(path->buf, &st)) {2239 if (errno == ENOENT)2240 /*2241 * file disappeared, which is what we2242 * wanted anyway2243 */2244 continue;2245 /* fall thru */2246 } else if (S_ISDIR(st.st_mode)) {2247 if (!remove_dir_recurse(path, flag, &kept_down))2248 continue; /* happy */2249 } else if (!only_empty &&2250 (!unlink(path->buf) || errno == ENOENT)) {2251 continue; /* happy, too */2252 }22532254 /* path too long, stat fails, or non-directory still exists */2255 ret = -1;2256 break;2257 }2258 closedir(dir);22592260 strbuf_setlen(path, original_len);2261 if (!ret && !keep_toplevel && !kept_down)2262 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;2263 else 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;2269 return ret;2270}22712272int remove_dir_recursively(struct strbuf *path, int flag)2273{2274 return remove_dir_recurse(path, flag, NULL);2275}22762277static GIT_PATH_FUNC(git_path_info_exclude, "info/exclude")22782279void setup_standard_excludes(struct dir_struct *dir)2280{2281 dir->exclude_per_dir = ".gitignore";22822283 /* core.excludefile defaulting to $XDG_HOME/git/ignore */2284 if (!excludes_file)2285 excludes_file = xdg_config_home("ignore");2286 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))2287 add_excludes_from_file_1(dir, excludes_file,2288 dir->untracked ? &dir->ss_excludes_file : NULL);22892290 /* per repository user preference */2291 if (startup_info->have_repository) {2292 const char *path = git_path_info_exclude();2293 if (!access_or_warn(path, R_OK, 0))2294 add_excludes_from_file_1(dir, path,2295 dir->untracked ? &dir->ss_info_exclude : NULL);2296 }2297}22982299int remove_path(const char *name)2300{2301 char *slash;23022303 if (unlink(name) && errno != ENOENT && errno != ENOTDIR)2304 return -1;23052306 slash = strrchr(name, '/');2307 if (slash) {2308 char *dirs = xstrdup(name);2309 slash = dirs + (slash - name);2310 do {2311 *slash = '\0';2312 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));2313 free(dirs);2314 }2315 return 0;2316}23172318/*2319 * Frees memory within dir which was allocated for exclude lists and2320 * the exclude_stack. Does not free dir itself.2321 */2322void clear_directory(struct dir_struct *dir)2323{2324 int i, j;2325 struct exclude_list_group *group;2326 struct exclude_list *el;2327 struct exclude_stack *stk;23282329 for (i = EXC_CMDL; i <= EXC_FILE; i++) {2330 group = &dir->exclude_list_group[i];2331 for (j = 0; j < group->nr; j++) {2332 el = &group->el[j];2333 if (i == EXC_DIRS)2334 free((char *)el->src);2335 clear_exclude_list(el);2336 }2337 free(group->el);2338 }23392340 stk = dir->exclude_stack;2341 while (stk) {2342 struct exclude_stack *prev = stk->prev;2343 free(stk);2344 stk = prev;2345 }2346 strbuf_release(&dir->basebuf);2347}23482349struct ondisk_untracked_cache {2350 struct stat_data info_exclude_stat;2351 struct stat_data excludes_file_stat;2352 uint32_t dir_flags;2353 unsigned char info_exclude_sha1[20];2354 unsigned char excludes_file_sha1[20];2355 char exclude_per_dir[FLEX_ARRAY];2356};23572358#define ouc_size(len) (offsetof(struct ondisk_untracked_cache, exclude_per_dir) + len + 1)23592360struct write_data {2361 int index; /* number of written untracked_cache_dir */2362 struct ewah_bitmap *check_only; /* from untracked_cache_dir */2363 struct ewah_bitmap *valid; /* from untracked_cache_dir */2364 struct ewah_bitmap *sha1_valid; /* set if exclude_sha1 is not null */2365 struct strbuf out;2366 struct strbuf sb_stat;2367 struct strbuf sb_sha1;2368};23692370static void stat_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 void write_one_dir(struct untracked_cache_dir *untracked,2384 struct write_data *wd)2385{2386 struct stat_data stat_data;2387 struct strbuf *out = &wd->out;2388 unsigned char intbuf[16];2389 unsigned int intlen, value;2390 int i = wd->index++;23912392 /*2393 * untracked_nr should be reset whenever valid is clear, but2394 * for safety..2395 */2396 if (!untracked->valid) {2397 untracked->untracked_nr = 0;2398 untracked->check_only = 0;2399 }24002401 if (untracked->check_only)2402 ewah_set(wd->check_only, i);2403 if (untracked->valid) {2404 ewah_set(wd->valid, i);2405 stat_data_to_disk(&stat_data, &untracked->stat_data);2406 strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data));2407 }2408 if (!is_null_sha1(untracked->exclude_sha1)) {2409 ewah_set(wd->sha1_valid, i);2410 strbuf_add(&wd->sb_sha1, untracked->exclude_sha1, 20);2411 }24122413 intlen = encode_varint(untracked->untracked_nr, intbuf);2414 strbuf_add(out, intbuf, intlen);24152416 /* skip non-recurse directories */2417 for (i = 0, value = 0; i < untracked->dirs_nr; i++)2418 if (untracked->dirs[i]->recurse)2419 value++;2420 intlen = encode_varint(value, intbuf);2421 strbuf_add(out, intbuf, intlen);24222423 strbuf_add(out, untracked->name, strlen(untracked->name) + 1);24242425 for (i = 0; i < untracked->untracked_nr; i++)2426 strbuf_add(out, untracked->untracked[i],2427 strlen(untracked->untracked[i]) + 1);24282429 for (i = 0; i < untracked->dirs_nr; i++)2430 if (untracked->dirs[i]->recurse)2431 write_one_dir(untracked->dirs[i], wd);2432}24332434void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked)2435{2436 struct ondisk_untracked_cache *ouc;2437 struct write_data wd;2438 unsigned char varbuf[16];2439 int varint_len;2440 size_t len = strlen(untracked->exclude_per_dir);24412442 FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2443 stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2444 stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2445 hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);2446 hashcpy(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);2450 strbuf_add(out, varbuf, varint_len);2451 strbuf_addbuf(out, &untracked->ident);24522453 strbuf_add(out, ouc, ouc_size(len));2454 free(ouc);2455 ouc = NULL;24562457 if (!untracked->root) {2458 varint_len = encode_varint(0, varbuf);2459 strbuf_add(out, varbuf, varint_len);2460 return;2461 }24622463 wd.index = 0;2464 wd.check_only = ewah_new();2465 wd.valid = ewah_new();2466 wd.sha1_valid = ewah_new();2467 strbuf_init(&wd.out, 1024);2468 strbuf_init(&wd.sb_stat, 1024);2469 strbuf_init(&wd.sb_sha1, 1024);2470 write_one_dir(untracked->root, &wd);24712472 varint_len = encode_varint(wd.index, varbuf);2473 strbuf_add(out, varbuf, varint_len);2474 strbuf_addbuf(out, &wd.out);2475 ewah_serialize_strbuf(wd.valid, out);2476 ewah_serialize_strbuf(wd.check_only, out);2477 ewah_serialize_strbuf(wd.sha1_valid, out);2478 strbuf_addbuf(out, &wd.sb_stat);2479 strbuf_addbuf(out, &wd.sb_sha1);2480 strbuf_addch(out, '\0'); /* safe guard for string lists */24812482 ewah_free(wd.valid);2483 ewah_free(wd.check_only);2484 ewah_free(wd.sha1_valid);2485 strbuf_release(&wd.out);2486 strbuf_release(&wd.sb_stat);2487 strbuf_release(&wd.sb_sha1);2488}24892490static void free_untracked(struct untracked_cache_dir *ucd)2491{2492 int i;2493 if (!ucd)2494 return;2495 for (i = 0; i < ucd->dirs_nr; i++)2496 free_untracked(ucd->dirs[i]);2497 for (i = 0; i < ucd->untracked_nr; i++)2498 free(ucd->untracked[i]);2499 free(ucd->untracked);2500 free(ucd->dirs);2501 free(ucd);2502}25032504void free_untracked_cache(struct untracked_cache *uc)2505{2506 if (uc)2507 free_untracked(uc->root);2508 free(uc);2509}25102511struct read_data {2512 int index;2513 struct untracked_cache_dir **ucd;2514 struct ewah_bitmap *check_only;2515 struct ewah_bitmap *valid;2516 struct ewah_bitmap *sha1_valid;2517 const unsigned char *data;2518 const unsigned char *end;2519};25202521static void stat_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 int read_one_dir(struct untracked_cache_dir **untracked_,2535 struct read_data *rd)2536{2537 struct untracked_cache_dir ud, *untracked;2538 const unsigned char *next, *data = rd->data, *end = rd->end;2539 unsigned int value;2540 int i, len;25412542 memset(&ud, 0, sizeof(ud));25432544 next = data;2545 value = decode_varint(&next);2546 if (next > end)2547 return -1;2548 ud.recurse = 1;2549 ud.untracked_alloc = value;2550 ud.untracked_nr = value;2551 if (ud.untracked_nr)2552 ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2553 data = next;25542555 next = data;2556 ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);2557 if (next > end)2558 return -1;2559 ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2560 data = next;25612562 len = strlen((const char *)data);2563 next = data + len + 1;2564 if (next > rd->end)2565 return -1;2566 *untracked_ = untracked = xmalloc(st_add(sizeof(*untracked), len));2567 memcpy(untracked, &ud, sizeof(ud));2568 memcpy(untracked->name, data, len + 1);2569 data = next;25702571 for (i = 0; i < untracked->untracked_nr; i++) {2572 len = strlen((const char *)data);2573 next = data + len + 1;2574 if (next > rd->end)2575 return -1;2576 untracked->untracked[i] = xstrdup((const char*)data);2577 data = next;2578 }25792580 rd->ucd[rd->index++] = untracked;2581 rd->data = data;25822583 for (i = 0; i < untracked->dirs_nr; i++) {2584 len = read_one_dir(untracked->dirs + i, rd);2585 if (len < 0)2586 return -1;2587 }2588 return 0;2589}25902591static void set_check_only(size_t pos, void *cb)2592{2593 struct read_data *rd = cb;2594 struct untracked_cache_dir *ud = rd->ucd[pos];2595 ud->check_only = 1;2596}25972598static void read_stat(size_t pos, void *cb)2599{2600 struct read_data *rd = cb;2601 struct untracked_cache_dir *ud = rd->ucd[pos];2602 if (rd->data + sizeof(struct stat_data) > rd->end) {2603 rd->data = rd->end + 1;2604 return;2605 }2606 stat_data_from_disk(&ud->stat_data, (struct stat_data *)rd->data);2607 rd->data += sizeof(struct stat_data);2608 ud->valid = 1;2609}26102611static void read_sha1(size_t pos, void *cb)2612{2613 struct read_data *rd = cb;2614 struct untracked_cache_dir *ud = rd->ucd[pos];2615 if (rd->data + 20 > rd->end) {2616 rd->data = rd->end + 1;2617 return;2618 }2619 hashcpy(ud->exclude_sha1, rd->data);2620 rd->data += 20;2621}26222623static void load_sha1_stat(struct sha1_stat *sha1_stat,2624 const struct stat_data *stat,2625 const unsigned char *sha1)2626{2627 stat_data_from_disk(&sha1_stat->stat, stat);2628 hashcpy(sha1_stat->sha1, sha1);2629 sha1_stat->valid = 1;2630}26312632struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz)2633{2634 const struct ondisk_untracked_cache *ouc;2635 struct untracked_cache *uc;2636 struct read_data rd;2637 const unsigned char *next = data, *end = (const unsigned char *)data + sz;2638 const char *ident;2639 int ident_len, len;26402641 if (sz <= 1 || end[-1] != '\0')2642 return NULL;2643 end--;26442645 ident_len = decode_varint(&next);2646 if (next + ident_len > end)2647 return NULL;2648 ident = (const char *)next;2649 next += ident_len;26502651 ouc = (const struct ondisk_untracked_cache *)next;2652 if (next + ouc_size(0) > end)2653 return NULL;26542655 uc = xcalloc(1, sizeof(*uc));2656 strbuf_init(&uc->ident, ident_len);2657 strbuf_add(&uc->ident, ident, ident_len);2658 load_sha1_stat(&uc->ss_info_exclude, &ouc->info_exclude_stat,2659 ouc->info_exclude_sha1);2660 load_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));2666 if (next >= end)2667 goto done2;26682669 len = decode_varint(&next);2670 if (next > end || len == 0)2671 goto 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;2679 ALLOC_ARRAY(rd.ucd, len);26802681 if (read_one_dir(&uc->root, &rd) || rd.index != len)2682 goto done;26832684 next = rd.data;2685 len = ewah_read_mmap(rd.valid, next, end - next);2686 if (len < 0)2687 goto done;26882689 next += len;2690 len = ewah_read_mmap(rd.check_only, next, end - next);2691 if (len < 0)2692 goto done;26932694 next += len;2695 len = ewah_read_mmap(rd.sha1_valid, next, end - next);2696 if (len < 0)2697 goto done;26982699 ewah_each_bit(rd.check_only, set_check_only, &rd);2700 rd.data = next + len;2701 ewah_each_bit(rd.valid, read_stat, &rd);2702 ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2703 next = rd.data;27042705done:2706 free(rd.ucd);2707 ewah_free(rd.valid);2708 ewah_free(rd.check_only);2709 ewah_free(rd.sha1_valid);2710done2:2711 if (next != end) {2712 free_untracked_cache(uc);2713 uc = NULL;2714 }2715 return uc;2716}27172718static void invalidate_one_directory(struct untracked_cache *uc,2719 struct 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 int invalidate_one_component(struct untracked_cache *uc,2751 struct untracked_cache_dir *dir,2752 const char *path, int len)2753{2754 const char *rest = strchr(path, '/');27552756 if (rest) {2757 int component_len = rest - path;2758 struct untracked_cache_dir *d =2759 lookup_untracked(uc, dir, path, component_len);2760 int ret =2761 invalidate_one_component(uc, d, rest + 1,2762 len - (component_len + 1));2763 if (ret)2764 invalidate_one_directory(uc, dir);2765 return ret;2766 }27672768 invalidate_one_directory(uc, dir);2769 return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2770}27712772void untracked_cache_invalidate_path(struct index_state *istate,2773 const char *path)2774{2775 if (!istate->untracked || !istate->untracked->root)2776 return;2777 invalidate_one_component(istate->untracked, istate->untracked->root,2778 path, strlen(path));2779}27802781void untracked_cache_remove_from_index(struct index_state *istate,2782 const char *path)2783{2784 untracked_cache_invalidate_path(istate, path);2785}27862787void untracked_cache_add_to_index(struct index_state *istate,2788 const char *path)2789{2790 untracked_cache_invalidate_path(istate, path);2791}27922793/* Update gitfile and core.worktree setting to connect work tree and git dir */2794void connect_work_tree_and_git_dir(const char *work_tree_, const char *git_dir_)2795{2796 struct strbuf gitfile_sb = STRBUF_INIT;2797 struct strbuf cfg_sb = STRBUF_INIT;2798 struct strbuf rel_path = STRBUF_INIT;2799 char *git_dir, *work_tree;28002801 /* Prepare .git file */2802 strbuf_addf(&gitfile_sb, "%s/.git", work_tree_);2803 if (safe_create_leading_directories_const(gitfile_sb.buf))2804 die(_("could not create directories for %s"), gitfile_sb.buf);28052806 /* Prepare config file */2807 strbuf_addf(&cfg_sb, "%s/config", git_dir_);2808 if (safe_create_leading_directories_const(cfg_sb.buf))2809 die(_("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 */2815 write_file(gitfile_sb.buf, "gitdir: %s",2816 relative_path(git_dir, work_tree, &rel_path));2817 /* Update core.worktree setting */2818 git_config_set_in_file(cfg_sb.buf, "core.worktree",2819 relative_path(work_tree, git_dir, &rel_path));28202821 strbuf_release(&gitfile_sb);2822 strbuf_release(&cfg_sb);2823 strbuf_release(&rel_path);2824 free(work_tree);2825 free(git_dir);2826}28272828/*2829 * Migrate the git directory of the given path from old_git_dir to new_git_dir.2830 */2831void relocate_gitdir(const char *path, const char *old_git_dir, const char *new_git_dir)2832{2833 if (rename(old_git_dir, new_git_dir) < 0)2834 die_errno(_("could not migrate git directory from '%s' to '%s'"),2835 old_git_dir, new_git_dir);28362837 connect_work_tree_and_git_dir(path, new_git_dir);2838}