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