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#include "cache.h" 11#include "dir.h" 12#include "refs.h" 13#include "wildmatch.h" 14#include "pathspec.h" 15#include "utf8.h" 16#include "varint.h" 17#include "ewah/ewok.h" 18 19/* 20 * Tells read_directory_recursive how a file or directory should be treated. 21 * Values are ordered by significance, e.g. if a directory contains both 22 * excluded and untracked files, it is listed as untracked because 23 * path_untracked > path_excluded. 24 */ 25enum path_treatment { 26 path_none = 0, 27 path_recurse, 28 path_excluded, 29 path_untracked 30}; 31 32/* 33 * Support data structure for our opendir/readdir/closedir wrappers 34 */ 35struct cached_dir { 36 DIR *fdir; 37 struct untracked_cache_dir *untracked; 38 int nr_files; 39 int nr_dirs; 40 41 struct dirent *de; 42 const char *file; 43 struct untracked_cache_dir *ucd; 44}; 45 46static enum path_treatment read_directory_recursive(struct dir_struct *dir, 47 const char *path, int len, struct untracked_cache_dir *untracked, 48 int check_only, const struct pathspec *pathspec); 49static int get_dtype(struct dirent *de, const char *path, int len); 50 51int fspathcmp(const char *a, const char *b) 52{ 53 return ignore_case ? strcasecmp(a, b) : strcmp(a, b); 54} 55 56int fspathncmp(const char *a, const char *b, size_t count) 57{ 58 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count); 59} 60 61int git_fnmatch(const struct pathspec_item *item, 62 const char *pattern, const char *string, 63 int prefix) 64{ 65 if (prefix > 0) { 66 if (ps_strncmp(item, pattern, string, prefix)) 67 return WM_NOMATCH; 68 pattern += prefix; 69 string += prefix; 70 } 71 if (item->flags & PATHSPEC_ONESTAR) { 72 int pattern_len = strlen(++pattern); 73 int string_len = strlen(string); 74 return string_len < pattern_len || 75 ps_strcmp(item, pattern, 76 string + string_len - pattern_len); 77 } 78 if (item->magic & PATHSPEC_GLOB) 79 return wildmatch(pattern, string, 80 WM_PATHNAME | 81 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0), 82 NULL); 83 else 84 /* wildmatch has not learned no FNM_PATHNAME mode yet */ 85 return wildmatch(pattern, string, 86 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0, 87 NULL); 88} 89 90static int fnmatch_icase_mem(const char *pattern, int patternlen, 91 const char *string, int stringlen, 92 int flags) 93{ 94 int match_status; 95 struct strbuf pat_buf = STRBUF_INIT; 96 struct strbuf str_buf = STRBUF_INIT; 97 const char *use_pat = pattern; 98 const char *use_str = string; 99 100 if (pattern[patternlen]) { 101 strbuf_add(&pat_buf, pattern, patternlen); 102 use_pat = pat_buf.buf; 103 } 104 if (string[stringlen]) { 105 strbuf_add(&str_buf, string, stringlen); 106 use_str = str_buf.buf; 107 } 108 109 if (ignore_case) 110 flags |= WM_CASEFOLD; 111 match_status = wildmatch(use_pat, use_str, flags, NULL); 112 113 strbuf_release(&pat_buf); 114 strbuf_release(&str_buf); 115 116 return match_status; 117} 118 119static size_t common_prefix_len(const struct pathspec *pathspec) 120{ 121 int n; 122 size_t max = 0; 123 124 /* 125 * ":(icase)path" is treated as a pathspec full of 126 * wildcard. In other words, only prefix is considered common 127 * prefix. If the pathspec is abc/foo abc/bar, running in 128 * subdir xyz, the common prefix is still xyz, not xuz/abc as 129 * in non-:(icase). 130 */ 131 GUARD_PATHSPEC(pathspec, 132 PATHSPEC_FROMTOP | 133 PATHSPEC_MAXDEPTH | 134 PATHSPEC_LITERAL | 135 PATHSPEC_GLOB | 136 PATHSPEC_ICASE | 137 PATHSPEC_EXCLUDE); 138 139 for (n = 0; n < pathspec->nr; n++) { 140 size_t i = 0, len = 0, item_len; 141 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE) 142 continue; 143 if (pathspec->items[n].magic & PATHSPEC_ICASE) 144 item_len = pathspec->items[n].prefix; 145 else 146 item_len = pathspec->items[n].nowildcard_len; 147 while (i < item_len && (n == 0 || i < max)) { 148 char c = pathspec->items[n].match[i]; 149 if (c != pathspec->items[0].match[i]) 150 break; 151 if (c == '/') 152 len = i + 1; 153 i++; 154 } 155 if (n == 0 || len < max) { 156 max = len; 157 if (!max) 158 break; 159 } 160 } 161 return max; 162} 163 164/* 165 * Returns a copy of the longest leading path common among all 166 * pathspecs. 167 */ 168char *common_prefix(const struct pathspec *pathspec) 169{ 170 unsigned long len = common_prefix_len(pathspec); 171 172 return len ? xmemdupz(pathspec->items[0].match, len) : NULL; 173} 174 175int fill_directory(struct dir_struct *dir, const struct pathspec *pathspec) 176{ 177 char *prefix; 178 size_t prefix_len; 179 180 /* 181 * Calculate common prefix for the pathspec, and 182 * use that to optimize the directory walk 183 */ 184 prefix = common_prefix(pathspec); 185 prefix_len = prefix ? strlen(prefix) : 0; 186 187 /* Read the directory and prune it */ 188 read_directory(dir, prefix, prefix_len, pathspec); 189 190 free(prefix); 191 return prefix_len; 192} 193 194int within_depth(const char *name, int namelen, 195 int depth, int max_depth) 196{ 197 const char *cp = name, *cpe = name + namelen; 198 199 while (cp < cpe) { 200 if (*cp++ != '/') 201 continue; 202 depth++; 203 if (depth > max_depth) 204 return 0; 205 } 206 return 1; 207} 208 209#define DO_MATCH_EXCLUDE (1<<0) 210#define DO_MATCH_DIRECTORY (1<<1) 211#define DO_MATCH_SUBMODULE (1<<2) 212 213/* 214 * Does 'match' match the given name? 215 * A match is found if 216 * 217 * (1) the 'match' string is leading directory of 'name', or 218 * (2) the 'match' string is a wildcard and matches 'name', or 219 * (3) the 'match' string is exactly the same as 'name'. 220 * 221 * and the return value tells which case it was. 222 * 223 * It returns 0 when there is no match. 224 */ 225static int match_pathspec_item(const struct pathspec_item *item, int prefix, 226 const char *name, int namelen, unsigned flags) 227{ 228 /* name/namelen has prefix cut off by caller */ 229 const char *match = item->match + prefix; 230 int matchlen = item->len - prefix; 231 232 /* 233 * The normal call pattern is: 234 * 1. prefix = common_prefix_len(ps); 235 * 2. prune something, or fill_directory 236 * 3. match_pathspec() 237 * 238 * 'prefix' at #1 may be shorter than the command's prefix and 239 * it's ok for #2 to match extra files. Those extras will be 240 * trimmed at #3. 241 * 242 * Suppose the pathspec is 'foo' and '../bar' running from 243 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 244 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 245 * user does not want XYZ/foo, only the "foo" part should be 246 * case-insensitive. We need to filter out XYZ/foo here. In 247 * other words, we do not trust the caller on comparing the 248 * prefix part when :(icase) is involved. We do exact 249 * comparison ourselves. 250 * 251 * Normally the caller (common_prefix_len() in fact) does 252 * _exact_ matching on name[-prefix+1..-1] and we do not need 253 * to check that part. Be defensive and check it anyway, in 254 * case common_prefix_len is changed, or a new caller is 255 * introduced that does not use common_prefix_len. 256 * 257 * If the penalty turns out too high when prefix is really 258 * long, maybe change it to 259 * strncmp(match, name, item->prefix - prefix) 260 */ 261 if (item->prefix && (item->magic & PATHSPEC_ICASE) && 262 strncmp(item->match, name - prefix, item->prefix)) 263 return 0; 264 265 /* If the match was just the prefix, we matched */ 266 if (!*match) 267 return MATCHED_RECURSIVELY; 268 269 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 270 if (matchlen == namelen) 271 return MATCHED_EXACTLY; 272 273 if (match[matchlen-1] == '/' || name[matchlen] == '/') 274 return MATCHED_RECURSIVELY; 275 } else if ((flags & DO_MATCH_DIRECTORY) && 276 match[matchlen - 1] == '/' && 277 namelen == matchlen - 1 && 278 !ps_strncmp(item, match, name, namelen)) 279 return MATCHED_EXACTLY; 280 281 if (item->nowildcard_len < item->len && 282 !git_fnmatch(item, match, name, 283 item->nowildcard_len - prefix)) 284 return MATCHED_FNMATCH; 285 286 /* Perform checks to see if "name" is a super set of the pathspec */ 287 if (flags & DO_MATCH_SUBMODULE) { 288 /* name is a literal prefix of the pathspec */ 289 if ((namelen < matchlen) && 290 (match[namelen] == '/') && 291 !ps_strncmp(item, match, name, namelen)) 292 return MATCHED_RECURSIVELY; 293 294 /* name" doesn't match up to the first wild character */ 295 if (item->nowildcard_len < item->len && 296 ps_strncmp(item, match, name, 297 item->nowildcard_len - prefix)) 298 return 0; 299 300 /* 301 * Here is where we would perform a wildmatch to check if 302 * "name" can be matched as a directory (or a prefix) against 303 * the pathspec. Since wildmatch doesn't have this capability 304 * at the present we have to punt and say that it is a match, 305 * potentially returning a false positive 306 * The submodules themselves will be able to perform more 307 * accurate matching to determine if the pathspec matches. 308 */ 309 return MATCHED_RECURSIVELY; 310 } 311 312 return 0; 313} 314 315/* 316 * Given a name and a list of pathspecs, returns the nature of the 317 * closest (i.e. most specific) match of the name to any of the 318 * pathspecs. 319 * 320 * The caller typically calls this multiple times with the same 321 * pathspec and seen[] array but with different name/namelen 322 * (e.g. entries from the index) and is interested in seeing if and 323 * how each pathspec matches all the names it calls this function 324 * with. A mark is left in the seen[] array for each pathspec element 325 * indicating the closest type of match that element achieved, so if 326 * seen[n] remains zero after multiple invocations, that means the nth 327 * pathspec did not match any names, which could indicate that the 328 * user mistyped the nth pathspec. 329 */ 330static int do_match_pathspec(const struct pathspec *ps, 331 const char *name, int namelen, 332 int prefix, char *seen, 333 unsigned flags) 334{ 335 int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE; 336 337 GUARD_PATHSPEC(ps, 338 PATHSPEC_FROMTOP | 339 PATHSPEC_MAXDEPTH | 340 PATHSPEC_LITERAL | 341 PATHSPEC_GLOB | 342 PATHSPEC_ICASE | 343 PATHSPEC_EXCLUDE); 344 345 if (!ps->nr) { 346 if (!ps->recursive || 347 !(ps->magic & PATHSPEC_MAXDEPTH) || 348 ps->max_depth == -1) 349 return MATCHED_RECURSIVELY; 350 351 if (within_depth(name, namelen, 0, ps->max_depth)) 352 return MATCHED_EXACTLY; 353 else 354 return 0; 355 } 356 357 name += prefix; 358 namelen -= prefix; 359 360 for (i = ps->nr - 1; i >= 0; i--) { 361 int how; 362 363 if ((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 364 ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 365 continue; 366 367 if (seen && seen[i] == MATCHED_EXACTLY) 368 continue; 369 /* 370 * Make exclude patterns optional and never report 371 * "pathspec ':(exclude)foo' matches no files" 372 */ 373 if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 374 seen[i] = MATCHED_FNMATCH; 375 how = match_pathspec_item(ps->items+i, prefix, name, 376 namelen, flags); 377 if (ps->recursive && 378 (ps->magic & PATHSPEC_MAXDEPTH) && 379 ps->max_depth != -1 && 380 how && how != MATCHED_FNMATCH) { 381 int len = ps->items[i].len; 382 if (name[len] == '/') 383 len++; 384 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 385 how = MATCHED_EXACTLY; 386 else 387 how = 0; 388 } 389 if (how) { 390 if (retval < how) 391 retval = how; 392 if (seen && seen[i] < how) 393 seen[i] = how; 394 } 395 } 396 return retval; 397} 398 399int match_pathspec(const struct pathspec *ps, 400 const char *name, int namelen, 401 int prefix, char *seen, int is_dir) 402{ 403 int positive, negative; 404 unsigned flags = is_dir ? DO_MATCH_DIRECTORY : 0; 405 positive = do_match_pathspec(ps, name, namelen, 406 prefix, seen, flags); 407 if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 408 return positive; 409 negative = do_match_pathspec(ps, name, namelen, 410 prefix, seen, 411 flags | DO_MATCH_EXCLUDE); 412 return negative ? 0 : positive; 413} 414 415/** 416 * Check if a submodule is a superset of the pathspec 417 */ 418int submodule_path_match(const struct pathspec *ps, 419 const char *submodule_name, 420 char *seen) 421{ 422 int matched = do_match_pathspec(ps, submodule_name, 423 strlen(submodule_name), 424 0, seen, 425 DO_MATCH_DIRECTORY | 426 DO_MATCH_SUBMODULE); 427 return matched; 428} 429 430int report_path_error(const char *ps_matched, 431 const struct pathspec *pathspec, 432 const char *prefix) 433{ 434 /* 435 * Make sure all pathspec matched; otherwise it is an error. 436 */ 437 int num, errors = 0; 438 for (num = 0; num < pathspec->nr; num++) { 439 int other, found_dup; 440 441 if (ps_matched[num]) 442 continue; 443 /* 444 * The caller might have fed identical pathspec 445 * twice. Do not barf on such a mistake. 446 * FIXME: parse_pathspec should have eliminated 447 * duplicate pathspec. 448 */ 449 for (found_dup = other = 0; 450 !found_dup && other < pathspec->nr; 451 other++) { 452 if (other == num || !ps_matched[other]) 453 continue; 454 if (!strcmp(pathspec->items[other].original, 455 pathspec->items[num].original)) 456 /* 457 * Ok, we have a match already. 458 */ 459 found_dup = 1; 460 } 461 if (found_dup) 462 continue; 463 464 error("pathspec '%s' did not match any file(s) known to git.", 465 pathspec->items[num].original); 466 errors++; 467 } 468 return errors; 469} 470 471/* 472 * Return the length of the "simple" part of a path match limiter. 473 */ 474int simple_length(const char *match) 475{ 476 int len = -1; 477 478 for (;;) { 479 unsigned char c = *match++; 480 len++; 481 if (c == '\0' || is_glob_special(c)) 482 return len; 483 } 484} 485 486int no_wildcard(const char *string) 487{ 488 return string[simple_length(string)] == '\0'; 489} 490 491void parse_exclude_pattern(const char **pattern, 492 int *patternlen, 493 unsigned *flags, 494 int *nowildcardlen) 495{ 496 const char *p = *pattern; 497 size_t i, len; 498 499 *flags = 0; 500 if (*p == '!') { 501 *flags |= EXC_FLAG_NEGATIVE; 502 p++; 503 } 504 len = strlen(p); 505 if (len && p[len - 1] == '/') { 506 len--; 507 *flags |= EXC_FLAG_MUSTBEDIR; 508 } 509 for (i = 0; i < len; i++) { 510 if (p[i] == '/') 511 break; 512 } 513 if (i == len) 514 *flags |= EXC_FLAG_NODIR; 515 *nowildcardlen = simple_length(p); 516 /* 517 * we should have excluded the trailing slash from 'p' too, 518 * but that's one more allocation. Instead just make sure 519 * nowildcardlen does not exceed real patternlen 520 */ 521 if (*nowildcardlen > len) 522 *nowildcardlen = len; 523 if (*p == '*' && no_wildcard(p + 1)) 524 *flags |= EXC_FLAG_ENDSWITH; 525 *pattern = p; 526 *patternlen = len; 527} 528 529void add_exclude(const char *string, const char *base, 530 int baselen, struct exclude_list *el, int srcpos) 531{ 532 struct exclude *x; 533 int patternlen; 534 unsigned flags; 535 int nowildcardlen; 536 537 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 538 if (flags & EXC_FLAG_MUSTBEDIR) { 539 FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 540 } else { 541 x = xmalloc(sizeof(*x)); 542 x->pattern = string; 543 } 544 x->patternlen = patternlen; 545 x->nowildcardlen = nowildcardlen; 546 x->base = base; 547 x->baselen = baselen; 548 x->flags = flags; 549 x->srcpos = srcpos; 550 ALLOC_GROW(el->excludes, el->nr + 1, el->alloc); 551 el->excludes[el->nr++] = x; 552 x->el = el; 553} 554 555static void *read_skip_worktree_file_from_index(const char *path, size_t *size, 556 struct sha1_stat *sha1_stat) 557{ 558 int pos, len; 559 unsigned long sz; 560 enum object_type type; 561 void *data; 562 563 len = strlen(path); 564 pos = cache_name_pos(path, len); 565 if (pos < 0) 566 return NULL; 567 if (!ce_skip_worktree(active_cache[pos])) 568 return NULL; 569 data = read_sha1_file(active_cache[pos]->oid.hash, &type, &sz); 570 if (!data || type != OBJ_BLOB) { 571 free(data); 572 return NULL; 573 } 574 *size = xsize_t(sz); 575 if (sha1_stat) { 576 memset(&sha1_stat->stat, 0, sizeof(sha1_stat->stat)); 577 hashcpy(sha1_stat->sha1, active_cache[pos]->oid.hash); 578 } 579 return data; 580} 581 582/* 583 * Frees memory within el which was allocated for exclude patterns and 584 * the file buffer. Does not free el itself. 585 */ 586void clear_exclude_list(struct exclude_list *el) 587{ 588 int i; 589 590 for (i = 0; i < el->nr; i++) 591 free(el->excludes[i]); 592 free(el->excludes); 593 free(el->filebuf); 594 595 memset(el, 0, sizeof(*el)); 596} 597 598static void trim_trailing_spaces(char *buf) 599{ 600 char *p, *last_space = NULL; 601 602 for (p = buf; *p; p++) 603 switch (*p) { 604 case ' ': 605 if (!last_space) 606 last_space = p; 607 break; 608 case '\\': 609 p++; 610 if (!*p) 611 return; 612 /* fallthrough */ 613 default: 614 last_space = NULL; 615 } 616 617 if (last_space) 618 *last_space = '\0'; 619} 620 621/* 622 * Given a subdirectory name and "dir" of the current directory, 623 * search the subdir in "dir" and return it, or create a new one if it 624 * does not exist in "dir". 625 * 626 * If "name" has the trailing slash, it'll be excluded in the search. 627 */ 628static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 629 struct untracked_cache_dir *dir, 630 const char *name, int len) 631{ 632 int first, last; 633 struct untracked_cache_dir *d; 634 if (!dir) 635 return NULL; 636 if (len && name[len - 1] == '/') 637 len--; 638 first = 0; 639 last = dir->dirs_nr; 640 while (last > first) { 641 int cmp, next = (last + first) >> 1; 642 d = dir->dirs[next]; 643 cmp = strncmp(name, d->name, len); 644 if (!cmp && strlen(d->name) > len) 645 cmp = -1; 646 if (!cmp) 647 return d; 648 if (cmp < 0) { 649 last = next; 650 continue; 651 } 652 first = next+1; 653 } 654 655 uc->dir_created++; 656 FLEX_ALLOC_MEM(d, name, name, len); 657 658 ALLOC_GROW(dir->dirs, dir->dirs_nr + 1, dir->dirs_alloc); 659 memmove(dir->dirs + first + 1, dir->dirs + first, 660 (dir->dirs_nr - first) * sizeof(*dir->dirs)); 661 dir->dirs_nr++; 662 dir->dirs[first] = d; 663 return d; 664} 665 666static void do_invalidate_gitignore(struct untracked_cache_dir *dir) 667{ 668 int i; 669 dir->valid = 0; 670 dir->untracked_nr = 0; 671 for (i = 0; i < dir->dirs_nr; i++) 672 do_invalidate_gitignore(dir->dirs[i]); 673} 674 675static void invalidate_gitignore(struct untracked_cache *uc, 676 struct untracked_cache_dir *dir) 677{ 678 uc->gitignore_invalidated++; 679 do_invalidate_gitignore(dir); 680} 681 682static void invalidate_directory(struct untracked_cache *uc, 683 struct untracked_cache_dir *dir) 684{ 685 int i; 686 uc->dir_invalidated++; 687 dir->valid = 0; 688 dir->untracked_nr = 0; 689 for (i = 0; i < dir->dirs_nr; i++) 690 dir->dirs[i]->recurse = 0; 691} 692 693/* 694 * Given a file with name "fname", read it (either from disk, or from 695 * the index if "check_index" is non-zero), parse it and store the 696 * exclude rules in "el". 697 * 698 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 699 * stat data from disk (only valid if add_excludes returns zero). If 700 * ss_valid is non-zero, "ss" must contain good value as input. 701 */ 702static int add_excludes(const char *fname, const char *base, int baselen, 703 struct exclude_list *el, int check_index, 704 struct sha1_stat *sha1_stat) 705{ 706 struct stat st; 707 int fd, i, lineno = 1; 708 size_t size = 0; 709 char *buf, *entry; 710 711 fd = open(fname, O_RDONLY); 712 if (fd < 0 || fstat(fd, &st) < 0) { 713 if (errno != ENOENT) 714 warn_on_inaccessible(fname); 715 if (0 <= fd) 716 close(fd); 717 if (!check_index || 718 (buf = read_skip_worktree_file_from_index(fname, &size, sha1_stat)) == NULL) 719 return -1; 720 if (size == 0) { 721 free(buf); 722 return 0; 723 } 724 if (buf[size-1] != '\n') { 725 buf = xrealloc(buf, st_add(size, 1)); 726 buf[size++] = '\n'; 727 } 728 } else { 729 size = xsize_t(st.st_size); 730 if (size == 0) { 731 if (sha1_stat) { 732 fill_stat_data(&sha1_stat->stat, &st); 733 hashcpy(sha1_stat->sha1, EMPTY_BLOB_SHA1_BIN); 734 sha1_stat->valid = 1; 735 } 736 close(fd); 737 return 0; 738 } 739 buf = xmallocz(size); 740 if (read_in_full(fd, buf, size) != size) { 741 free(buf); 742 close(fd); 743 return -1; 744 } 745 buf[size++] = '\n'; 746 close(fd); 747 if (sha1_stat) { 748 int pos; 749 if (sha1_stat->valid && 750 !match_stat_data_racy(&the_index, &sha1_stat->stat, &st)) 751 ; /* no content change, ss->sha1 still good */ 752 else if (check_index && 753 (pos = cache_name_pos(fname, strlen(fname))) >= 0 && 754 !ce_stage(active_cache[pos]) && 755 ce_uptodate(active_cache[pos]) && 756 !would_convert_to_git(fname)) 757 hashcpy(sha1_stat->sha1, 758 active_cache[pos]->oid.hash); 759 else 760 hash_sha1_file(buf, size, "blob", sha1_stat->sha1); 761 fill_stat_data(&sha1_stat->stat, &st); 762 sha1_stat->valid = 1; 763 } 764 } 765 766 el->filebuf = buf; 767 768 if (skip_utf8_bom(&buf, size)) 769 size -= buf - el->filebuf; 770 771 entry = buf; 772 773 for (i = 0; i < size; i++) { 774 if (buf[i] == '\n') { 775 if (entry != buf + i && entry[0] != '#') { 776 buf[i - (i && buf[i-1] == '\r')] = 0; 777 trim_trailing_spaces(entry); 778 add_exclude(entry, base, baselen, el, lineno); 779 } 780 lineno++; 781 entry = buf + i + 1; 782 } 783 } 784 return 0; 785} 786 787int add_excludes_from_file_to_list(const char *fname, const char *base, 788 int baselen, struct exclude_list *el, 789 int check_index) 790{ 791 return add_excludes(fname, base, baselen, el, check_index, NULL); 792} 793 794struct exclude_list *add_exclude_list(struct dir_struct *dir, 795 int group_type, const char *src) 796{ 797 struct exclude_list *el; 798 struct exclude_list_group *group; 799 800 group = &dir->exclude_list_group[group_type]; 801 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 802 el = &group->el[group->nr++]; 803 memset(el, 0, sizeof(*el)); 804 el->src = src; 805 return el; 806} 807 808/* 809 * Used to set up core.excludesfile and .git/info/exclude lists. 810 */ 811static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname, 812 struct sha1_stat *sha1_stat) 813{ 814 struct exclude_list *el; 815 /* 816 * catch setup_standard_excludes() that's called before 817 * dir->untracked is assigned. That function behaves 818 * differently when dir->untracked is non-NULL. 819 */ 820 if (!dir->untracked) 821 dir->unmanaged_exclude_files++; 822 el = add_exclude_list(dir, EXC_FILE, fname); 823 if (add_excludes(fname, "", 0, el, 0, sha1_stat) < 0) 824 die("cannot use %s as an exclude file", fname); 825} 826 827void add_excludes_from_file(struct dir_struct *dir, const char *fname) 828{ 829 dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */ 830 add_excludes_from_file_1(dir, fname, NULL); 831} 832 833int match_basename(const char *basename, int basenamelen, 834 const char *pattern, int prefix, int patternlen, 835 unsigned flags) 836{ 837 if (prefix == patternlen) { 838 if (patternlen == basenamelen && 839 !fspathncmp(pattern, basename, basenamelen)) 840 return 1; 841 } else if (flags & EXC_FLAG_ENDSWITH) { 842 /* "*literal" matching against "fooliteral" */ 843 if (patternlen - 1 <= basenamelen && 844 !fspathncmp(pattern + 1, 845 basename + basenamelen - (patternlen - 1), 846 patternlen - 1)) 847 return 1; 848 } else { 849 if (fnmatch_icase_mem(pattern, patternlen, 850 basename, basenamelen, 851 0) == 0) 852 return 1; 853 } 854 return 0; 855} 856 857int match_pathname(const char *pathname, int pathlen, 858 const char *base, int baselen, 859 const char *pattern, int prefix, int patternlen, 860 unsigned flags) 861{ 862 const char *name; 863 int namelen; 864 865 /* 866 * match with FNM_PATHNAME; the pattern has base implicitly 867 * in front of it. 868 */ 869 if (*pattern == '/') { 870 pattern++; 871 patternlen--; 872 prefix--; 873 } 874 875 /* 876 * baselen does not count the trailing slash. base[] may or 877 * may not end with a trailing slash though. 878 */ 879 if (pathlen < baselen + 1 || 880 (baselen && pathname[baselen] != '/') || 881 fspathncmp(pathname, base, baselen)) 882 return 0; 883 884 namelen = baselen ? pathlen - baselen - 1 : pathlen; 885 name = pathname + pathlen - namelen; 886 887 if (prefix) { 888 /* 889 * if the non-wildcard part is longer than the 890 * remaining pathname, surely it cannot match. 891 */ 892 if (prefix > namelen) 893 return 0; 894 895 if (fspathncmp(pattern, name, prefix)) 896 return 0; 897 pattern += prefix; 898 patternlen -= prefix; 899 name += prefix; 900 namelen -= prefix; 901 902 /* 903 * If the whole pattern did not have a wildcard, 904 * then our prefix match is all we need; we 905 * do not need to call fnmatch at all. 906 */ 907 if (!patternlen && !namelen) 908 return 1; 909 } 910 911 return fnmatch_icase_mem(pattern, patternlen, 912 name, namelen, 913 WM_PATHNAME) == 0; 914} 915 916/* 917 * Scan the given exclude list in reverse to see whether pathname 918 * should be ignored. The first match (i.e. the last on the list), if 919 * any, determines the fate. Returns the exclude_list element which 920 * matched, or NULL for undecided. 921 */ 922static struct exclude *last_exclude_matching_from_list(const char *pathname, 923 int pathlen, 924 const char *basename, 925 int *dtype, 926 struct exclude_list *el) 927{ 928 struct exclude *exc = NULL; /* undecided */ 929 int i; 930 931 if (!el->nr) 932 return NULL; /* undefined */ 933 934 for (i = el->nr - 1; 0 <= i; i--) { 935 struct exclude *x = el->excludes[i]; 936 const char *exclude = x->pattern; 937 int prefix = x->nowildcardlen; 938 939 if (x->flags & EXC_FLAG_MUSTBEDIR) { 940 if (*dtype == DT_UNKNOWN) 941 *dtype = get_dtype(NULL, pathname, pathlen); 942 if (*dtype != DT_DIR) 943 continue; 944 } 945 946 if (x->flags & EXC_FLAG_NODIR) { 947 if (match_basename(basename, 948 pathlen - (basename - pathname), 949 exclude, prefix, x->patternlen, 950 x->flags)) { 951 exc = x; 952 break; 953 } 954 continue; 955 } 956 957 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/'); 958 if (match_pathname(pathname, pathlen, 959 x->base, x->baselen ? x->baselen - 1 : 0, 960 exclude, prefix, x->patternlen, x->flags)) { 961 exc = x; 962 break; 963 } 964 } 965 return exc; 966} 967 968/* 969 * Scan the list and let the last match determine the fate. 970 * Return 1 for exclude, 0 for include and -1 for undecided. 971 */ 972int is_excluded_from_list(const char *pathname, 973 int pathlen, const char *basename, int *dtype, 974 struct exclude_list *el) 975{ 976 struct exclude *exclude; 977 exclude = last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el); 978 if (exclude) 979 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 980 return -1; /* undecided */ 981} 982 983static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir, 984 const char *pathname, int pathlen, const char *basename, 985 int *dtype_p) 986{ 987 int i, j; 988 struct exclude_list_group *group; 989 struct exclude *exclude; 990 for (i = EXC_CMDL; i <= EXC_FILE; i++) { 991 group = &dir->exclude_list_group[i]; 992 for (j = group->nr - 1; j >= 0; j--) { 993 exclude = last_exclude_matching_from_list( 994 pathname, pathlen, basename, dtype_p, 995 &group->el[j]); 996 if (exclude) 997 return exclude; 998 } 999 }1000 return NULL;1001}10021003/*1004 * Loads the per-directory exclude list for the substring of base1005 * which has a char length of baselen.1006 */1007static void prep_exclude(struct dir_struct *dir, const char *base, int baselen)1008{1009 struct exclude_list_group *group;1010 struct exclude_list *el;1011 struct exclude_stack *stk = NULL;1012 struct untracked_cache_dir *untracked;1013 int current;10141015 group = &dir->exclude_list_group[EXC_DIRS];10161017 /*1018 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1019 * which originate from directories not in the prefix of the1020 * path being checked.1021 */1022 while ((stk = dir->exclude_stack) != NULL) {1023 if (stk->baselen <= baselen &&1024 !strncmp(dir->basebuf.buf, base, stk->baselen))1025 break;1026 el = &group->el[dir->exclude_stack->exclude_ix];1027 dir->exclude_stack = stk->prev;1028 dir->exclude = NULL;1029 free((char *)el->src); /* see strbuf_detach() below */1030 clear_exclude_list(el);1031 free(stk);1032 group->nr--;1033 }10341035 /* Skip traversing into sub directories if the parent is excluded */1036 if (dir->exclude)1037 return;10381039 /*1040 * Lazy initialization. All call sites currently just1041 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1042 * them seems lots of work for little benefit.1043 */1044 if (!dir->basebuf.buf)1045 strbuf_init(&dir->basebuf, PATH_MAX);10461047 /* Read from the parent directories and push them down. */1048 current = stk ? stk->baselen : -1;1049 strbuf_setlen(&dir->basebuf, current < 0 ? 0 : current);1050 if (dir->untracked)1051 untracked = stk ? stk->ucd : dir->untracked->root;1052 else1053 untracked = NULL;10541055 while (current < baselen) {1056 const char *cp;1057 struct sha1_stat sha1_stat;10581059 stk = xcalloc(1, sizeof(*stk));1060 if (current < 0) {1061 cp = base;1062 current = 0;1063 } else {1064 cp = strchr(base + current + 1, '/');1065 if (!cp)1066 die("oops in prep_exclude");1067 cp++;1068 untracked =1069 lookup_untracked(dir->untracked, untracked,1070 base + current,1071 cp - base - current);1072 }1073 stk->prev = dir->exclude_stack;1074 stk->baselen = cp - base;1075 stk->exclude_ix = group->nr;1076 stk->ucd = untracked;1077 el = add_exclude_list(dir, EXC_DIRS, NULL);1078 strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1079 assert(stk->baselen == dir->basebuf.len);10801081 /* Abort if the directory is excluded */1082 if (stk->baselen) {1083 int dt = DT_DIR;1084 dir->basebuf.buf[stk->baselen - 1] = 0;1085 dir->exclude = last_exclude_matching_from_lists(dir,1086 dir->basebuf.buf, stk->baselen - 1,1087 dir->basebuf.buf + current, &dt);1088 dir->basebuf.buf[stk->baselen - 1] = '/';1089 if (dir->exclude &&1090 dir->exclude->flags & EXC_FLAG_NEGATIVE)1091 dir->exclude = NULL;1092 if (dir->exclude) {1093 dir->exclude_stack = stk;1094 return;1095 }1096 }10971098 /* Try to read per-directory file */1099 hashclr(sha1_stat.sha1);1100 sha1_stat.valid = 0;1101 if (dir->exclude_per_dir &&1102 /*1103 * If we know that no files have been added in1104 * this directory (i.e. valid_cached_dir() has1105 * been executed and set untracked->valid) ..1106 */1107 (!untracked || !untracked->valid ||1108 /*1109 * .. and .gitignore does not exist before1110 * (i.e. null exclude_sha1). Then we can skip1111 * loading .gitignore, which would result in1112 * ENOENT anyway.1113 */1114 !is_null_sha1(untracked->exclude_sha1))) {1115 /*1116 * dir->basebuf gets reused by the traversal, but we1117 * need fname to remain unchanged to ensure the src1118 * member of each struct exclude correctly1119 * back-references its source file. Other invocations1120 * of add_exclude_list provide stable strings, so we1121 * strbuf_detach() and free() here in the caller.1122 */1123 struct strbuf sb = STRBUF_INIT;1124 strbuf_addbuf(&sb, &dir->basebuf);1125 strbuf_addstr(&sb, dir->exclude_per_dir);1126 el->src = strbuf_detach(&sb, NULL);1127 add_excludes(el->src, el->src, stk->baselen, el, 1,1128 untracked ? &sha1_stat : NULL);1129 }1130 /*1131 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1132 * will first be called in valid_cached_dir() then maybe many1133 * times more in last_exclude_matching(). When the cache is1134 * used, last_exclude_matching() will not be called and1135 * reading .gitignore content will be a waste.1136 *1137 * So when it's called by valid_cached_dir() and we can get1138 * .gitignore SHA-1 from the index (i.e. .gitignore is not1139 * modified on work tree), we could delay reading the1140 * .gitignore content until we absolutely need it in1141 * last_exclude_matching(). Be careful about ignore rule1142 * order, though, if you do that.1143 */1144 if (untracked &&1145 hashcmp(sha1_stat.sha1, untracked->exclude_sha1)) {1146 invalidate_gitignore(dir->untracked, untracked);1147 hashcpy(untracked->exclude_sha1, sha1_stat.sha1);1148 }1149 dir->exclude_stack = stk;1150 current = stk->baselen;1151 }1152 strbuf_setlen(&dir->basebuf, baselen);1153}11541155/*1156 * Loads the exclude lists for the directory containing pathname, then1157 * scans all exclude lists to determine whether pathname is excluded.1158 * Returns the exclude_list element which matched, or NULL for1159 * undecided.1160 */1161struct exclude *last_exclude_matching(struct dir_struct *dir,1162 const char *pathname,1163 int *dtype_p)1164{1165 int pathlen = strlen(pathname);1166 const char *basename = strrchr(pathname, '/');1167 basename = (basename) ? basename+1 : pathname;11681169 prep_exclude(dir, pathname, basename-pathname);11701171 if (dir->exclude)1172 return dir->exclude;11731174 return last_exclude_matching_from_lists(dir, pathname, pathlen,1175 basename, dtype_p);1176}11771178/*1179 * Loads the exclude lists for the directory containing pathname, then1180 * scans all exclude lists to determine whether pathname is excluded.1181 * Returns 1 if true, otherwise 0.1182 */1183int is_excluded(struct dir_struct *dir, const char *pathname, int *dtype_p)1184{1185 struct exclude *exclude =1186 last_exclude_matching(dir, pathname, dtype_p);1187 if (exclude)1188 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1189 return 0;1190}11911192static struct dir_entry *dir_entry_new(const char *pathname, int len)1193{1194 struct dir_entry *ent;11951196 FLEX_ALLOC_MEM(ent, name, pathname, len);1197 ent->len = len;1198 return ent;1199}12001201static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len)1202{1203 if (cache_file_exists(pathname, len, ignore_case))1204 return NULL;12051206 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1207 return dir->entries[dir->nr++] = dir_entry_new(pathname, len);1208}12091210struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len)1211{1212 if (!cache_name_is_other(pathname, len))1213 return NULL;12141215 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1216 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);1217}12181219enum exist_status {1220 index_nonexistent = 0,1221 index_directory,1222 index_gitdir1223};12241225/*1226 * Do not use the alphabetically sorted index to look up1227 * the directory name; instead, use the case insensitive1228 * directory hash.1229 */1230static enum exist_status directory_exists_in_index_icase(const char *dirname, int len)1231{1232 struct cache_entry *ce;12331234 if (cache_dir_exists(dirname, len))1235 return index_directory;12361237 ce = cache_file_exists(dirname, len, ignore_case);1238 if (ce && S_ISGITLINK(ce->ce_mode))1239 return index_gitdir;12401241 return index_nonexistent;1242}12431244/*1245 * The index sorts alphabetically by entry name, which1246 * means that a gitlink sorts as '\0' at the end, while1247 * a directory (which is defined not as an entry, but as1248 * the files it contains) will sort with the '/' at the1249 * end.1250 */1251static enum exist_status directory_exists_in_index(const char *dirname, int len)1252{1253 int pos;12541255 if (ignore_case)1256 return directory_exists_in_index_icase(dirname, len);12571258 pos = cache_name_pos(dirname, len);1259 if (pos < 0)1260 pos = -pos-1;1261 while (pos < active_nr) {1262 const struct cache_entry *ce = active_cache[pos++];1263 unsigned char endchar;12641265 if (strncmp(ce->name, dirname, len))1266 break;1267 endchar = ce->name[len];1268 if (endchar > '/')1269 break;1270 if (endchar == '/')1271 return index_directory;1272 if (!endchar && S_ISGITLINK(ce->ce_mode))1273 return index_gitdir;1274 }1275 return index_nonexistent;1276}12771278/*1279 * When we find a directory when traversing the filesystem, we1280 * have three distinct cases:1281 *1282 * - ignore it1283 * - see it as a directory1284 * - recurse into it1285 *1286 * and which one we choose depends on a combination of existing1287 * git index contents and the flags passed into the directory1288 * traversal routine.1289 *1290 * Case 1: If we *already* have entries in the index under that1291 * directory name, we always recurse into the directory to see1292 * all the files.1293 *1294 * Case 2: If we *already* have that directory name as a gitlink,1295 * we always continue to see it as a gitlink, regardless of whether1296 * there is an actual git directory there or not (it might not1297 * be checked out as a subproject!)1298 *1299 * Case 3: if we didn't have it in the index previously, we1300 * have a few sub-cases:1301 *1302 * (a) if "show_other_directories" is true, we show it as1303 * just a directory, unless "hide_empty_directories" is1304 * also true, in which case we need to check if it contains any1305 * untracked and / or ignored files.1306 * (b) if it looks like a git directory, and we don't have1307 * 'no_gitlinks' set we treat it as a gitlink, and show it1308 * as a directory.1309 * (c) otherwise, we recurse into it.1310 */1311static enum path_treatment treat_directory(struct dir_struct *dir,1312 struct untracked_cache_dir *untracked,1313 const char *dirname, int len, int baselen, int exclude,1314 const struct pathspec *pathspec)1315{1316 /* The "len-1" is to strip the final '/' */1317 switch (directory_exists_in_index(dirname, len-1)) {1318 case index_directory:1319 return path_recurse;13201321 case index_gitdir:1322 return path_none;13231324 case index_nonexistent:1325 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1326 break;1327 if (!(dir->flags & DIR_NO_GITLINKS)) {1328 unsigned char sha1[20];1329 if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)1330 return path_untracked;1331 }1332 return path_recurse;1333 }13341335 /* This is the "show_other_directories" case */13361337 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1338 return exclude ? path_excluded : path_untracked;13391340 untracked = lookup_untracked(dir->untracked, untracked,1341 dirname + baselen, len - baselen);1342 return read_directory_recursive(dir, dirname, len,1343 untracked, 1, pathspec);1344}13451346/*1347 * This is an inexact early pruning of any recursive directory1348 * reading - if the path cannot possibly be in the pathspec,1349 * return true, and we'll skip it early.1350 */1351static int simplify_away(const char *path, int pathlen,1352 const struct pathspec *pathspec)1353{1354 int i;13551356 if (!pathspec || !pathspec->nr)1357 return 0;13581359 GUARD_PATHSPEC(pathspec,1360 PATHSPEC_FROMTOP |1361 PATHSPEC_MAXDEPTH |1362 PATHSPEC_LITERAL |1363 PATHSPEC_GLOB |1364 PATHSPEC_ICASE |1365 PATHSPEC_EXCLUDE);13661367 for (i = 0; i < pathspec->nr; i++) {1368 const struct pathspec_item *item = &pathspec->items[i];1369 int len = item->nowildcard_len;13701371 if (len > pathlen)1372 len = pathlen;1373 if (!ps_strncmp(item, item->match, path, len))1374 return 0;1375 }13761377 return 1;1378}13791380/*1381 * This function tells us whether an excluded path matches a1382 * list of "interesting" pathspecs. That is, whether a path matched1383 * by any of the pathspecs could possibly be ignored by excluding1384 * the specified path. This can happen if:1385 *1386 * 1. the path is mentioned explicitly in the pathspec1387 *1388 * 2. the path is a directory prefix of some element in the1389 * pathspec1390 */1391static int exclude_matches_pathspec(const char *path, int pathlen,1392 const struct pathspec *pathspec)1393{1394 int i;13951396 if (!pathspec || !pathspec->nr)1397 return 0;13981399 GUARD_PATHSPEC(pathspec,1400 PATHSPEC_FROMTOP |1401 PATHSPEC_MAXDEPTH |1402 PATHSPEC_LITERAL |1403 PATHSPEC_GLOB |1404 PATHSPEC_ICASE |1405 PATHSPEC_EXCLUDE);14061407 for (i = 0; i < pathspec->nr; i++) {1408 const struct pathspec_item *item = &pathspec->items[i];1409 int len = item->nowildcard_len;14101411 if (len == pathlen &&1412 !ps_strncmp(item, item->match, path, pathlen))1413 return 1;1414 if (len > pathlen &&1415 item->match[pathlen] == '/' &&1416 !ps_strncmp(item, item->match, path, pathlen))1417 return 1;1418 }1419 return 0;1420}14211422static int get_index_dtype(const char *path, int len)1423{1424 int pos;1425 const struct cache_entry *ce;14261427 ce = cache_file_exists(path, len, 0);1428 if (ce) {1429 if (!ce_uptodate(ce))1430 return DT_UNKNOWN;1431 if (S_ISGITLINK(ce->ce_mode))1432 return DT_DIR;1433 /*1434 * Nobody actually cares about the1435 * difference between DT_LNK and DT_REG1436 */1437 return DT_REG;1438 }14391440 /* Try to look it up as a directory */1441 pos = cache_name_pos(path, len);1442 if (pos >= 0)1443 return DT_UNKNOWN;1444 pos = -pos-1;1445 while (pos < active_nr) {1446 ce = active_cache[pos++];1447 if (strncmp(ce->name, path, len))1448 break;1449 if (ce->name[len] > '/')1450 break;1451 if (ce->name[len] < '/')1452 continue;1453 if (!ce_uptodate(ce))1454 break; /* continue? */1455 return DT_DIR;1456 }1457 return DT_UNKNOWN;1458}14591460static int get_dtype(struct dirent *de, const char *path, int len)1461{1462 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1463 struct stat st;14641465 if (dtype != DT_UNKNOWN)1466 return dtype;1467 dtype = get_index_dtype(path, len);1468 if (dtype != DT_UNKNOWN)1469 return dtype;1470 if (lstat(path, &st))1471 return dtype;1472 if (S_ISREG(st.st_mode))1473 return DT_REG;1474 if (S_ISDIR(st.st_mode))1475 return DT_DIR;1476 if (S_ISLNK(st.st_mode))1477 return DT_LNK;1478 return dtype;1479}14801481static enum path_treatment treat_one_path(struct dir_struct *dir,1482 struct untracked_cache_dir *untracked,1483 struct strbuf *path,1484 int baselen,1485 const struct pathspec *pathspec,1486 int dtype, struct dirent *de)1487{1488 int exclude;1489 int has_path_in_index = !!cache_file_exists(path->buf, path->len, ignore_case);14901491 if (dtype == DT_UNKNOWN)1492 dtype = get_dtype(de, path->buf, path->len);14931494 /* Always exclude indexed files */1495 if (dtype != DT_DIR && has_path_in_index)1496 return path_none;14971498 /*1499 * When we are looking at a directory P in the working tree,1500 * there are three cases:1501 *1502 * (1) P exists in the index. Everything inside the directory P in1503 * the working tree needs to go when P is checked out from the1504 * index.1505 *1506 * (2) P does not exist in the index, but there is P/Q in the index.1507 * We know P will stay a directory when we check out the contents1508 * of the index, but we do not know yet if there is a directory1509 * P/Q in the working tree to be killed, so we need to recurse.1510 *1511 * (3) P does not exist in the index, and there is no P/Q in the index1512 * to require P to be a directory, either. Only in this case, we1513 * know that everything inside P will not be killed without1514 * recursing.1515 */1516 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1517 (dtype == DT_DIR) &&1518 !has_path_in_index &&1519 (directory_exists_in_index(path->buf, path->len) == index_nonexistent))1520 return path_none;15211522 exclude = is_excluded(dir, path->buf, &dtype);15231524 /*1525 * Excluded? If we don't explicitly want to show1526 * ignored files, ignore it1527 */1528 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1529 return path_excluded;15301531 switch (dtype) {1532 default:1533 return path_none;1534 case DT_DIR:1535 strbuf_addch(path, '/');1536 return treat_directory(dir, untracked, path->buf, path->len,1537 baselen, exclude, pathspec);1538 case DT_REG:1539 case DT_LNK:1540 return exclude ? path_excluded : path_untracked;1541 }1542}15431544static enum path_treatment treat_path_fast(struct dir_struct *dir,1545 struct untracked_cache_dir *untracked,1546 struct cached_dir *cdir,1547 struct strbuf *path,1548 int baselen,1549 const struct pathspec *pathspec)1550{1551 strbuf_setlen(path, baselen);1552 if (!cdir->ucd) {1553 strbuf_addstr(path, cdir->file);1554 return path_untracked;1555 }1556 strbuf_addstr(path, cdir->ucd->name);1557 /* treat_one_path() does this before it calls treat_directory() */1558 strbuf_complete(path, '/');1559 if (cdir->ucd->check_only)1560 /*1561 * check_only is set as a result of treat_directory() getting1562 * to its bottom. Verify again the same set of directories1563 * with check_only set.1564 */1565 return read_directory_recursive(dir, path->buf, path->len,1566 cdir->ucd, 1, pathspec);1567 /*1568 * We get path_recurse in the first run when1569 * directory_exists_in_index() returns index_nonexistent. We1570 * are sure that new changes in the index does not impact the1571 * outcome. Return now.1572 */1573 return path_recurse;1574}15751576static enum path_treatment treat_path(struct dir_struct *dir,1577 struct untracked_cache_dir *untracked,1578 struct cached_dir *cdir,1579 struct strbuf *path,1580 int baselen,1581 const struct pathspec *pathspec)1582{1583 int dtype;1584 struct dirent *de = cdir->de;15851586 if (!de)1587 return treat_path_fast(dir, untracked, cdir, path,1588 baselen, pathspec);1589 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))1590 return path_none;1591 strbuf_setlen(path, baselen);1592 strbuf_addstr(path, de->d_name);1593 if (simplify_away(path->buf, path->len, pathspec))1594 return path_none;15951596 dtype = DTYPE(de);1597 return treat_one_path(dir, untracked, path, baselen, pathspec, dtype, de);1598}15991600static void add_untracked(struct untracked_cache_dir *dir, const char *name)1601{1602 if (!dir)1603 return;1604 ALLOC_GROW(dir->untracked, dir->untracked_nr + 1,1605 dir->untracked_alloc);1606 dir->untracked[dir->untracked_nr++] = xstrdup(name);1607}16081609static int valid_cached_dir(struct dir_struct *dir,1610 struct untracked_cache_dir *untracked,1611 struct strbuf *path,1612 int check_only)1613{1614 struct stat st;16151616 if (!untracked)1617 return 0;16181619 if (stat(path->len ? path->buf : ".", &st)) {1620 invalidate_directory(dir->untracked, untracked);1621 memset(&untracked->stat_data, 0, sizeof(untracked->stat_data));1622 return 0;1623 }1624 if (!untracked->valid ||1625 match_stat_data_racy(&the_index, &untracked->stat_data, &st)) {1626 if (untracked->valid)1627 invalidate_directory(dir->untracked, untracked);1628 fill_stat_data(&untracked->stat_data, &st);1629 return 0;1630 }16311632 if (untracked->check_only != !!check_only) {1633 invalidate_directory(dir->untracked, untracked);1634 return 0;1635 }16361637 /*1638 * prep_exclude will be called eventually on this directory,1639 * but it's called much later in last_exclude_matching(). We1640 * need it now to determine the validity of the cache for this1641 * path. The next calls will be nearly no-op, the way1642 * prep_exclude() is designed.1643 */1644 if (path->len && path->buf[path->len - 1] != '/') {1645 strbuf_addch(path, '/');1646 prep_exclude(dir, path->buf, path->len);1647 strbuf_setlen(path, path->len - 1);1648 } else1649 prep_exclude(dir, path->buf, path->len);16501651 /* hopefully prep_exclude() haven't invalidated this entry... */1652 return untracked->valid;1653}16541655static int open_cached_dir(struct cached_dir *cdir,1656 struct dir_struct *dir,1657 struct untracked_cache_dir *untracked,1658 struct strbuf *path,1659 int check_only)1660{1661 memset(cdir, 0, sizeof(*cdir));1662 cdir->untracked = untracked;1663 if (valid_cached_dir(dir, untracked, path, check_only))1664 return 0;1665 cdir->fdir = opendir(path->len ? path->buf : ".");1666 if (dir->untracked)1667 dir->untracked->dir_opened++;1668 if (!cdir->fdir)1669 return -1;1670 return 0;1671}16721673static int read_cached_dir(struct cached_dir *cdir)1674{1675 if (cdir->fdir) {1676 cdir->de = readdir(cdir->fdir);1677 if (!cdir->de)1678 return -1;1679 return 0;1680 }1681 while (cdir->nr_dirs < cdir->untracked->dirs_nr) {1682 struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1683 if (!d->recurse) {1684 cdir->nr_dirs++;1685 continue;1686 }1687 cdir->ucd = d;1688 cdir->nr_dirs++;1689 return 0;1690 }1691 cdir->ucd = NULL;1692 if (cdir->nr_files < cdir->untracked->untracked_nr) {1693 struct untracked_cache_dir *d = cdir->untracked;1694 cdir->file = d->untracked[cdir->nr_files++];1695 return 0;1696 }1697 return -1;1698}16991700static void close_cached_dir(struct cached_dir *cdir)1701{1702 if (cdir->fdir)1703 closedir(cdir->fdir);1704 /*1705 * We have gone through this directory and found no untracked1706 * entries. Mark it valid.1707 */1708 if (cdir->untracked) {1709 cdir->untracked->valid = 1;1710 cdir->untracked->recurse = 1;1711 }1712}17131714/*1715 * Read a directory tree. We currently ignore anything but1716 * directories, regular files and symlinks. That's because git1717 * doesn't handle them at all yet. Maybe that will change some1718 * day.1719 *1720 * Also, we ignore the name ".git" (even if it is not a directory).1721 * That likely will not change.1722 *1723 * Returns the most significant path_treatment value encountered in the scan.1724 */1725static enum path_treatment read_directory_recursive(struct dir_struct *dir,1726 const char *base, int baselen,1727 struct untracked_cache_dir *untracked, int check_only,1728 const struct pathspec *pathspec)1729{1730 struct cached_dir cdir;1731 enum path_treatment state, subdir_state, dir_state = path_none;1732 struct strbuf path = STRBUF_INIT;17331734 strbuf_add(&path, base, baselen);17351736 if (open_cached_dir(&cdir, dir, untracked, &path, check_only))1737 goto out;17381739 if (untracked)1740 untracked->check_only = !!check_only;17411742 while (!read_cached_dir(&cdir)) {1743 /* check how the file or directory should be treated */1744 state = treat_path(dir, untracked, &cdir, &path,1745 baselen, pathspec);17461747 if (state > dir_state)1748 dir_state = state;17491750 /* recurse into subdir if instructed by treat_path */1751 if (state == path_recurse) {1752 struct untracked_cache_dir *ud;1753 ud = lookup_untracked(dir->untracked, untracked,1754 path.buf + baselen,1755 path.len - baselen);1756 subdir_state =1757 read_directory_recursive(dir, path.buf,1758 path.len, ud,1759 check_only, pathspec);1760 if (subdir_state > dir_state)1761 dir_state = subdir_state;1762 }17631764 if (check_only) {1765 /* abort early if maximum state has been reached */1766 if (dir_state == path_untracked) {1767 if (cdir.fdir)1768 add_untracked(untracked, path.buf + baselen);1769 break;1770 }1771 /* skip the dir_add_* part */1772 continue;1773 }17741775 /* add the path to the appropriate result list */1776 switch (state) {1777 case path_excluded:1778 if (dir->flags & DIR_SHOW_IGNORED)1779 dir_add_name(dir, path.buf, path.len);1780 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||1781 ((dir->flags & DIR_COLLECT_IGNORED) &&1782 exclude_matches_pathspec(path.buf, path.len,1783 pathspec)))1784 dir_add_ignored(dir, path.buf, path.len);1785 break;17861787 case path_untracked:1788 if (dir->flags & DIR_SHOW_IGNORED)1789 break;1790 dir_add_name(dir, path.buf, path.len);1791 if (cdir.fdir)1792 add_untracked(untracked, path.buf + baselen);1793 break;17941795 default:1796 break;1797 }1798 }1799 close_cached_dir(&cdir);1800 out:1801 strbuf_release(&path);18021803 return dir_state;1804}18051806static int cmp_name(const void *p1, const void *p2)1807{1808 const struct dir_entry *e1 = *(const struct dir_entry **)p1;1809 const struct dir_entry *e2 = *(const struct dir_entry **)p2;18101811 return name_compare(e1->name, e1->len, e2->name, e2->len);1812}18131814static int treat_leading_path(struct dir_struct *dir,1815 const char *path, int len,1816 const struct pathspec *pathspec)1817{1818 struct strbuf sb = STRBUF_INIT;1819 int baselen, rc = 0;1820 const char *cp;1821 int old_flags = dir->flags;18221823 while (len && path[len - 1] == '/')1824 len--;1825 if (!len)1826 return 1;1827 baselen = 0;1828 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1829 while (1) {1830 cp = path + baselen + !!baselen;1831 cp = memchr(cp, '/', path + len - cp);1832 if (!cp)1833 baselen = len;1834 else1835 baselen = cp - path;1836 strbuf_setlen(&sb, 0);1837 strbuf_add(&sb, path, baselen);1838 if (!is_directory(sb.buf))1839 break;1840 if (simplify_away(sb.buf, sb.len, pathspec))1841 break;1842 if (treat_one_path(dir, NULL, &sb, baselen, pathspec,1843 DT_DIR, NULL) == path_none)1844 break; /* do not recurse into it */1845 if (len <= baselen) {1846 rc = 1;1847 break; /* finished checking */1848 }1849 }1850 strbuf_release(&sb);1851 dir->flags = old_flags;1852 return rc;1853}18541855static const char *get_ident_string(void)1856{1857 static struct strbuf sb = STRBUF_INIT;1858 struct utsname uts;18591860 if (sb.len)1861 return sb.buf;1862 if (uname(&uts) < 0)1863 die_errno(_("failed to get kernel name and information"));1864 strbuf_addf(&sb, "Location %s, system %s", get_git_work_tree(),1865 uts.sysname);1866 return sb.buf;1867}18681869static int ident_in_untracked(const struct untracked_cache *uc)1870{1871 /*1872 * Previous git versions may have saved many NUL separated1873 * strings in the "ident" field, but it is insane to manage1874 * many locations, so just take care of the first one.1875 */18761877 return !strcmp(uc->ident.buf, get_ident_string());1878}18791880static void set_untracked_ident(struct untracked_cache *uc)1881{1882 strbuf_reset(&uc->ident);1883 strbuf_addstr(&uc->ident, get_ident_string());18841885 /*1886 * This strbuf used to contain a list of NUL separated1887 * strings, so save NUL too for backward compatibility.1888 */1889 strbuf_addch(&uc->ident, 0);1890}18911892static void new_untracked_cache(struct index_state *istate)1893{1894 struct untracked_cache *uc = xcalloc(1, sizeof(*uc));1895 strbuf_init(&uc->ident, 100);1896 uc->exclude_per_dir = ".gitignore";1897 /* should be the same flags used by git-status */1898 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;1899 set_untracked_ident(uc);1900 istate->untracked = uc;1901 istate->cache_changed |= UNTRACKED_CHANGED;1902}19031904void add_untracked_cache(struct index_state *istate)1905{1906 if (!istate->untracked) {1907 new_untracked_cache(istate);1908 } else {1909 if (!ident_in_untracked(istate->untracked)) {1910 free_untracked_cache(istate->untracked);1911 new_untracked_cache(istate);1912 }1913 }1914}19151916void remove_untracked_cache(struct index_state *istate)1917{1918 if (istate->untracked) {1919 free_untracked_cache(istate->untracked);1920 istate->untracked = NULL;1921 istate->cache_changed |= UNTRACKED_CHANGED;1922 }1923}19241925static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,1926 int base_len,1927 const struct pathspec *pathspec)1928{1929 struct untracked_cache_dir *root;19301931 if (!dir->untracked || getenv("GIT_DISABLE_UNTRACKED_CACHE"))1932 return NULL;19331934 /*1935 * We only support $GIT_DIR/info/exclude and core.excludesfile1936 * as the global ignore rule files. Any other additions1937 * (e.g. from command line) invalidate the cache. This1938 * condition also catches running setup_standard_excludes()1939 * before setting dir->untracked!1940 */1941 if (dir->unmanaged_exclude_files)1942 return NULL;19431944 /*1945 * Optimize for the main use case only: whole-tree git1946 * status. More work involved in treat_leading_path() if we1947 * use cache on just a subset of the worktree. pathspec1948 * support could make the matter even worse.1949 */1950 if (base_len || (pathspec && pathspec->nr))1951 return NULL;19521953 /* Different set of flags may produce different results */1954 if (dir->flags != dir->untracked->dir_flags ||1955 /*1956 * See treat_directory(), case index_nonexistent. Without1957 * this flag, we may need to also cache .git file content1958 * for the resolve_gitlink_ref() call, which we don't.1959 */1960 !(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||1961 /* We don't support collecting ignore files */1962 (dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |1963 DIR_COLLECT_IGNORED)))1964 return NULL;19651966 /*1967 * If we use .gitignore in the cache and now you change it to1968 * .gitexclude, everything will go wrong.1969 */1970 if (dir->exclude_per_dir != dir->untracked->exclude_per_dir &&1971 strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))1972 return NULL;19731974 /*1975 * EXC_CMDL is not considered in the cache. If people set it,1976 * skip the cache.1977 */1978 if (dir->exclude_list_group[EXC_CMDL].nr)1979 return NULL;19801981 if (!ident_in_untracked(dir->untracked)) {1982 warning(_("Untracked cache is disabled on this system or location."));1983 return NULL;1984 }19851986 if (!dir->untracked->root) {1987 const int len = sizeof(*dir->untracked->root);1988 dir->untracked->root = xmalloc(len);1989 memset(dir->untracked->root, 0, len);1990 }19911992 /* Validate $GIT_DIR/info/exclude and core.excludesfile */1993 root = dir->untracked->root;1994 if (hashcmp(dir->ss_info_exclude.sha1,1995 dir->untracked->ss_info_exclude.sha1)) {1996 invalidate_gitignore(dir->untracked, root);1997 dir->untracked->ss_info_exclude = dir->ss_info_exclude;1998 }1999 if (hashcmp(dir->ss_excludes_file.sha1,2000 dir->untracked->ss_excludes_file.sha1)) {2001 invalidate_gitignore(dir->untracked, root);2002 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2003 }20042005 /* Make sure this directory is not dropped out at saving phase */2006 root->recurse = 1;2007 return root;2008}20092010int read_directory(struct dir_struct *dir, const char *path,2011 int len, const struct pathspec *pathspec)2012{2013 struct untracked_cache_dir *untracked;20142015 if (has_symlink_leading_path(path, len))2016 return dir->nr;20172018 untracked = validate_untracked_cache(dir, len, pathspec);2019 if (!untracked)2020 /*2021 * make sure untracked cache code path is disabled,2022 * e.g. prep_exclude()2023 */2024 dir->untracked = NULL;2025 if (!len || treat_leading_path(dir, path, len, pathspec))2026 read_directory_recursive(dir, path, len, untracked, 0, pathspec);2027 QSORT(dir->entries, dir->nr, cmp_name);2028 QSORT(dir->ignored, dir->ignored_nr, cmp_name);2029 if (dir->untracked) {2030 static struct trace_key trace_untracked_stats = TRACE_KEY_INIT(UNTRACKED_STATS);2031 trace_printf_key(&trace_untracked_stats,2032 "node creation: %u\n"2033 "gitignore invalidation: %u\n"2034 "directory invalidation: %u\n"2035 "opendir: %u\n",2036 dir->untracked->dir_created,2037 dir->untracked->gitignore_invalidated,2038 dir->untracked->dir_invalidated,2039 dir->untracked->dir_opened);2040 if (dir->untracked == the_index.untracked &&2041 (dir->untracked->dir_opened ||2042 dir->untracked->gitignore_invalidated ||2043 dir->untracked->dir_invalidated))2044 the_index.cache_changed |= UNTRACKED_CHANGED;2045 if (dir->untracked != the_index.untracked) {2046 free(dir->untracked);2047 dir->untracked = NULL;2048 }2049 }2050 return dir->nr;2051}20522053int file_exists(const char *f)2054{2055 struct stat sb;2056 return lstat(f, &sb) == 0;2057}20582059static int cmp_icase(char a, char b)2060{2061 if (a == b)2062 return 0;2063 if (ignore_case)2064 return toupper(a) - toupper(b);2065 return a - b;2066}20672068/*2069 * Given two normalized paths (a trailing slash is ok), if subdir is2070 * outside dir, return -1. Otherwise return the offset in subdir that2071 * can be used as relative path to dir.2072 */2073int dir_inside_of(const char *subdir, const char *dir)2074{2075 int offset = 0;20762077 assert(dir && subdir && *dir && *subdir);20782079 while (*dir && *subdir && !cmp_icase(*dir, *subdir)) {2080 dir++;2081 subdir++;2082 offset++;2083 }20842085 /* hel[p]/me vs hel[l]/yeah */2086 if (*dir && *subdir)2087 return -1;20882089 if (!*subdir)2090 return !*dir ? offset : -1; /* same dir */20912092 /* foo/[b]ar vs foo/[] */2093 if (is_dir_sep(dir[-1]))2094 return is_dir_sep(subdir[-1]) ? offset : -1;20952096 /* foo[/]bar vs foo[] */2097 return is_dir_sep(*subdir) ? offset + 1 : -1;2098}20992100int is_inside_dir(const char *dir)2101{2102 char *cwd;2103 int rc;21042105 if (!dir)2106 return 0;21072108 cwd = xgetcwd();2109 rc = (dir_inside_of(cwd, dir) >= 0);2110 free(cwd);2111 return rc;2112}21132114int is_empty_dir(const char *path)2115{2116 DIR *dir = opendir(path);2117 struct dirent *e;2118 int ret = 1;21192120 if (!dir)2121 return 0;21222123 while ((e = readdir(dir)) != NULL)2124 if (!is_dot_or_dotdot(e->d_name)) {2125 ret = 0;2126 break;2127 }21282129 closedir(dir);2130 return ret;2131}21322133static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)2134{2135 DIR *dir;2136 struct dirent *e;2137 int ret = 0, original_len = path->len, len, kept_down = 0;2138 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2139 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2140 unsigned char submodule_head[20];21412142 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2143 !resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {2144 /* Do not descend and nuke a nested git work tree. */2145 if (kept_up)2146 *kept_up = 1;2147 return 0;2148 }21492150 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2151 dir = opendir(path->buf);2152 if (!dir) {2153 if (errno == ENOENT)2154 return keep_toplevel ? -1 : 0;2155 else if (errno == EACCES && !keep_toplevel)2156 /*2157 * An empty dir could be removable even if it2158 * is unreadable:2159 */2160 return rmdir(path->buf);2161 else2162 return -1;2163 }2164 strbuf_complete(path, '/');21652166 len = path->len;2167 while ((e = readdir(dir)) != NULL) {2168 struct stat st;2169 if (is_dot_or_dotdot(e->d_name))2170 continue;21712172 strbuf_setlen(path, len);2173 strbuf_addstr(path, e->d_name);2174 if (lstat(path->buf, &st)) {2175 if (errno == ENOENT)2176 /*2177 * file disappeared, which is what we2178 * wanted anyway2179 */2180 continue;2181 /* fall thru */2182 } else if (S_ISDIR(st.st_mode)) {2183 if (!remove_dir_recurse(path, flag, &kept_down))2184 continue; /* happy */2185 } else if (!only_empty &&2186 (!unlink(path->buf) || errno == ENOENT)) {2187 continue; /* happy, too */2188 }21892190 /* path too long, stat fails, or non-directory still exists */2191 ret = -1;2192 break;2193 }2194 closedir(dir);21952196 strbuf_setlen(path, original_len);2197 if (!ret && !keep_toplevel && !kept_down)2198 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;2199 else if (kept_up)2200 /*2201 * report the uplevel that it is not an error that we2202 * did not rmdir() our directory.2203 */2204 *kept_up = !ret;2205 return ret;2206}22072208int remove_dir_recursively(struct strbuf *path, int flag)2209{2210 return remove_dir_recurse(path, flag, NULL);2211}22122213static GIT_PATH_FUNC(git_path_info_exclude, "info/exclude")22142215void setup_standard_excludes(struct dir_struct *dir)2216{2217 dir->exclude_per_dir = ".gitignore";22182219 /* core.excludefile defaulting to $XDG_HOME/git/ignore */2220 if (!excludes_file)2221 excludes_file = xdg_config_home("ignore");2222 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))2223 add_excludes_from_file_1(dir, excludes_file,2224 dir->untracked ? &dir->ss_excludes_file : NULL);22252226 /* per repository user preference */2227 if (startup_info->have_repository) {2228 const char *path = git_path_info_exclude();2229 if (!access_or_warn(path, R_OK, 0))2230 add_excludes_from_file_1(dir, path,2231 dir->untracked ? &dir->ss_info_exclude : NULL);2232 }2233}22342235int remove_path(const char *name)2236{2237 char *slash;22382239 if (unlink(name) && errno != ENOENT && errno != ENOTDIR)2240 return -1;22412242 slash = strrchr(name, '/');2243 if (slash) {2244 char *dirs = xstrdup(name);2245 slash = dirs + (slash - name);2246 do {2247 *slash = '\0';2248 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));2249 free(dirs);2250 }2251 return 0;2252}22532254/*2255 * Frees memory within dir which was allocated for exclude lists and2256 * the exclude_stack. Does not free dir itself.2257 */2258void clear_directory(struct dir_struct *dir)2259{2260 int i, j;2261 struct exclude_list_group *group;2262 struct exclude_list *el;2263 struct exclude_stack *stk;22642265 for (i = EXC_CMDL; i <= EXC_FILE; i++) {2266 group = &dir->exclude_list_group[i];2267 for (j = 0; j < group->nr; j++) {2268 el = &group->el[j];2269 if (i == EXC_DIRS)2270 free((char *)el->src);2271 clear_exclude_list(el);2272 }2273 free(group->el);2274 }22752276 stk = dir->exclude_stack;2277 while (stk) {2278 struct exclude_stack *prev = stk->prev;2279 free(stk);2280 stk = prev;2281 }2282 strbuf_release(&dir->basebuf);2283}22842285struct ondisk_untracked_cache {2286 struct stat_data info_exclude_stat;2287 struct stat_data excludes_file_stat;2288 uint32_t dir_flags;2289 unsigned char info_exclude_sha1[20];2290 unsigned char excludes_file_sha1[20];2291 char exclude_per_dir[FLEX_ARRAY];2292};22932294#define ouc_size(len) (offsetof(struct ondisk_untracked_cache, exclude_per_dir) + len + 1)22952296struct write_data {2297 int index; /* number of written untracked_cache_dir */2298 struct ewah_bitmap *check_only; /* from untracked_cache_dir */2299 struct ewah_bitmap *valid; /* from untracked_cache_dir */2300 struct ewah_bitmap *sha1_valid; /* set if exclude_sha1 is not null */2301 struct strbuf out;2302 struct strbuf sb_stat;2303 struct strbuf sb_sha1;2304};23052306static void stat_data_to_disk(struct stat_data *to, const struct stat_data *from)2307{2308 to->sd_ctime.sec = htonl(from->sd_ctime.sec);2309 to->sd_ctime.nsec = htonl(from->sd_ctime.nsec);2310 to->sd_mtime.sec = htonl(from->sd_mtime.sec);2311 to->sd_mtime.nsec = htonl(from->sd_mtime.nsec);2312 to->sd_dev = htonl(from->sd_dev);2313 to->sd_ino = htonl(from->sd_ino);2314 to->sd_uid = htonl(from->sd_uid);2315 to->sd_gid = htonl(from->sd_gid);2316 to->sd_size = htonl(from->sd_size);2317}23182319static void write_one_dir(struct untracked_cache_dir *untracked,2320 struct write_data *wd)2321{2322 struct stat_data stat_data;2323 struct strbuf *out = &wd->out;2324 unsigned char intbuf[16];2325 unsigned int intlen, value;2326 int i = wd->index++;23272328 /*2329 * untracked_nr should be reset whenever valid is clear, but2330 * for safety..2331 */2332 if (!untracked->valid) {2333 untracked->untracked_nr = 0;2334 untracked->check_only = 0;2335 }23362337 if (untracked->check_only)2338 ewah_set(wd->check_only, i);2339 if (untracked->valid) {2340 ewah_set(wd->valid, i);2341 stat_data_to_disk(&stat_data, &untracked->stat_data);2342 strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data));2343 }2344 if (!is_null_sha1(untracked->exclude_sha1)) {2345 ewah_set(wd->sha1_valid, i);2346 strbuf_add(&wd->sb_sha1, untracked->exclude_sha1, 20);2347 }23482349 intlen = encode_varint(untracked->untracked_nr, intbuf);2350 strbuf_add(out, intbuf, intlen);23512352 /* skip non-recurse directories */2353 for (i = 0, value = 0; i < untracked->dirs_nr; i++)2354 if (untracked->dirs[i]->recurse)2355 value++;2356 intlen = encode_varint(value, intbuf);2357 strbuf_add(out, intbuf, intlen);23582359 strbuf_add(out, untracked->name, strlen(untracked->name) + 1);23602361 for (i = 0; i < untracked->untracked_nr; i++)2362 strbuf_add(out, untracked->untracked[i],2363 strlen(untracked->untracked[i]) + 1);23642365 for (i = 0; i < untracked->dirs_nr; i++)2366 if (untracked->dirs[i]->recurse)2367 write_one_dir(untracked->dirs[i], wd);2368}23692370void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked)2371{2372 struct ondisk_untracked_cache *ouc;2373 struct write_data wd;2374 unsigned char varbuf[16];2375 int varint_len;2376 size_t len = strlen(untracked->exclude_per_dir);23772378 FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2379 stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2380 stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2381 hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);2382 hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.sha1);2383 ouc->dir_flags = htonl(untracked->dir_flags);23842385 varint_len = encode_varint(untracked->ident.len, varbuf);2386 strbuf_add(out, varbuf, varint_len);2387 strbuf_addbuf(out, &untracked->ident);23882389 strbuf_add(out, ouc, ouc_size(len));2390 free(ouc);2391 ouc = NULL;23922393 if (!untracked->root) {2394 varint_len = encode_varint(0, varbuf);2395 strbuf_add(out, varbuf, varint_len);2396 return;2397 }23982399 wd.index = 0;2400 wd.check_only = ewah_new();2401 wd.valid = ewah_new();2402 wd.sha1_valid = ewah_new();2403 strbuf_init(&wd.out, 1024);2404 strbuf_init(&wd.sb_stat, 1024);2405 strbuf_init(&wd.sb_sha1, 1024);2406 write_one_dir(untracked->root, &wd);24072408 varint_len = encode_varint(wd.index, varbuf);2409 strbuf_add(out, varbuf, varint_len);2410 strbuf_addbuf(out, &wd.out);2411 ewah_serialize_strbuf(wd.valid, out);2412 ewah_serialize_strbuf(wd.check_only, out);2413 ewah_serialize_strbuf(wd.sha1_valid, out);2414 strbuf_addbuf(out, &wd.sb_stat);2415 strbuf_addbuf(out, &wd.sb_sha1);2416 strbuf_addch(out, '\0'); /* safe guard for string lists */24172418 ewah_free(wd.valid);2419 ewah_free(wd.check_only);2420 ewah_free(wd.sha1_valid);2421 strbuf_release(&wd.out);2422 strbuf_release(&wd.sb_stat);2423 strbuf_release(&wd.sb_sha1);2424}24252426static void free_untracked(struct untracked_cache_dir *ucd)2427{2428 int i;2429 if (!ucd)2430 return;2431 for (i = 0; i < ucd->dirs_nr; i++)2432 free_untracked(ucd->dirs[i]);2433 for (i = 0; i < ucd->untracked_nr; i++)2434 free(ucd->untracked[i]);2435 free(ucd->untracked);2436 free(ucd->dirs);2437 free(ucd);2438}24392440void free_untracked_cache(struct untracked_cache *uc)2441{2442 if (uc)2443 free_untracked(uc->root);2444 free(uc);2445}24462447struct read_data {2448 int index;2449 struct untracked_cache_dir **ucd;2450 struct ewah_bitmap *check_only;2451 struct ewah_bitmap *valid;2452 struct ewah_bitmap *sha1_valid;2453 const unsigned char *data;2454 const unsigned char *end;2455};24562457static void stat_data_from_disk(struct stat_data *to, const struct stat_data *from)2458{2459 to->sd_ctime.sec = get_be32(&from->sd_ctime.sec);2460 to->sd_ctime.nsec = get_be32(&from->sd_ctime.nsec);2461 to->sd_mtime.sec = get_be32(&from->sd_mtime.sec);2462 to->sd_mtime.nsec = get_be32(&from->sd_mtime.nsec);2463 to->sd_dev = get_be32(&from->sd_dev);2464 to->sd_ino = get_be32(&from->sd_ino);2465 to->sd_uid = get_be32(&from->sd_uid);2466 to->sd_gid = get_be32(&from->sd_gid);2467 to->sd_size = get_be32(&from->sd_size);2468}24692470static int read_one_dir(struct untracked_cache_dir **untracked_,2471 struct read_data *rd)2472{2473 struct untracked_cache_dir ud, *untracked;2474 const unsigned char *next, *data = rd->data, *end = rd->end;2475 unsigned int value;2476 int i, len;24772478 memset(&ud, 0, sizeof(ud));24792480 next = data;2481 value = decode_varint(&next);2482 if (next > end)2483 return -1;2484 ud.recurse = 1;2485 ud.untracked_alloc = value;2486 ud.untracked_nr = value;2487 if (ud.untracked_nr)2488 ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2489 data = next;24902491 next = data;2492 ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);2493 if (next > end)2494 return -1;2495 ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2496 data = next;24972498 len = strlen((const char *)data);2499 next = data + len + 1;2500 if (next > rd->end)2501 return -1;2502 *untracked_ = untracked = xmalloc(st_add(sizeof(*untracked), len));2503 memcpy(untracked, &ud, sizeof(ud));2504 memcpy(untracked->name, data, len + 1);2505 data = next;25062507 for (i = 0; i < untracked->untracked_nr; i++) {2508 len = strlen((const char *)data);2509 next = data + len + 1;2510 if (next > rd->end)2511 return -1;2512 untracked->untracked[i] = xstrdup((const char*)data);2513 data = next;2514 }25152516 rd->ucd[rd->index++] = untracked;2517 rd->data = data;25182519 for (i = 0; i < untracked->dirs_nr; i++) {2520 len = read_one_dir(untracked->dirs + i, rd);2521 if (len < 0)2522 return -1;2523 }2524 return 0;2525}25262527static void set_check_only(size_t pos, void *cb)2528{2529 struct read_data *rd = cb;2530 struct untracked_cache_dir *ud = rd->ucd[pos];2531 ud->check_only = 1;2532}25332534static void read_stat(size_t pos, void *cb)2535{2536 struct read_data *rd = cb;2537 struct untracked_cache_dir *ud = rd->ucd[pos];2538 if (rd->data + sizeof(struct stat_data) > rd->end) {2539 rd->data = rd->end + 1;2540 return;2541 }2542 stat_data_from_disk(&ud->stat_data, (struct stat_data *)rd->data);2543 rd->data += sizeof(struct stat_data);2544 ud->valid = 1;2545}25462547static void read_sha1(size_t pos, void *cb)2548{2549 struct read_data *rd = cb;2550 struct untracked_cache_dir *ud = rd->ucd[pos];2551 if (rd->data + 20 > rd->end) {2552 rd->data = rd->end + 1;2553 return;2554 }2555 hashcpy(ud->exclude_sha1, rd->data);2556 rd->data += 20;2557}25582559static void load_sha1_stat(struct sha1_stat *sha1_stat,2560 const struct stat_data *stat,2561 const unsigned char *sha1)2562{2563 stat_data_from_disk(&sha1_stat->stat, stat);2564 hashcpy(sha1_stat->sha1, sha1);2565 sha1_stat->valid = 1;2566}25672568struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz)2569{2570 const struct ondisk_untracked_cache *ouc;2571 struct untracked_cache *uc;2572 struct read_data rd;2573 const unsigned char *next = data, *end = (const unsigned char *)data + sz;2574 const char *ident;2575 int ident_len, len;25762577 if (sz <= 1 || end[-1] != '\0')2578 return NULL;2579 end--;25802581 ident_len = decode_varint(&next);2582 if (next + ident_len > end)2583 return NULL;2584 ident = (const char *)next;2585 next += ident_len;25862587 ouc = (const struct ondisk_untracked_cache *)next;2588 if (next + ouc_size(0) > end)2589 return NULL;25902591 uc = xcalloc(1, sizeof(*uc));2592 strbuf_init(&uc->ident, ident_len);2593 strbuf_add(&uc->ident, ident, ident_len);2594 load_sha1_stat(&uc->ss_info_exclude, &ouc->info_exclude_stat,2595 ouc->info_exclude_sha1);2596 load_sha1_stat(&uc->ss_excludes_file, &ouc->excludes_file_stat,2597 ouc->excludes_file_sha1);2598 uc->dir_flags = get_be32(&ouc->dir_flags);2599 uc->exclude_per_dir = xstrdup(ouc->exclude_per_dir);2600 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */2601 next += ouc_size(strlen(ouc->exclude_per_dir));2602 if (next >= end)2603 goto done2;26042605 len = decode_varint(&next);2606 if (next > end || len == 0)2607 goto done2;26082609 rd.valid = ewah_new();2610 rd.check_only = ewah_new();2611 rd.sha1_valid = ewah_new();2612 rd.data = next;2613 rd.end = end;2614 rd.index = 0;2615 ALLOC_ARRAY(rd.ucd, len);26162617 if (read_one_dir(&uc->root, &rd) || rd.index != len)2618 goto done;26192620 next = rd.data;2621 len = ewah_read_mmap(rd.valid, next, end - next);2622 if (len < 0)2623 goto done;26242625 next += len;2626 len = ewah_read_mmap(rd.check_only, next, end - next);2627 if (len < 0)2628 goto done;26292630 next += len;2631 len = ewah_read_mmap(rd.sha1_valid, next, end - next);2632 if (len < 0)2633 goto done;26342635 ewah_each_bit(rd.check_only, set_check_only, &rd);2636 rd.data = next + len;2637 ewah_each_bit(rd.valid, read_stat, &rd);2638 ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2639 next = rd.data;26402641done:2642 free(rd.ucd);2643 ewah_free(rd.valid);2644 ewah_free(rd.check_only);2645 ewah_free(rd.sha1_valid);2646done2:2647 if (next != end) {2648 free_untracked_cache(uc);2649 uc = NULL;2650 }2651 return uc;2652}26532654static void invalidate_one_directory(struct untracked_cache *uc,2655 struct untracked_cache_dir *ucd)2656{2657 uc->dir_invalidated++;2658 ucd->valid = 0;2659 ucd->untracked_nr = 0;2660}26612662/*2663 * Normally when an entry is added or removed from a directory,2664 * invalidating that directory is enough. No need to touch its2665 * ancestors. When a directory is shown as "foo/bar/" in git-status2666 * however, deleting or adding an entry may have cascading effect.2667 *2668 * Say the "foo/bar/file" has become untracked, we need to tell the2669 * untracked_cache_dir of "foo" that "bar/" is not an untracked2670 * directory any more (because "bar" is managed by foo as an untracked2671 * "file").2672 *2673 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2674 * was the last untracked entry in the entire "foo", we should show2675 * "foo/" instead. Which means we have to invalidate past "bar" up to2676 * "foo".2677 *2678 * This function traverses all directories from root to leaf. If there2679 * is a chance of one of the above cases happening, we invalidate back2680 * to root. Otherwise we just invalidate the leaf. There may be a more2681 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2682 * detect these cases and avoid unnecessary invalidation, for example,2683 * checking for the untracked entry named "bar/" in "foo", but for now2684 * stick to something safe and simple.2685 */2686static int invalidate_one_component(struct untracked_cache *uc,2687 struct untracked_cache_dir *dir,2688 const char *path, int len)2689{2690 const char *rest = strchr(path, '/');26912692 if (rest) {2693 int component_len = rest - path;2694 struct untracked_cache_dir *d =2695 lookup_untracked(uc, dir, path, component_len);2696 int ret =2697 invalidate_one_component(uc, d, rest + 1,2698 len - (component_len + 1));2699 if (ret)2700 invalidate_one_directory(uc, dir);2701 return ret;2702 }27032704 invalidate_one_directory(uc, dir);2705 return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2706}27072708void untracked_cache_invalidate_path(struct index_state *istate,2709 const char *path)2710{2711 if (!istate->untracked || !istate->untracked->root)2712 return;2713 invalidate_one_component(istate->untracked, istate->untracked->root,2714 path, strlen(path));2715}27162717void untracked_cache_remove_from_index(struct index_state *istate,2718 const char *path)2719{2720 untracked_cache_invalidate_path(istate, path);2721}27222723void untracked_cache_add_to_index(struct index_state *istate,2724 const char *path)2725{2726 untracked_cache_invalidate_path(istate, path);2727}27282729/* Update gitfile and core.worktree setting to connect work tree and git dir */2730void connect_work_tree_and_git_dir(const char *work_tree_, const char *git_dir_)2731{2732 struct strbuf file_name = STRBUF_INIT;2733 struct strbuf rel_path = STRBUF_INIT;2734 char *git_dir = real_pathdup(git_dir_);2735 char *work_tree = real_pathdup(work_tree_);27362737 /* Update gitfile */2738 strbuf_addf(&file_name, "%s/.git", work_tree);2739 write_file(file_name.buf, "gitdir: %s",2740 relative_path(git_dir, work_tree, &rel_path));27412742 /* Update core.worktree setting */2743 strbuf_reset(&file_name);2744 strbuf_addf(&file_name, "%s/config", git_dir);2745 git_config_set_in_file(file_name.buf, "core.worktree",2746 relative_path(work_tree, git_dir, &rel_path));27472748 strbuf_release(&file_name);2749 strbuf_release(&rel_path);2750 free(work_tree);2751 free(git_dir);2752}27532754/*2755 * Migrate the git directory of the given path from old_git_dir to new_git_dir.2756 */2757void relocate_gitdir(const char *path, const char *old_git_dir, const char *new_git_dir)2758{2759 if (rename(old_git_dir, new_git_dir) < 0)2760 die_errno(_("could not migrate git directory from '%s' to '%s'"),2761 old_git_dir, new_git_dir);27622763 connect_work_tree_and_git_dir(path, new_git_dir);2764}