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 "config.h" 12#include "dir.h" 13#include "object-store.h" 14#include "attr.h" 15#include "refs.h" 16#include "wildmatch.h" 17#include "pathspec.h" 18#include "utf8.h" 19#include "varint.h" 20#include "ewah/ewok.h" 21#include "fsmonitor.h" 22#include "submodule-config.h" 23 24/* 25 * Tells read_directory_recursive how a file or directory should be treated. 26 * Values are ordered by significance, e.g. if a directory contains both 27 * excluded and untracked files, it is listed as untracked because 28 * path_untracked > path_excluded. 29 */ 30enum path_treatment { 31 path_none = 0, 32 path_recurse, 33 path_excluded, 34 path_untracked 35}; 36 37/* 38 * Support data structure for our opendir/readdir/closedir wrappers 39 */ 40struct cached_dir { 41 DIR *fdir; 42 struct untracked_cache_dir *untracked; 43 int nr_files; 44 int nr_dirs; 45 46 struct dirent *de; 47 const char *file; 48 struct untracked_cache_dir *ucd; 49}; 50 51static enum path_treatment read_directory_recursive(struct dir_struct *dir, 52 struct index_state *istate, const char *path, int len, 53 struct untracked_cache_dir *untracked, 54 int check_only, int stop_at_first_file, const struct pathspec *pathspec); 55static int get_dtype(struct dirent *de, struct index_state *istate, 56 const char *path, int len); 57 58int count_slashes(const char *s) 59{ 60 int cnt = 0; 61 while (*s) 62 if (*s++ == '/') 63 cnt++; 64 return cnt; 65} 66 67int fspathcmp(const char *a, const char *b) 68{ 69 return ignore_case ? strcasecmp(a, b) : strcmp(a, b); 70} 71 72int fspathncmp(const char *a, const char *b, size_t count) 73{ 74 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count); 75} 76 77int git_fnmatch(const struct pathspec_item *item, 78 const char *pattern, const char *string, 79 int prefix) 80{ 81 if (prefix > 0) { 82 if (ps_strncmp(item, pattern, string, prefix)) 83 return WM_NOMATCH; 84 pattern += prefix; 85 string += prefix; 86 } 87 if (item->flags & PATHSPEC_ONESTAR) { 88 int pattern_len = strlen(++pattern); 89 int string_len = strlen(string); 90 return string_len < pattern_len || 91 ps_strcmp(item, pattern, 92 string + string_len - pattern_len); 93 } 94 if (item->magic & PATHSPEC_GLOB) 95 return wildmatch(pattern, string, 96 WM_PATHNAME | 97 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0)); 98 else 99 /* wildmatch has not learned no FNM_PATHNAME mode yet */ 100 return wildmatch(pattern, string, 101 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0); 102} 103 104static int fnmatch_icase_mem(const char *pattern, int patternlen, 105 const char *string, int stringlen, 106 int flags) 107{ 108 int match_status; 109 struct strbuf pat_buf = STRBUF_INIT; 110 struct strbuf str_buf = STRBUF_INIT; 111 const char *use_pat = pattern; 112 const char *use_str = string; 113 114 if (pattern[patternlen]) { 115 strbuf_add(&pat_buf, pattern, patternlen); 116 use_pat = pat_buf.buf; 117 } 118 if (string[stringlen]) { 119 strbuf_add(&str_buf, string, stringlen); 120 use_str = str_buf.buf; 121 } 122 123 if (ignore_case) 124 flags |= WM_CASEFOLD; 125 match_status = wildmatch(use_pat, use_str, flags); 126 127 strbuf_release(&pat_buf); 128 strbuf_release(&str_buf); 129 130 return match_status; 131} 132 133static size_t common_prefix_len(const struct pathspec *pathspec) 134{ 135 int n; 136 size_t max = 0; 137 138 /* 139 * ":(icase)path" is treated as a pathspec full of 140 * wildcard. In other words, only prefix is considered common 141 * prefix. If the pathspec is abc/foo abc/bar, running in 142 * subdir xyz, the common prefix is still xyz, not xuz/abc as 143 * in non-:(icase). 144 */ 145 GUARD_PATHSPEC(pathspec, 146 PATHSPEC_FROMTOP | 147 PATHSPEC_MAXDEPTH | 148 PATHSPEC_LITERAL | 149 PATHSPEC_GLOB | 150 PATHSPEC_ICASE | 151 PATHSPEC_EXCLUDE | 152 PATHSPEC_ATTR); 153 154 for (n = 0; n < pathspec->nr; n++) { 155 size_t i = 0, len = 0, item_len; 156 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE) 157 continue; 158 if (pathspec->items[n].magic & PATHSPEC_ICASE) 159 item_len = pathspec->items[n].prefix; 160 else 161 item_len = pathspec->items[n].nowildcard_len; 162 while (i < item_len && (n == 0 || i < max)) { 163 char c = pathspec->items[n].match[i]; 164 if (c != pathspec->items[0].match[i]) 165 break; 166 if (c == '/') 167 len = i + 1; 168 i++; 169 } 170 if (n == 0 || len < max) { 171 max = len; 172 if (!max) 173 break; 174 } 175 } 176 return max; 177} 178 179/* 180 * Returns a copy of the longest leading path common among all 181 * pathspecs. 182 */ 183char *common_prefix(const struct pathspec *pathspec) 184{ 185 unsigned long len = common_prefix_len(pathspec); 186 187 return len ? xmemdupz(pathspec->items[0].match, len) : NULL; 188} 189 190int fill_directory(struct dir_struct *dir, 191 struct index_state *istate, 192 const struct pathspec *pathspec) 193{ 194 const char *prefix; 195 size_t prefix_len; 196 197 /* 198 * Calculate common prefix for the pathspec, and 199 * use that to optimize the directory walk 200 */ 201 prefix_len = common_prefix_len(pathspec); 202 prefix = prefix_len ? pathspec->items[0].match : ""; 203 204 /* Read the directory and prune it */ 205 read_directory(dir, istate, prefix, prefix_len, pathspec); 206 207 return prefix_len; 208} 209 210int within_depth(const char *name, int namelen, 211 int depth, int max_depth) 212{ 213 const char *cp = name, *cpe = name + namelen; 214 215 while (cp < cpe) { 216 if (*cp++ != '/') 217 continue; 218 depth++; 219 if (depth > max_depth) 220 return 0; 221 } 222 return 1; 223} 224 225/* 226 * Read the contents of the blob with the given OID into a buffer. 227 * Append a trailing LF to the end if the last line doesn't have one. 228 * 229 * Returns: 230 * -1 when the OID is invalid or unknown or does not refer to a blob. 231 * 0 when the blob is empty. 232 * 1 along with { data, size } of the (possibly augmented) buffer 233 * when successful. 234 * 235 * Optionally updates the given oid_stat with the given OID (when valid). 236 */ 237static int do_read_blob(const struct object_id *oid, struct oid_stat *oid_stat, 238 size_t *size_out, char **data_out) 239{ 240 enum object_type type; 241 unsigned long sz; 242 char *data; 243 244 *size_out = 0; 245 *data_out = NULL; 246 247 data = read_object_file(oid, &type, &sz); 248 if (!data || type != OBJ_BLOB) { 249 free(data); 250 return -1; 251 } 252 253 if (oid_stat) { 254 memset(&oid_stat->stat, 0, sizeof(oid_stat->stat)); 255 oidcpy(&oid_stat->oid, oid); 256 } 257 258 if (sz == 0) { 259 free(data); 260 return 0; 261 } 262 263 if (data[sz - 1] != '\n') { 264 data = xrealloc(data, st_add(sz, 1)); 265 data[sz++] = '\n'; 266 } 267 268 *size_out = xsize_t(sz); 269 *data_out = data; 270 271 return 1; 272} 273 274#define DO_MATCH_EXCLUDE (1<<0) 275#define DO_MATCH_DIRECTORY (1<<1) 276#define DO_MATCH_SUBMODULE (1<<2) 277 278/* 279 * Does 'match' match the given name? 280 * A match is found if 281 * 282 * (1) the 'match' string is leading directory of 'name', or 283 * (2) the 'match' string is a wildcard and matches 'name', or 284 * (3) the 'match' string is exactly the same as 'name'. 285 * 286 * and the return value tells which case it was. 287 * 288 * It returns 0 when there is no match. 289 */ 290static int match_pathspec_item(const struct index_state *istate, 291 const struct pathspec_item *item, int prefix, 292 const char *name, int namelen, unsigned flags) 293{ 294 /* name/namelen has prefix cut off by caller */ 295 const char *match = item->match + prefix; 296 int matchlen = item->len - prefix; 297 298 /* 299 * The normal call pattern is: 300 * 1. prefix = common_prefix_len(ps); 301 * 2. prune something, or fill_directory 302 * 3. match_pathspec() 303 * 304 * 'prefix' at #1 may be shorter than the command's prefix and 305 * it's ok for #2 to match extra files. Those extras will be 306 * trimmed at #3. 307 * 308 * Suppose the pathspec is 'foo' and '../bar' running from 309 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 310 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 311 * user does not want XYZ/foo, only the "foo" part should be 312 * case-insensitive. We need to filter out XYZ/foo here. In 313 * other words, we do not trust the caller on comparing the 314 * prefix part when :(icase) is involved. We do exact 315 * comparison ourselves. 316 * 317 * Normally the caller (common_prefix_len() in fact) does 318 * _exact_ matching on name[-prefix+1..-1] and we do not need 319 * to check that part. Be defensive and check it anyway, in 320 * case common_prefix_len is changed, or a new caller is 321 * introduced that does not use common_prefix_len. 322 * 323 * If the penalty turns out too high when prefix is really 324 * long, maybe change it to 325 * strncmp(match, name, item->prefix - prefix) 326 */ 327 if (item->prefix && (item->magic & PATHSPEC_ICASE) && 328 strncmp(item->match, name - prefix, item->prefix)) 329 return 0; 330 331 if (item->attr_match_nr && 332 !match_pathspec_attrs(istate, name, namelen, item)) 333 return 0; 334 335 /* If the match was just the prefix, we matched */ 336 if (!*match) 337 return MATCHED_RECURSIVELY; 338 339 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 340 if (matchlen == namelen) 341 return MATCHED_EXACTLY; 342 343 if (match[matchlen-1] == '/' || name[matchlen] == '/') 344 return MATCHED_RECURSIVELY; 345 } else if ((flags & DO_MATCH_DIRECTORY) && 346 match[matchlen - 1] == '/' && 347 namelen == matchlen - 1 && 348 !ps_strncmp(item, match, name, namelen)) 349 return MATCHED_EXACTLY; 350 351 if (item->nowildcard_len < item->len && 352 !git_fnmatch(item, match, name, 353 item->nowildcard_len - prefix)) 354 return MATCHED_FNMATCH; 355 356 /* Perform checks to see if "name" is a super set of the pathspec */ 357 if (flags & DO_MATCH_SUBMODULE) { 358 /* name is a literal prefix of the pathspec */ 359 if ((namelen < matchlen) && 360 (match[namelen] == '/') && 361 !ps_strncmp(item, match, name, namelen)) 362 return MATCHED_RECURSIVELY; 363 364 /* name" doesn't match up to the first wild character */ 365 if (item->nowildcard_len < item->len && 366 ps_strncmp(item, match, name, 367 item->nowildcard_len - prefix)) 368 return 0; 369 370 /* 371 * Here is where we would perform a wildmatch to check if 372 * "name" can be matched as a directory (or a prefix) against 373 * the pathspec. Since wildmatch doesn't have this capability 374 * at the present we have to punt and say that it is a match, 375 * potentially returning a false positive 376 * The submodules themselves will be able to perform more 377 * accurate matching to determine if the pathspec matches. 378 */ 379 return MATCHED_RECURSIVELY; 380 } 381 382 return 0; 383} 384 385/* 386 * Given a name and a list of pathspecs, returns the nature of the 387 * closest (i.e. most specific) match of the name to any of the 388 * pathspecs. 389 * 390 * The caller typically calls this multiple times with the same 391 * pathspec and seen[] array but with different name/namelen 392 * (e.g. entries from the index) and is interested in seeing if and 393 * how each pathspec matches all the names it calls this function 394 * with. A mark is left in the seen[] array for each pathspec element 395 * indicating the closest type of match that element achieved, so if 396 * seen[n] remains zero after multiple invocations, that means the nth 397 * pathspec did not match any names, which could indicate that the 398 * user mistyped the nth pathspec. 399 */ 400static int do_match_pathspec(const struct index_state *istate, 401 const struct pathspec *ps, 402 const char *name, int namelen, 403 int prefix, char *seen, 404 unsigned flags) 405{ 406 int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE; 407 408 GUARD_PATHSPEC(ps, 409 PATHSPEC_FROMTOP | 410 PATHSPEC_MAXDEPTH | 411 PATHSPEC_LITERAL | 412 PATHSPEC_GLOB | 413 PATHSPEC_ICASE | 414 PATHSPEC_EXCLUDE | 415 PATHSPEC_ATTR); 416 417 if (!ps->nr) { 418 if (!ps->recursive || 419 !(ps->magic & PATHSPEC_MAXDEPTH) || 420 ps->max_depth == -1) 421 return MATCHED_RECURSIVELY; 422 423 if (within_depth(name, namelen, 0, ps->max_depth)) 424 return MATCHED_EXACTLY; 425 else 426 return 0; 427 } 428 429 name += prefix; 430 namelen -= prefix; 431 432 for (i = ps->nr - 1; i >= 0; i--) { 433 int how; 434 435 if ((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 436 ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 437 continue; 438 439 if (seen && seen[i] == MATCHED_EXACTLY) 440 continue; 441 /* 442 * Make exclude patterns optional and never report 443 * "pathspec ':(exclude)foo' matches no files" 444 */ 445 if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 446 seen[i] = MATCHED_FNMATCH; 447 how = match_pathspec_item(istate, ps->items+i, prefix, name, 448 namelen, flags); 449 if (ps->recursive && 450 (ps->magic & PATHSPEC_MAXDEPTH) && 451 ps->max_depth != -1 && 452 how && how != MATCHED_FNMATCH) { 453 int len = ps->items[i].len; 454 if (name[len] == '/') 455 len++; 456 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 457 how = MATCHED_EXACTLY; 458 else 459 how = 0; 460 } 461 if (how) { 462 if (retval < how) 463 retval = how; 464 if (seen && seen[i] < how) 465 seen[i] = how; 466 } 467 } 468 return retval; 469} 470 471int match_pathspec(const struct index_state *istate, 472 const struct pathspec *ps, 473 const char *name, int namelen, 474 int prefix, char *seen, int is_dir) 475{ 476 int positive, negative; 477 unsigned flags = is_dir ? DO_MATCH_DIRECTORY : 0; 478 positive = do_match_pathspec(istate, ps, name, namelen, 479 prefix, seen, flags); 480 if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 481 return positive; 482 negative = do_match_pathspec(istate, ps, name, namelen, 483 prefix, seen, 484 flags | DO_MATCH_EXCLUDE); 485 return negative ? 0 : positive; 486} 487 488/** 489 * Check if a submodule is a superset of the pathspec 490 */ 491int submodule_path_match(const struct index_state *istate, 492 const struct pathspec *ps, 493 const char *submodule_name, 494 char *seen) 495{ 496 int matched = do_match_pathspec(istate, ps, submodule_name, 497 strlen(submodule_name), 498 0, seen, 499 DO_MATCH_DIRECTORY | 500 DO_MATCH_SUBMODULE); 501 return matched; 502} 503 504int report_path_error(const char *ps_matched, 505 const struct pathspec *pathspec) 506{ 507 /* 508 * Make sure all pathspec matched; otherwise it is an error. 509 */ 510 int num, errors = 0; 511 for (num = 0; num < pathspec->nr; num++) { 512 int other, found_dup; 513 514 if (ps_matched[num]) 515 continue; 516 /* 517 * The caller might have fed identical pathspec 518 * twice. Do not barf on such a mistake. 519 * FIXME: parse_pathspec should have eliminated 520 * duplicate pathspec. 521 */ 522 for (found_dup = other = 0; 523 !found_dup && other < pathspec->nr; 524 other++) { 525 if (other == num || !ps_matched[other]) 526 continue; 527 if (!strcmp(pathspec->items[other].original, 528 pathspec->items[num].original)) 529 /* 530 * Ok, we have a match already. 531 */ 532 found_dup = 1; 533 } 534 if (found_dup) 535 continue; 536 537 error(_("pathspec '%s' did not match any file(s) known to git"), 538 pathspec->items[num].original); 539 errors++; 540 } 541 return errors; 542} 543 544/* 545 * Return the length of the "simple" part of a path match limiter. 546 */ 547int simple_length(const char *match) 548{ 549 int len = -1; 550 551 for (;;) { 552 unsigned char c = *match++; 553 len++; 554 if (c == '\0' || is_glob_special(c)) 555 return len; 556 } 557} 558 559int no_wildcard(const char *string) 560{ 561 return string[simple_length(string)] == '\0'; 562} 563 564void parse_exclude_pattern(const char **pattern, 565 int *patternlen, 566 unsigned *flags, 567 int *nowildcardlen) 568{ 569 const char *p = *pattern; 570 size_t i, len; 571 572 *flags = 0; 573 if (*p == '!') { 574 *flags |= EXC_FLAG_NEGATIVE; 575 p++; 576 } 577 len = strlen(p); 578 if (len && p[len - 1] == '/') { 579 len--; 580 *flags |= EXC_FLAG_MUSTBEDIR; 581 } 582 for (i = 0; i < len; i++) { 583 if (p[i] == '/') 584 break; 585 } 586 if (i == len) 587 *flags |= EXC_FLAG_NODIR; 588 *nowildcardlen = simple_length(p); 589 /* 590 * we should have excluded the trailing slash from 'p' too, 591 * but that's one more allocation. Instead just make sure 592 * nowildcardlen does not exceed real patternlen 593 */ 594 if (*nowildcardlen > len) 595 *nowildcardlen = len; 596 if (*p == '*' && no_wildcard(p + 1)) 597 *flags |= EXC_FLAG_ENDSWITH; 598 *pattern = p; 599 *patternlen = len; 600} 601 602void add_exclude(const char *string, const char *base, 603 int baselen, struct exclude_list *el, int srcpos) 604{ 605 struct path_pattern *pattern; 606 int patternlen; 607 unsigned flags; 608 int nowildcardlen; 609 610 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 611 if (flags & EXC_FLAG_MUSTBEDIR) { 612 FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen); 613 } else { 614 pattern = xmalloc(sizeof(*pattern)); 615 pattern->pattern = string; 616 } 617 pattern->patternlen = patternlen; 618 pattern->nowildcardlen = nowildcardlen; 619 pattern->base = base; 620 pattern->baselen = baselen; 621 pattern->flags = flags; 622 pattern->srcpos = srcpos; 623 ALLOC_GROW(el->patterns, el->nr + 1, el->alloc); 624 el->patterns[el->nr++] = pattern; 625 pattern->el = el; 626} 627 628static int read_skip_worktree_file_from_index(const struct index_state *istate, 629 const char *path, 630 size_t *size_out, char **data_out, 631 struct oid_stat *oid_stat) 632{ 633 int pos, len; 634 635 len = strlen(path); 636 pos = index_name_pos(istate, path, len); 637 if (pos < 0) 638 return -1; 639 if (!ce_skip_worktree(istate->cache[pos])) 640 return -1; 641 642 return do_read_blob(&istate->cache[pos]->oid, oid_stat, size_out, data_out); 643} 644 645/* 646 * Frees memory within el which was allocated for exclude patterns and 647 * the file buffer. Does not free el itself. 648 */ 649void clear_exclude_list(struct exclude_list *el) 650{ 651 int i; 652 653 for (i = 0; i < el->nr; i++) 654 free(el->patterns[i]); 655 free(el->patterns); 656 free(el->filebuf); 657 658 memset(el, 0, sizeof(*el)); 659} 660 661static void trim_trailing_spaces(char *buf) 662{ 663 char *p, *last_space = NULL; 664 665 for (p = buf; *p; p++) 666 switch (*p) { 667 case ' ': 668 if (!last_space) 669 last_space = p; 670 break; 671 case '\\': 672 p++; 673 if (!*p) 674 return; 675 /* fallthrough */ 676 default: 677 last_space = NULL; 678 } 679 680 if (last_space) 681 *last_space = '\0'; 682} 683 684/* 685 * Given a subdirectory name and "dir" of the current directory, 686 * search the subdir in "dir" and return it, or create a new one if it 687 * does not exist in "dir". 688 * 689 * If "name" has the trailing slash, it'll be excluded in the search. 690 */ 691static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 692 struct untracked_cache_dir *dir, 693 const char *name, int len) 694{ 695 int first, last; 696 struct untracked_cache_dir *d; 697 if (!dir) 698 return NULL; 699 if (len && name[len - 1] == '/') 700 len--; 701 first = 0; 702 last = dir->dirs_nr; 703 while (last > first) { 704 int cmp, next = (last + first) >> 1; 705 d = dir->dirs[next]; 706 cmp = strncmp(name, d->name, len); 707 if (!cmp && strlen(d->name) > len) 708 cmp = -1; 709 if (!cmp) 710 return d; 711 if (cmp < 0) { 712 last = next; 713 continue; 714 } 715 first = next+1; 716 } 717 718 uc->dir_created++; 719 FLEX_ALLOC_MEM(d, name, name, len); 720 721 ALLOC_GROW(dir->dirs, dir->dirs_nr + 1, dir->dirs_alloc); 722 MOVE_ARRAY(dir->dirs + first + 1, dir->dirs + first, 723 dir->dirs_nr - first); 724 dir->dirs_nr++; 725 dir->dirs[first] = d; 726 return d; 727} 728 729static void do_invalidate_gitignore(struct untracked_cache_dir *dir) 730{ 731 int i; 732 dir->valid = 0; 733 dir->untracked_nr = 0; 734 for (i = 0; i < dir->dirs_nr; i++) 735 do_invalidate_gitignore(dir->dirs[i]); 736} 737 738static void invalidate_gitignore(struct untracked_cache *uc, 739 struct untracked_cache_dir *dir) 740{ 741 uc->gitignore_invalidated++; 742 do_invalidate_gitignore(dir); 743} 744 745static void invalidate_directory(struct untracked_cache *uc, 746 struct untracked_cache_dir *dir) 747{ 748 int i; 749 750 /* 751 * Invalidation increment here is just roughly correct. If 752 * untracked_nr or any of dirs[].recurse is non-zero, we 753 * should increment dir_invalidated too. But that's more 754 * expensive to do. 755 */ 756 if (dir->valid) 757 uc->dir_invalidated++; 758 759 dir->valid = 0; 760 dir->untracked_nr = 0; 761 for (i = 0; i < dir->dirs_nr; i++) 762 dir->dirs[i]->recurse = 0; 763} 764 765static int add_excludes_from_buffer(char *buf, size_t size, 766 const char *base, int baselen, 767 struct exclude_list *el); 768 769/* 770 * Given a file with name "fname", read it (either from disk, or from 771 * an index if 'istate' is non-null), parse it and store the 772 * exclude rules in "el". 773 * 774 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 775 * stat data from disk (only valid if add_excludes returns zero). If 776 * ss_valid is non-zero, "ss" must contain good value as input. 777 */ 778static int add_excludes(const char *fname, const char *base, int baselen, 779 struct exclude_list *el, struct index_state *istate, 780 struct oid_stat *oid_stat) 781{ 782 struct stat st; 783 int r; 784 int fd; 785 size_t size = 0; 786 char *buf; 787 788 fd = open(fname, O_RDONLY); 789 if (fd < 0 || fstat(fd, &st) < 0) { 790 if (fd < 0) 791 warn_on_fopen_errors(fname); 792 else 793 close(fd); 794 if (!istate) 795 return -1; 796 r = read_skip_worktree_file_from_index(istate, fname, 797 &size, &buf, 798 oid_stat); 799 if (r != 1) 800 return r; 801 } else { 802 size = xsize_t(st.st_size); 803 if (size == 0) { 804 if (oid_stat) { 805 fill_stat_data(&oid_stat->stat, &st); 806 oidcpy(&oid_stat->oid, the_hash_algo->empty_blob); 807 oid_stat->valid = 1; 808 } 809 close(fd); 810 return 0; 811 } 812 buf = xmallocz(size); 813 if (read_in_full(fd, buf, size) != size) { 814 free(buf); 815 close(fd); 816 return -1; 817 } 818 buf[size++] = '\n'; 819 close(fd); 820 if (oid_stat) { 821 int pos; 822 if (oid_stat->valid && 823 !match_stat_data_racy(istate, &oid_stat->stat, &st)) 824 ; /* no content change, ss->sha1 still good */ 825 else if (istate && 826 (pos = index_name_pos(istate, fname, strlen(fname))) >= 0 && 827 !ce_stage(istate->cache[pos]) && 828 ce_uptodate(istate->cache[pos]) && 829 !would_convert_to_git(istate, fname)) 830 oidcpy(&oid_stat->oid, 831 &istate->cache[pos]->oid); 832 else 833 hash_object_file(buf, size, "blob", 834 &oid_stat->oid); 835 fill_stat_data(&oid_stat->stat, &st); 836 oid_stat->valid = 1; 837 } 838 } 839 840 add_excludes_from_buffer(buf, size, base, baselen, el); 841 return 0; 842} 843 844static int add_excludes_from_buffer(char *buf, size_t size, 845 const char *base, int baselen, 846 struct exclude_list *el) 847{ 848 int i, lineno = 1; 849 char *entry; 850 851 el->filebuf = buf; 852 853 if (skip_utf8_bom(&buf, size)) 854 size -= buf - el->filebuf; 855 856 entry = buf; 857 858 for (i = 0; i < size; i++) { 859 if (buf[i] == '\n') { 860 if (entry != buf + i && entry[0] != '#') { 861 buf[i - (i && buf[i-1] == '\r')] = 0; 862 trim_trailing_spaces(entry); 863 add_exclude(entry, base, baselen, el, lineno); 864 } 865 lineno++; 866 entry = buf + i + 1; 867 } 868 } 869 return 0; 870} 871 872int add_excludes_from_file_to_list(const char *fname, const char *base, 873 int baselen, struct exclude_list *el, 874 struct index_state *istate) 875{ 876 return add_excludes(fname, base, baselen, el, istate, NULL); 877} 878 879int add_excludes_from_blob_to_list( 880 struct object_id *oid, 881 const char *base, int baselen, 882 struct exclude_list *el) 883{ 884 char *buf; 885 size_t size; 886 int r; 887 888 r = do_read_blob(oid, NULL, &size, &buf); 889 if (r != 1) 890 return r; 891 892 add_excludes_from_buffer(buf, size, base, baselen, el); 893 return 0; 894} 895 896struct exclude_list *add_exclude_list(struct dir_struct *dir, 897 int group_type, const char *src) 898{ 899 struct exclude_list *el; 900 struct exclude_list_group *group; 901 902 group = &dir->exclude_list_group[group_type]; 903 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 904 el = &group->el[group->nr++]; 905 memset(el, 0, sizeof(*el)); 906 el->src = src; 907 return el; 908} 909 910/* 911 * Used to set up core.excludesfile and .git/info/exclude lists. 912 */ 913static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname, 914 struct oid_stat *oid_stat) 915{ 916 struct exclude_list *el; 917 /* 918 * catch setup_standard_excludes() that's called before 919 * dir->untracked is assigned. That function behaves 920 * differently when dir->untracked is non-NULL. 921 */ 922 if (!dir->untracked) 923 dir->unmanaged_exclude_files++; 924 el = add_exclude_list(dir, EXC_FILE, fname); 925 if (add_excludes(fname, "", 0, el, NULL, oid_stat) < 0) 926 die(_("cannot use %s as an exclude file"), fname); 927} 928 929void add_excludes_from_file(struct dir_struct *dir, const char *fname) 930{ 931 dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */ 932 add_excludes_from_file_1(dir, fname, NULL); 933} 934 935int match_basename(const char *basename, int basenamelen, 936 const char *pattern, int prefix, int patternlen, 937 unsigned flags) 938{ 939 if (prefix == patternlen) { 940 if (patternlen == basenamelen && 941 !fspathncmp(pattern, basename, basenamelen)) 942 return 1; 943 } else if (flags & EXC_FLAG_ENDSWITH) { 944 /* "*literal" matching against "fooliteral" */ 945 if (patternlen - 1 <= basenamelen && 946 !fspathncmp(pattern + 1, 947 basename + basenamelen - (patternlen - 1), 948 patternlen - 1)) 949 return 1; 950 } else { 951 if (fnmatch_icase_mem(pattern, patternlen, 952 basename, basenamelen, 953 0) == 0) 954 return 1; 955 } 956 return 0; 957} 958 959int match_pathname(const char *pathname, int pathlen, 960 const char *base, int baselen, 961 const char *pattern, int prefix, int patternlen, 962 unsigned flags) 963{ 964 const char *name; 965 int namelen; 966 967 /* 968 * match with FNM_PATHNAME; the pattern has base implicitly 969 * in front of it. 970 */ 971 if (*pattern == '/') { 972 pattern++; 973 patternlen--; 974 prefix--; 975 } 976 977 /* 978 * baselen does not count the trailing slash. base[] may or 979 * may not end with a trailing slash though. 980 */ 981 if (pathlen < baselen + 1 || 982 (baselen && pathname[baselen] != '/') || 983 fspathncmp(pathname, base, baselen)) 984 return 0; 985 986 namelen = baselen ? pathlen - baselen - 1 : pathlen; 987 name = pathname + pathlen - namelen; 988 989 if (prefix) { 990 /* 991 * if the non-wildcard part is longer than the 992 * remaining pathname, surely it cannot match. 993 */ 994 if (prefix > namelen) 995 return 0; 996 997 if (fspathncmp(pattern, name, prefix)) 998 return 0; 999 pattern += prefix;1000 patternlen -= prefix;1001 name += prefix;1002 namelen -= prefix;10031004 /*1005 * If the whole pattern did not have a wildcard,1006 * then our prefix match is all we need; we1007 * do not need to call fnmatch at all.1008 */1009 if (!patternlen && !namelen)1010 return 1;1011 }10121013 return fnmatch_icase_mem(pattern, patternlen,1014 name, namelen,1015 WM_PATHNAME) == 0;1016}10171018/*1019 * Scan the given exclude list in reverse to see whether pathname1020 * should be ignored. The first match (i.e. the last on the list), if1021 * any, determines the fate. Returns the exclude_list element which1022 * matched, or NULL for undecided.1023 */1024static struct path_pattern *last_exclude_matching_from_list(const char *pathname,1025 int pathlen,1026 const char *basename,1027 int *dtype,1028 struct exclude_list *el,1029 struct index_state *istate)1030{1031 struct path_pattern *res = NULL; /* undecided */1032 int i;10331034 if (!el->nr)1035 return NULL; /* undefined */10361037 for (i = el->nr - 1; 0 <= i; i--) {1038 struct path_pattern *pattern = el->patterns[i];1039 const char *exclude = pattern->pattern;1040 int prefix = pattern->nowildcardlen;10411042 if (pattern->flags & EXC_FLAG_MUSTBEDIR) {1043 if (*dtype == DT_UNKNOWN)1044 *dtype = get_dtype(NULL, istate, pathname, pathlen);1045 if (*dtype != DT_DIR)1046 continue;1047 }10481049 if (pattern->flags & EXC_FLAG_NODIR) {1050 if (match_basename(basename,1051 pathlen - (basename - pathname),1052 exclude, prefix, pattern->patternlen,1053 pattern->flags)) {1054 res = pattern;1055 break;1056 }1057 continue;1058 }10591060 assert(pattern->baselen == 0 ||1061 pattern->base[pattern->baselen - 1] == '/');1062 if (match_pathname(pathname, pathlen,1063 pattern->base,1064 pattern->baselen ? pattern->baselen - 1 : 0,1065 exclude, prefix, pattern->patternlen,1066 pattern->flags)) {1067 res = pattern;1068 break;1069 }1070 }1071 return res;1072}10731074/*1075 * Scan the list and let the last match determine the fate.1076 * Return 1 for exclude, 0 for include and -1 for undecided.1077 */1078int is_excluded_from_list(const char *pathname,1079 int pathlen, const char *basename, int *dtype,1080 struct exclude_list *el, struct index_state *istate)1081{1082 struct path_pattern *pattern;1083 pattern = last_exclude_matching_from_list(pathname, pathlen, basename,1084 dtype, el, istate);1085 if (pattern)1086 return pattern->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1087 return -1; /* undecided */1088}10891090static struct path_pattern *last_exclude_matching_from_lists(1091 struct dir_struct *dir, struct index_state *istate,1092 const char *pathname, int pathlen,1093 const char *basename, int *dtype_p)1094{1095 int i, j;1096 struct exclude_list_group *group;1097 struct path_pattern *pattern;1098 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1099 group = &dir->exclude_list_group[i];1100 for (j = group->nr - 1; j >= 0; j--) {1101 pattern = last_exclude_matching_from_list(1102 pathname, pathlen, basename, dtype_p,1103 &group->el[j], istate);1104 if (pattern)1105 return pattern;1106 }1107 }1108 return NULL;1109}11101111/*1112 * Loads the per-directory exclude list for the substring of base1113 * which has a char length of baselen.1114 */1115static void prep_exclude(struct dir_struct *dir,1116 struct index_state *istate,1117 const char *base, int baselen)1118{1119 struct exclude_list_group *group;1120 struct exclude_list *el;1121 struct exclude_stack *stk = NULL;1122 struct untracked_cache_dir *untracked;1123 int current;11241125 group = &dir->exclude_list_group[EXC_DIRS];11261127 /*1128 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1129 * which originate from directories not in the prefix of the1130 * path being checked.1131 */1132 while ((stk = dir->exclude_stack) != NULL) {1133 if (stk->baselen <= baselen &&1134 !strncmp(dir->basebuf.buf, base, stk->baselen))1135 break;1136 el = &group->el[dir->exclude_stack->exclude_ix];1137 dir->exclude_stack = stk->prev;1138 dir->pattern = NULL;1139 free((char *)el->src); /* see strbuf_detach() below */1140 clear_exclude_list(el);1141 free(stk);1142 group->nr--;1143 }11441145 /* Skip traversing into sub directories if the parent is excluded */1146 if (dir->pattern)1147 return;11481149 /*1150 * Lazy initialization. All call sites currently just1151 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1152 * them seems lots of work for little benefit.1153 */1154 if (!dir->basebuf.buf)1155 strbuf_init(&dir->basebuf, PATH_MAX);11561157 /* Read from the parent directories and push them down. */1158 current = stk ? stk->baselen : -1;1159 strbuf_setlen(&dir->basebuf, current < 0 ? 0 : current);1160 if (dir->untracked)1161 untracked = stk ? stk->ucd : dir->untracked->root;1162 else1163 untracked = NULL;11641165 while (current < baselen) {1166 const char *cp;1167 struct oid_stat oid_stat;11681169 stk = xcalloc(1, sizeof(*stk));1170 if (current < 0) {1171 cp = base;1172 current = 0;1173 } else {1174 cp = strchr(base + current + 1, '/');1175 if (!cp)1176 die("oops in prep_exclude");1177 cp++;1178 untracked =1179 lookup_untracked(dir->untracked, untracked,1180 base + current,1181 cp - base - current);1182 }1183 stk->prev = dir->exclude_stack;1184 stk->baselen = cp - base;1185 stk->exclude_ix = group->nr;1186 stk->ucd = untracked;1187 el = add_exclude_list(dir, EXC_DIRS, NULL);1188 strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1189 assert(stk->baselen == dir->basebuf.len);11901191 /* Abort if the directory is excluded */1192 if (stk->baselen) {1193 int dt = DT_DIR;1194 dir->basebuf.buf[stk->baselen - 1] = 0;1195 dir->pattern = last_exclude_matching_from_lists(dir,1196 istate,1197 dir->basebuf.buf, stk->baselen - 1,1198 dir->basebuf.buf + current, &dt);1199 dir->basebuf.buf[stk->baselen - 1] = '/';1200 if (dir->pattern &&1201 dir->pattern->flags & EXC_FLAG_NEGATIVE)1202 dir->pattern = NULL;1203 if (dir->pattern) {1204 dir->exclude_stack = stk;1205 return;1206 }1207 }12081209 /* Try to read per-directory file */1210 oidclr(&oid_stat.oid);1211 oid_stat.valid = 0;1212 if (dir->exclude_per_dir &&1213 /*1214 * If we know that no files have been added in1215 * this directory (i.e. valid_cached_dir() has1216 * been executed and set untracked->valid) ..1217 */1218 (!untracked || !untracked->valid ||1219 /*1220 * .. and .gitignore does not exist before1221 * (i.e. null exclude_oid). Then we can skip1222 * loading .gitignore, which would result in1223 * ENOENT anyway.1224 */1225 !is_null_oid(&untracked->exclude_oid))) {1226 /*1227 * dir->basebuf gets reused by the traversal, but we1228 * need fname to remain unchanged to ensure the src1229 * member of each struct path_pattern correctly1230 * back-references its source file. Other invocations1231 * of add_exclude_list provide stable strings, so we1232 * strbuf_detach() and free() here in the caller.1233 */1234 struct strbuf sb = STRBUF_INIT;1235 strbuf_addbuf(&sb, &dir->basebuf);1236 strbuf_addstr(&sb, dir->exclude_per_dir);1237 el->src = strbuf_detach(&sb, NULL);1238 add_excludes(el->src, el->src, stk->baselen, el, istate,1239 untracked ? &oid_stat : NULL);1240 }1241 /*1242 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1243 * will first be called in valid_cached_dir() then maybe many1244 * times more in last_exclude_matching(). When the cache is1245 * used, last_exclude_matching() will not be called and1246 * reading .gitignore content will be a waste.1247 *1248 * So when it's called by valid_cached_dir() and we can get1249 * .gitignore SHA-1 from the index (i.e. .gitignore is not1250 * modified on work tree), we could delay reading the1251 * .gitignore content until we absolutely need it in1252 * last_exclude_matching(). Be careful about ignore rule1253 * order, though, if you do that.1254 */1255 if (untracked &&1256 !oideq(&oid_stat.oid, &untracked->exclude_oid)) {1257 invalidate_gitignore(dir->untracked, untracked);1258 oidcpy(&untracked->exclude_oid, &oid_stat.oid);1259 }1260 dir->exclude_stack = stk;1261 current = stk->baselen;1262 }1263 strbuf_setlen(&dir->basebuf, baselen);1264}12651266/*1267 * Loads the exclude lists for the directory containing pathname, then1268 * scans all exclude lists to determine whether pathname is excluded.1269 * Returns the exclude_list element which matched, or NULL for1270 * undecided.1271 */1272struct path_pattern *last_exclude_matching(struct dir_struct *dir,1273 struct index_state *istate,1274 const char *pathname,1275 int *dtype_p)1276{1277 int pathlen = strlen(pathname);1278 const char *basename = strrchr(pathname, '/');1279 basename = (basename) ? basename+1 : pathname;12801281 prep_exclude(dir, istate, pathname, basename-pathname);12821283 if (dir->pattern)1284 return dir->pattern;12851286 return last_exclude_matching_from_lists(dir, istate, pathname, pathlen,1287 basename, dtype_p);1288}12891290/*1291 * Loads the exclude lists for the directory containing pathname, then1292 * scans all exclude lists to determine whether pathname is excluded.1293 * Returns 1 if true, otherwise 0.1294 */1295int is_excluded(struct dir_struct *dir, struct index_state *istate,1296 const char *pathname, int *dtype_p)1297{1298 struct path_pattern *pattern =1299 last_exclude_matching(dir, istate, pathname, dtype_p);1300 if (pattern)1301 return pattern->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1302 return 0;1303}13041305static struct dir_entry *dir_entry_new(const char *pathname, int len)1306{1307 struct dir_entry *ent;13081309 FLEX_ALLOC_MEM(ent, name, pathname, len);1310 ent->len = len;1311 return ent;1312}13131314static struct dir_entry *dir_add_name(struct dir_struct *dir,1315 struct index_state *istate,1316 const char *pathname, int len)1317{1318 if (index_file_exists(istate, pathname, len, ignore_case))1319 return NULL;13201321 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1322 return dir->entries[dir->nr++] = dir_entry_new(pathname, len);1323}13241325struct dir_entry *dir_add_ignored(struct dir_struct *dir,1326 struct index_state *istate,1327 const char *pathname, int len)1328{1329 if (!index_name_is_other(istate, pathname, len))1330 return NULL;13311332 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1333 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);1334}13351336enum exist_status {1337 index_nonexistent = 0,1338 index_directory,1339 index_gitdir1340};13411342/*1343 * Do not use the alphabetically sorted index to look up1344 * the directory name; instead, use the case insensitive1345 * directory hash.1346 */1347static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1348 const char *dirname, int len)1349{1350 struct cache_entry *ce;13511352 if (index_dir_exists(istate, dirname, len))1353 return index_directory;13541355 ce = index_file_exists(istate, dirname, len, ignore_case);1356 if (ce && S_ISGITLINK(ce->ce_mode))1357 return index_gitdir;13581359 return index_nonexistent;1360}13611362/*1363 * The index sorts alphabetically by entry name, which1364 * means that a gitlink sorts as '\0' at the end, while1365 * a directory (which is defined not as an entry, but as1366 * the files it contains) will sort with the '/' at the1367 * end.1368 */1369static enum exist_status directory_exists_in_index(struct index_state *istate,1370 const char *dirname, int len)1371{1372 int pos;13731374 if (ignore_case)1375 return directory_exists_in_index_icase(istate, dirname, len);13761377 pos = index_name_pos(istate, dirname, len);1378 if (pos < 0)1379 pos = -pos-1;1380 while (pos < istate->cache_nr) {1381 const struct cache_entry *ce = istate->cache[pos++];1382 unsigned char endchar;13831384 if (strncmp(ce->name, dirname, len))1385 break;1386 endchar = ce->name[len];1387 if (endchar > '/')1388 break;1389 if (endchar == '/')1390 return index_directory;1391 if (!endchar && S_ISGITLINK(ce->ce_mode))1392 return index_gitdir;1393 }1394 return index_nonexistent;1395}13961397/*1398 * When we find a directory when traversing the filesystem, we1399 * have three distinct cases:1400 *1401 * - ignore it1402 * - see it as a directory1403 * - recurse into it1404 *1405 * and which one we choose depends on a combination of existing1406 * git index contents and the flags passed into the directory1407 * traversal routine.1408 *1409 * Case 1: If we *already* have entries in the index under that1410 * directory name, we always recurse into the directory to see1411 * all the files.1412 *1413 * Case 2: If we *already* have that directory name as a gitlink,1414 * we always continue to see it as a gitlink, regardless of whether1415 * there is an actual git directory there or not (it might not1416 * be checked out as a subproject!)1417 *1418 * Case 3: if we didn't have it in the index previously, we1419 * have a few sub-cases:1420 *1421 * (a) if "show_other_directories" is true, we show it as1422 * just a directory, unless "hide_empty_directories" is1423 * also true, in which case we need to check if it contains any1424 * untracked and / or ignored files.1425 * (b) if it looks like a git directory, and we don't have1426 * 'no_gitlinks' set we treat it as a gitlink, and show it1427 * as a directory.1428 * (c) otherwise, we recurse into it.1429 */1430static enum path_treatment treat_directory(struct dir_struct *dir,1431 struct index_state *istate,1432 struct untracked_cache_dir *untracked,1433 const char *dirname, int len, int baselen, int exclude,1434 const struct pathspec *pathspec)1435{1436 /* The "len-1" is to strip the final '/' */1437 switch (directory_exists_in_index(istate, dirname, len-1)) {1438 case index_directory:1439 return path_recurse;14401441 case index_gitdir:1442 return path_none;14431444 case index_nonexistent:1445 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1446 break;1447 if (exclude &&1448 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1449 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING)) {14501451 /*1452 * This is an excluded directory and we are1453 * showing ignored paths that match an exclude1454 * pattern. (e.g. show directory as ignored1455 * only if it matches an exclude pattern).1456 * This path will either be 'path_excluded`1457 * (if we are showing empty directories or if1458 * the directory is not empty), or will be1459 * 'path_none' (empty directory, and we are1460 * not showing empty directories).1461 */1462 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1463 return path_excluded;14641465 if (read_directory_recursive(dir, istate, dirname, len,1466 untracked, 1, 1, pathspec) == path_excluded)1467 return path_excluded;14681469 return path_none;1470 }1471 if (!(dir->flags & DIR_NO_GITLINKS)) {1472 struct strbuf sb = STRBUF_INIT;1473 strbuf_addstr(&sb, dirname);1474 if (is_nonbare_repository_dir(&sb))1475 return exclude ? path_excluded : path_untracked;1476 strbuf_release(&sb);1477 }1478 return path_recurse;1479 }14801481 /* This is the "show_other_directories" case */14821483 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1484 return exclude ? path_excluded : path_untracked;14851486 untracked = lookup_untracked(dir->untracked, untracked,1487 dirname + baselen, len - baselen);14881489 /*1490 * If this is an excluded directory, then we only need to check if1491 * the directory contains any files.1492 */1493 return read_directory_recursive(dir, istate, dirname, len,1494 untracked, 1, exclude, pathspec);1495}14961497/*1498 * This is an inexact early pruning of any recursive directory1499 * reading - if the path cannot possibly be in the pathspec,1500 * return true, and we'll skip it early.1501 */1502static int simplify_away(const char *path, int pathlen,1503 const struct pathspec *pathspec)1504{1505 int i;15061507 if (!pathspec || !pathspec->nr)1508 return 0;15091510 GUARD_PATHSPEC(pathspec,1511 PATHSPEC_FROMTOP |1512 PATHSPEC_MAXDEPTH |1513 PATHSPEC_LITERAL |1514 PATHSPEC_GLOB |1515 PATHSPEC_ICASE |1516 PATHSPEC_EXCLUDE |1517 PATHSPEC_ATTR);15181519 for (i = 0; i < pathspec->nr; i++) {1520 const struct pathspec_item *item = &pathspec->items[i];1521 int len = item->nowildcard_len;15221523 if (len > pathlen)1524 len = pathlen;1525 if (!ps_strncmp(item, item->match, path, len))1526 return 0;1527 }15281529 return 1;1530}15311532/*1533 * This function tells us whether an excluded path matches a1534 * list of "interesting" pathspecs. That is, whether a path matched1535 * by any of the pathspecs could possibly be ignored by excluding1536 * the specified path. This can happen if:1537 *1538 * 1. the path is mentioned explicitly in the pathspec1539 *1540 * 2. the path is a directory prefix of some element in the1541 * pathspec1542 */1543static int exclude_matches_pathspec(const char *path, int pathlen,1544 const struct pathspec *pathspec)1545{1546 int i;15471548 if (!pathspec || !pathspec->nr)1549 return 0;15501551 GUARD_PATHSPEC(pathspec,1552 PATHSPEC_FROMTOP |1553 PATHSPEC_MAXDEPTH |1554 PATHSPEC_LITERAL |1555 PATHSPEC_GLOB |1556 PATHSPEC_ICASE |1557 PATHSPEC_EXCLUDE);15581559 for (i = 0; i < pathspec->nr; i++) {1560 const struct pathspec_item *item = &pathspec->items[i];1561 int len = item->nowildcard_len;15621563 if (len == pathlen &&1564 !ps_strncmp(item, item->match, path, pathlen))1565 return 1;1566 if (len > pathlen &&1567 item->match[pathlen] == '/' &&1568 !ps_strncmp(item, item->match, path, pathlen))1569 return 1;1570 }1571 return 0;1572}15731574static int get_index_dtype(struct index_state *istate,1575 const char *path, int len)1576{1577 int pos;1578 const struct cache_entry *ce;15791580 ce = index_file_exists(istate, path, len, 0);1581 if (ce) {1582 if (!ce_uptodate(ce))1583 return DT_UNKNOWN;1584 if (S_ISGITLINK(ce->ce_mode))1585 return DT_DIR;1586 /*1587 * Nobody actually cares about the1588 * difference between DT_LNK and DT_REG1589 */1590 return DT_REG;1591 }15921593 /* Try to look it up as a directory */1594 pos = index_name_pos(istate, path, len);1595 if (pos >= 0)1596 return DT_UNKNOWN;1597 pos = -pos-1;1598 while (pos < istate->cache_nr) {1599 ce = istate->cache[pos++];1600 if (strncmp(ce->name, path, len))1601 break;1602 if (ce->name[len] > '/')1603 break;1604 if (ce->name[len] < '/')1605 continue;1606 if (!ce_uptodate(ce))1607 break; /* continue? */1608 return DT_DIR;1609 }1610 return DT_UNKNOWN;1611}16121613static int get_dtype(struct dirent *de, struct index_state *istate,1614 const char *path, int len)1615{1616 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1617 struct stat st;16181619 if (dtype != DT_UNKNOWN)1620 return dtype;1621 dtype = get_index_dtype(istate, path, len);1622 if (dtype != DT_UNKNOWN)1623 return dtype;1624 if (lstat(path, &st))1625 return dtype;1626 if (S_ISREG(st.st_mode))1627 return DT_REG;1628 if (S_ISDIR(st.st_mode))1629 return DT_DIR;1630 if (S_ISLNK(st.st_mode))1631 return DT_LNK;1632 return dtype;1633}16341635static enum path_treatment treat_one_path(struct dir_struct *dir,1636 struct untracked_cache_dir *untracked,1637 struct index_state *istate,1638 struct strbuf *path,1639 int baselen,1640 const struct pathspec *pathspec,1641 int dtype, struct dirent *de)1642{1643 int exclude;1644 int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);1645 enum path_treatment path_treatment;16461647 if (dtype == DT_UNKNOWN)1648 dtype = get_dtype(de, istate, path->buf, path->len);16491650 /* Always exclude indexed files */1651 if (dtype != DT_DIR && has_path_in_index)1652 return path_none;16531654 /*1655 * When we are looking at a directory P in the working tree,1656 * there are three cases:1657 *1658 * (1) P exists in the index. Everything inside the directory P in1659 * the working tree needs to go when P is checked out from the1660 * index.1661 *1662 * (2) P does not exist in the index, but there is P/Q in the index.1663 * We know P will stay a directory when we check out the contents1664 * of the index, but we do not know yet if there is a directory1665 * P/Q in the working tree to be killed, so we need to recurse.1666 *1667 * (3) P does not exist in the index, and there is no P/Q in the index1668 * to require P to be a directory, either. Only in this case, we1669 * know that everything inside P will not be killed without1670 * recursing.1671 */1672 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1673 (dtype == DT_DIR) &&1674 !has_path_in_index &&1675 (directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))1676 return path_none;16771678 exclude = is_excluded(dir, istate, path->buf, &dtype);16791680 /*1681 * Excluded? If we don't explicitly want to show1682 * ignored files, ignore it1683 */1684 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1685 return path_excluded;16861687 switch (dtype) {1688 default:1689 return path_none;1690 case DT_DIR:1691 strbuf_addch(path, '/');1692 path_treatment = treat_directory(dir, istate, untracked,1693 path->buf, path->len,1694 baselen, exclude, pathspec);1695 /*1696 * If 1) we only want to return directories that1697 * match an exclude pattern and 2) this directory does1698 * not match an exclude pattern but all of its1699 * contents are excluded, then indicate that we should1700 * recurse into this directory (instead of marking the1701 * directory itself as an ignored path).1702 */1703 if (!exclude &&1704 path_treatment == path_excluded &&1705 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1706 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING))1707 return path_recurse;1708 return path_treatment;1709 case DT_REG:1710 case DT_LNK:1711 return exclude ? path_excluded : path_untracked;1712 }1713}17141715static enum path_treatment treat_path_fast(struct dir_struct *dir,1716 struct untracked_cache_dir *untracked,1717 struct cached_dir *cdir,1718 struct index_state *istate,1719 struct strbuf *path,1720 int baselen,1721 const struct pathspec *pathspec)1722{1723 strbuf_setlen(path, baselen);1724 if (!cdir->ucd) {1725 strbuf_addstr(path, cdir->file);1726 return path_untracked;1727 }1728 strbuf_addstr(path, cdir->ucd->name);1729 /* treat_one_path() does this before it calls treat_directory() */1730 strbuf_complete(path, '/');1731 if (cdir->ucd->check_only)1732 /*1733 * check_only is set as a result of treat_directory() getting1734 * to its bottom. Verify again the same set of directories1735 * with check_only set.1736 */1737 return read_directory_recursive(dir, istate, path->buf, path->len,1738 cdir->ucd, 1, 0, pathspec);1739 /*1740 * We get path_recurse in the first run when1741 * directory_exists_in_index() returns index_nonexistent. We1742 * are sure that new changes in the index does not impact the1743 * outcome. Return now.1744 */1745 return path_recurse;1746}17471748static enum path_treatment treat_path(struct dir_struct *dir,1749 struct untracked_cache_dir *untracked,1750 struct cached_dir *cdir,1751 struct index_state *istate,1752 struct strbuf *path,1753 int baselen,1754 const struct pathspec *pathspec)1755{1756 int dtype;1757 struct dirent *de = cdir->de;17581759 if (!de)1760 return treat_path_fast(dir, untracked, cdir, istate, path,1761 baselen, pathspec);1762 if (is_dot_or_dotdot(de->d_name) || !fspathcmp(de->d_name, ".git"))1763 return path_none;1764 strbuf_setlen(path, baselen);1765 strbuf_addstr(path, de->d_name);1766 if (simplify_away(path->buf, path->len, pathspec))1767 return path_none;17681769 dtype = DTYPE(de);1770 return treat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1771}17721773static void add_untracked(struct untracked_cache_dir *dir, const char *name)1774{1775 if (!dir)1776 return;1777 ALLOC_GROW(dir->untracked, dir->untracked_nr + 1,1778 dir->untracked_alloc);1779 dir->untracked[dir->untracked_nr++] = xstrdup(name);1780}17811782static int valid_cached_dir(struct dir_struct *dir,1783 struct untracked_cache_dir *untracked,1784 struct index_state *istate,1785 struct strbuf *path,1786 int check_only)1787{1788 struct stat st;17891790 if (!untracked)1791 return 0;17921793 /*1794 * With fsmonitor, we can trust the untracked cache's valid field.1795 */1796 refresh_fsmonitor(istate);1797 if (!(dir->untracked->use_fsmonitor && untracked->valid)) {1798 if (lstat(path->len ? path->buf : ".", &st)) {1799 memset(&untracked->stat_data, 0, sizeof(untracked->stat_data));1800 return 0;1801 }1802 if (!untracked->valid ||1803 match_stat_data_racy(istate, &untracked->stat_data, &st)) {1804 fill_stat_data(&untracked->stat_data, &st);1805 return 0;1806 }1807 }18081809 if (untracked->check_only != !!check_only)1810 return 0;18111812 /*1813 * prep_exclude will be called eventually on this directory,1814 * but it's called much later in last_exclude_matching(). We1815 * need it now to determine the validity of the cache for this1816 * path. The next calls will be nearly no-op, the way1817 * prep_exclude() is designed.1818 */1819 if (path->len && path->buf[path->len - 1] != '/') {1820 strbuf_addch(path, '/');1821 prep_exclude(dir, istate, path->buf, path->len);1822 strbuf_setlen(path, path->len - 1);1823 } else1824 prep_exclude(dir, istate, path->buf, path->len);18251826 /* hopefully prep_exclude() haven't invalidated this entry... */1827 return untracked->valid;1828}18291830static int open_cached_dir(struct cached_dir *cdir,1831 struct dir_struct *dir,1832 struct untracked_cache_dir *untracked,1833 struct index_state *istate,1834 struct strbuf *path,1835 int check_only)1836{1837 const char *c_path;18381839 memset(cdir, 0, sizeof(*cdir));1840 cdir->untracked = untracked;1841 if (valid_cached_dir(dir, untracked, istate, path, check_only))1842 return 0;1843 c_path = path->len ? path->buf : ".";1844 cdir->fdir = opendir(c_path);1845 if (!cdir->fdir)1846 warning_errno(_("could not open directory '%s'"), c_path);1847 if (dir->untracked) {1848 invalidate_directory(dir->untracked, untracked);1849 dir->untracked->dir_opened++;1850 }1851 if (!cdir->fdir)1852 return -1;1853 return 0;1854}18551856static int read_cached_dir(struct cached_dir *cdir)1857{1858 if (cdir->fdir) {1859 cdir->de = readdir(cdir->fdir);1860 if (!cdir->de)1861 return -1;1862 return 0;1863 }1864 while (cdir->nr_dirs < cdir->untracked->dirs_nr) {1865 struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1866 if (!d->recurse) {1867 cdir->nr_dirs++;1868 continue;1869 }1870 cdir->ucd = d;1871 cdir->nr_dirs++;1872 return 0;1873 }1874 cdir->ucd = NULL;1875 if (cdir->nr_files < cdir->untracked->untracked_nr) {1876 struct untracked_cache_dir *d = cdir->untracked;1877 cdir->file = d->untracked[cdir->nr_files++];1878 return 0;1879 }1880 return -1;1881}18821883static void close_cached_dir(struct cached_dir *cdir)1884{1885 if (cdir->fdir)1886 closedir(cdir->fdir);1887 /*1888 * We have gone through this directory and found no untracked1889 * entries. Mark it valid.1890 */1891 if (cdir->untracked) {1892 cdir->untracked->valid = 1;1893 cdir->untracked->recurse = 1;1894 }1895}18961897/*1898 * Read a directory tree. We currently ignore anything but1899 * directories, regular files and symlinks. That's because git1900 * doesn't handle them at all yet. Maybe that will change some1901 * day.1902 *1903 * Also, we ignore the name ".git" (even if it is not a directory).1904 * That likely will not change.1905 *1906 * If 'stop_at_first_file' is specified, 'path_excluded' is returned1907 * to signal that a file was found. This is the least significant value that1908 * indicates that a file was encountered that does not depend on the order of1909 * whether an untracked or exluded path was encountered first.1910 *1911 * Returns the most significant path_treatment value encountered in the scan.1912 * If 'stop_at_first_file' is specified, `path_excluded` is the most1913 * significant path_treatment value that will be returned.1914 */19151916static enum path_treatment read_directory_recursive(struct dir_struct *dir,1917 struct index_state *istate, const char *base, int baselen,1918 struct untracked_cache_dir *untracked, int check_only,1919 int stop_at_first_file, const struct pathspec *pathspec)1920{1921 struct cached_dir cdir;1922 enum path_treatment state, subdir_state, dir_state = path_none;1923 struct strbuf path = STRBUF_INIT;19241925 strbuf_add(&path, base, baselen);19261927 if (open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1928 goto out;19291930 if (untracked)1931 untracked->check_only = !!check_only;19321933 while (!read_cached_dir(&cdir)) {1934 /* check how the file or directory should be treated */1935 state = treat_path(dir, untracked, &cdir, istate, &path,1936 baselen, pathspec);19371938 if (state > dir_state)1939 dir_state = state;19401941 /* recurse into subdir if instructed by treat_path */1942 if ((state == path_recurse) ||1943 ((state == path_untracked) &&1944 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1945 (get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {1946 struct untracked_cache_dir *ud;1947 ud = lookup_untracked(dir->untracked, untracked,1948 path.buf + baselen,1949 path.len - baselen);1950 subdir_state =1951 read_directory_recursive(dir, istate, path.buf,1952 path.len, ud,1953 check_only, stop_at_first_file, pathspec);1954 if (subdir_state > dir_state)1955 dir_state = subdir_state;1956 }19571958 if (check_only) {1959 if (stop_at_first_file) {1960 /*1961 * If stopping at first file, then1962 * signal that a file was found by1963 * returning `path_excluded`. This is1964 * to return a consistent value1965 * regardless of whether an ignored or1966 * excluded file happened to be1967 * encountered 1st.1968 *1969 * In current usage, the1970 * `stop_at_first_file` is passed when1971 * an ancestor directory has matched1972 * an exclude pattern, so any found1973 * files will be excluded.1974 */1975 if (dir_state >= path_excluded) {1976 dir_state = path_excluded;1977 break;1978 }1979 }19801981 /* abort early if maximum state has been reached */1982 if (dir_state == path_untracked) {1983 if (cdir.fdir)1984 add_untracked(untracked, path.buf + baselen);1985 break;1986 }1987 /* skip the dir_add_* part */1988 continue;1989 }19901991 /* add the path to the appropriate result list */1992 switch (state) {1993 case path_excluded:1994 if (dir->flags & DIR_SHOW_IGNORED)1995 dir_add_name(dir, istate, path.buf, path.len);1996 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||1997 ((dir->flags & DIR_COLLECT_IGNORED) &&1998 exclude_matches_pathspec(path.buf, path.len,1999 pathspec)))2000 dir_add_ignored(dir, istate, path.buf, path.len);2001 break;20022003 case path_untracked:2004 if (dir->flags & DIR_SHOW_IGNORED)2005 break;2006 dir_add_name(dir, istate, path.buf, path.len);2007 if (cdir.fdir)2008 add_untracked(untracked, path.buf + baselen);2009 break;20102011 default:2012 break;2013 }2014 }2015 close_cached_dir(&cdir);2016 out:2017 strbuf_release(&path);20182019 return dir_state;2020}20212022int cmp_dir_entry(const void *p1, const void *p2)2023{2024 const struct dir_entry *e1 = *(const struct dir_entry **)p1;2025 const struct dir_entry *e2 = *(const struct dir_entry **)p2;20262027 return name_compare(e1->name, e1->len, e2->name, e2->len);2028}20292030/* check if *out lexically strictly contains *in */2031int check_dir_entry_contains(const struct dir_entry *out, const struct dir_entry *in)2032{2033 return (out->len < in->len) &&2034 (out->name[out->len - 1] == '/') &&2035 !memcmp(out->name, in->name, out->len);2036}20372038static int treat_leading_path(struct dir_struct *dir,2039 struct index_state *istate,2040 const char *path, int len,2041 const struct pathspec *pathspec)2042{2043 struct strbuf sb = STRBUF_INIT;2044 int baselen, rc = 0;2045 const char *cp;2046 int old_flags = dir->flags;20472048 while (len && path[len - 1] == '/')2049 len--;2050 if (!len)2051 return 1;2052 baselen = 0;2053 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;2054 while (1) {2055 cp = path + baselen + !!baselen;2056 cp = memchr(cp, '/', path + len - cp);2057 if (!cp)2058 baselen = len;2059 else2060 baselen = cp - path;2061 strbuf_setlen(&sb, 0);2062 strbuf_add(&sb, path, baselen);2063 if (!is_directory(sb.buf))2064 break;2065 if (simplify_away(sb.buf, sb.len, pathspec))2066 break;2067 if (treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,2068 DT_DIR, NULL) == path_none)2069 break; /* do not recurse into it */2070 if (len <= baselen) {2071 rc = 1;2072 break; /* finished checking */2073 }2074 }2075 strbuf_release(&sb);2076 dir->flags = old_flags;2077 return rc;2078}20792080static const char *get_ident_string(void)2081{2082 static struct strbuf sb = STRBUF_INIT;2083 struct utsname uts;20842085 if (sb.len)2086 return sb.buf;2087 if (uname(&uts) < 0)2088 die_errno(_("failed to get kernel name and information"));2089 strbuf_addf(&sb, "Location %s, system %s", get_git_work_tree(),2090 uts.sysname);2091 return sb.buf;2092}20932094static int ident_in_untracked(const struct untracked_cache *uc)2095{2096 /*2097 * Previous git versions may have saved many NUL separated2098 * strings in the "ident" field, but it is insane to manage2099 * many locations, so just take care of the first one.2100 */21012102 return !strcmp(uc->ident.buf, get_ident_string());2103}21042105static void set_untracked_ident(struct untracked_cache *uc)2106{2107 strbuf_reset(&uc->ident);2108 strbuf_addstr(&uc->ident, get_ident_string());21092110 /*2111 * This strbuf used to contain a list of NUL separated2112 * strings, so save NUL too for backward compatibility.2113 */2114 strbuf_addch(&uc->ident, 0);2115}21162117static void new_untracked_cache(struct index_state *istate)2118{2119 struct untracked_cache *uc = xcalloc(1, sizeof(*uc));2120 strbuf_init(&uc->ident, 100);2121 uc->exclude_per_dir = ".gitignore";2122 /* should be the same flags used by git-status */2123 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;2124 set_untracked_ident(uc);2125 istate->untracked = uc;2126 istate->cache_changed |= UNTRACKED_CHANGED;2127}21282129void add_untracked_cache(struct index_state *istate)2130{2131 if (!istate->untracked) {2132 new_untracked_cache(istate);2133 } else {2134 if (!ident_in_untracked(istate->untracked)) {2135 free_untracked_cache(istate->untracked);2136 new_untracked_cache(istate);2137 }2138 }2139}21402141void remove_untracked_cache(struct index_state *istate)2142{2143 if (istate->untracked) {2144 free_untracked_cache(istate->untracked);2145 istate->untracked = NULL;2146 istate->cache_changed |= UNTRACKED_CHANGED;2147 }2148}21492150static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,2151 int base_len,2152 const struct pathspec *pathspec)2153{2154 struct untracked_cache_dir *root;2155 static int untracked_cache_disabled = -1;21562157 if (!dir->untracked)2158 return NULL;2159 if (untracked_cache_disabled < 0)2160 untracked_cache_disabled = git_env_bool("GIT_DISABLE_UNTRACKED_CACHE", 0);2161 if (untracked_cache_disabled)2162 return NULL;21632164 /*2165 * We only support $GIT_DIR/info/exclude and core.excludesfile2166 * as the global ignore rule files. Any other additions2167 * (e.g. from command line) invalidate the cache. This2168 * condition also catches running setup_standard_excludes()2169 * before setting dir->untracked!2170 */2171 if (dir->unmanaged_exclude_files)2172 return NULL;21732174 /*2175 * Optimize for the main use case only: whole-tree git2176 * status. More work involved in treat_leading_path() if we2177 * use cache on just a subset of the worktree. pathspec2178 * support could make the matter even worse.2179 */2180 if (base_len || (pathspec && pathspec->nr))2181 return NULL;21822183 /* Different set of flags may produce different results */2184 if (dir->flags != dir->untracked->dir_flags ||2185 /*2186 * See treat_directory(), case index_nonexistent. Without2187 * this flag, we may need to also cache .git file content2188 * for the resolve_gitlink_ref() call, which we don't.2189 */2190 !(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2191 /* We don't support collecting ignore files */2192 (dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2193 DIR_COLLECT_IGNORED)))2194 return NULL;21952196 /*2197 * If we use .gitignore in the cache and now you change it to2198 * .gitexclude, everything will go wrong.2199 */2200 if (dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2201 strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2202 return NULL;22032204 /*2205 * EXC_CMDL is not considered in the cache. If people set it,2206 * skip the cache.2207 */2208 if (dir->exclude_list_group[EXC_CMDL].nr)2209 return NULL;22102211 if (!ident_in_untracked(dir->untracked)) {2212 warning(_("untracked cache is disabled on this system or location"));2213 return NULL;2214 }22152216 if (!dir->untracked->root) {2217 const int len = sizeof(*dir->untracked->root);2218 dir->untracked->root = xmalloc(len);2219 memset(dir->untracked->root, 0, len);2220 }22212222 /* Validate $GIT_DIR/info/exclude and core.excludesfile */2223 root = dir->untracked->root;2224 if (!oideq(&dir->ss_info_exclude.oid,2225 &dir->untracked->ss_info_exclude.oid)) {2226 invalidate_gitignore(dir->untracked, root);2227 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2228 }2229 if (!oideq(&dir->ss_excludes_file.oid,2230 &dir->untracked->ss_excludes_file.oid)) {2231 invalidate_gitignore(dir->untracked, root);2232 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2233 }22342235 /* Make sure this directory is not dropped out at saving phase */2236 root->recurse = 1;2237 return root;2238}22392240int read_directory(struct dir_struct *dir, struct index_state *istate,2241 const char *path, int len, const struct pathspec *pathspec)2242{2243 struct untracked_cache_dir *untracked;22442245 trace_performance_enter();22462247 if (has_symlink_leading_path(path, len)) {2248 trace_performance_leave("read directory %.*s", len, path);2249 return dir->nr;2250 }22512252 untracked = validate_untracked_cache(dir, len, pathspec);2253 if (!untracked)2254 /*2255 * make sure untracked cache code path is disabled,2256 * e.g. prep_exclude()2257 */2258 dir->untracked = NULL;2259 if (!len || treat_leading_path(dir, istate, path, len, pathspec))2260 read_directory_recursive(dir, istate, path, len, untracked, 0, 0, pathspec);2261 QSORT(dir->entries, dir->nr, cmp_dir_entry);2262 QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);22632264 /*2265 * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will2266 * also pick up untracked contents of untracked dirs; by default2267 * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.2268 */2269 if ((dir->flags & DIR_SHOW_IGNORED_TOO) &&2270 !(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {2271 int i, j;22722273 /* remove from dir->entries untracked contents of untracked dirs */2274 for (i = j = 0; j < dir->nr; j++) {2275 if (i &&2276 check_dir_entry_contains(dir->entries[i - 1], dir->entries[j])) {2277 FREE_AND_NULL(dir->entries[j]);2278 } else {2279 dir->entries[i++] = dir->entries[j];2280 }2281 }22822283 dir->nr = i;2284 }22852286 trace_performance_leave("read directory %.*s", len, path);2287 if (dir->untracked) {2288 static int force_untracked_cache = -1;2289 static struct trace_key trace_untracked_stats = TRACE_KEY_INIT(UNTRACKED_STATS);22902291 if (force_untracked_cache < 0)2292 force_untracked_cache =2293 git_env_bool("GIT_FORCE_UNTRACKED_CACHE", 0);2294 trace_printf_key(&trace_untracked_stats,2295 "node creation: %u\n"2296 "gitignore invalidation: %u\n"2297 "directory invalidation: %u\n"2298 "opendir: %u\n",2299 dir->untracked->dir_created,2300 dir->untracked->gitignore_invalidated,2301 dir->untracked->dir_invalidated,2302 dir->untracked->dir_opened);2303 if (force_untracked_cache &&2304 dir->untracked == istate->untracked &&2305 (dir->untracked->dir_opened ||2306 dir->untracked->gitignore_invalidated ||2307 dir->untracked->dir_invalidated))2308 istate->cache_changed |= UNTRACKED_CHANGED;2309 if (dir->untracked != istate->untracked) {2310 FREE_AND_NULL(dir->untracked);2311 }2312 }2313 return dir->nr;2314}23152316int file_exists(const char *f)2317{2318 struct stat sb;2319 return lstat(f, &sb) == 0;2320}23212322int repo_file_exists(struct repository *repo, const char *path)2323{2324 if (repo != the_repository)2325 BUG("do not know how to check file existence in arbitrary repo");23262327 return file_exists(path);2328}23292330static int cmp_icase(char a, char b)2331{2332 if (a == b)2333 return 0;2334 if (ignore_case)2335 return toupper(a) - toupper(b);2336 return a - b;2337}23382339/*2340 * Given two normalized paths (a trailing slash is ok), if subdir is2341 * outside dir, return -1. Otherwise return the offset in subdir that2342 * can be used as relative path to dir.2343 */2344int dir_inside_of(const char *subdir, const char *dir)2345{2346 int offset = 0;23472348 assert(dir && subdir && *dir && *subdir);23492350 while (*dir && *subdir && !cmp_icase(*dir, *subdir)) {2351 dir++;2352 subdir++;2353 offset++;2354 }23552356 /* hel[p]/me vs hel[l]/yeah */2357 if (*dir && *subdir)2358 return -1;23592360 if (!*subdir)2361 return !*dir ? offset : -1; /* same dir */23622363 /* foo/[b]ar vs foo/[] */2364 if (is_dir_sep(dir[-1]))2365 return is_dir_sep(subdir[-1]) ? offset : -1;23662367 /* foo[/]bar vs foo[] */2368 return is_dir_sep(*subdir) ? offset + 1 : -1;2369}23702371int is_inside_dir(const char *dir)2372{2373 char *cwd;2374 int rc;23752376 if (!dir)2377 return 0;23782379 cwd = xgetcwd();2380 rc = (dir_inside_of(cwd, dir) >= 0);2381 free(cwd);2382 return rc;2383}23842385int is_empty_dir(const char *path)2386{2387 DIR *dir = opendir(path);2388 struct dirent *e;2389 int ret = 1;23902391 if (!dir)2392 return 0;23932394 while ((e = readdir(dir)) != NULL)2395 if (!is_dot_or_dotdot(e->d_name)) {2396 ret = 0;2397 break;2398 }23992400 closedir(dir);2401 return ret;2402}24032404static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)2405{2406 DIR *dir;2407 struct dirent *e;2408 int ret = 0, original_len = path->len, len, kept_down = 0;2409 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2410 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2411 struct object_id submodule_head;24122413 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2414 !resolve_gitlink_ref(path->buf, "HEAD", &submodule_head)) {2415 /* Do not descend and nuke a nested git work tree. */2416 if (kept_up)2417 *kept_up = 1;2418 return 0;2419 }24202421 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2422 dir = opendir(path->buf);2423 if (!dir) {2424 if (errno == ENOENT)2425 return keep_toplevel ? -1 : 0;2426 else if (errno == EACCES && !keep_toplevel)2427 /*2428 * An empty dir could be removable even if it2429 * is unreadable:2430 */2431 return rmdir(path->buf);2432 else2433 return -1;2434 }2435 strbuf_complete(path, '/');24362437 len = path->len;2438 while ((e = readdir(dir)) != NULL) {2439 struct stat st;2440 if (is_dot_or_dotdot(e->d_name))2441 continue;24422443 strbuf_setlen(path, len);2444 strbuf_addstr(path, e->d_name);2445 if (lstat(path->buf, &st)) {2446 if (errno == ENOENT)2447 /*2448 * file disappeared, which is what we2449 * wanted anyway2450 */2451 continue;2452 /* fall thru */2453 } else if (S_ISDIR(st.st_mode)) {2454 if (!remove_dir_recurse(path, flag, &kept_down))2455 continue; /* happy */2456 } else if (!only_empty &&2457 (!unlink(path->buf) || errno == ENOENT)) {2458 continue; /* happy, too */2459 }24602461 /* path too long, stat fails, or non-directory still exists */2462 ret = -1;2463 break;2464 }2465 closedir(dir);24662467 strbuf_setlen(path, original_len);2468 if (!ret && !keep_toplevel && !kept_down)2469 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;2470 else if (kept_up)2471 /*2472 * report the uplevel that it is not an error that we2473 * did not rmdir() our directory.2474 */2475 *kept_up = !ret;2476 return ret;2477}24782479int remove_dir_recursively(struct strbuf *path, int flag)2480{2481 return remove_dir_recurse(path, flag, NULL);2482}24832484static GIT_PATH_FUNC(git_path_info_exclude, "info/exclude")24852486void setup_standard_excludes(struct dir_struct *dir)2487{2488 dir->exclude_per_dir = ".gitignore";24892490 /* core.excludesfile defaulting to $XDG_CONFIG_HOME/git/ignore */2491 if (!excludes_file)2492 excludes_file = xdg_config_home("ignore");2493 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))2494 add_excludes_from_file_1(dir, excludes_file,2495 dir->untracked ? &dir->ss_excludes_file : NULL);24962497 /* per repository user preference */2498 if (startup_info->have_repository) {2499 const char *path = git_path_info_exclude();2500 if (!access_or_warn(path, R_OK, 0))2501 add_excludes_from_file_1(dir, path,2502 dir->untracked ? &dir->ss_info_exclude : NULL);2503 }2504}25052506int remove_path(const char *name)2507{2508 char *slash;25092510 if (unlink(name) && !is_missing_file_error(errno))2511 return -1;25122513 slash = strrchr(name, '/');2514 if (slash) {2515 char *dirs = xstrdup(name);2516 slash = dirs + (slash - name);2517 do {2518 *slash = '\0';2519 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));2520 free(dirs);2521 }2522 return 0;2523}25242525/*2526 * Frees memory within dir which was allocated for exclude lists and2527 * the exclude_stack. Does not free dir itself.2528 */2529void clear_directory(struct dir_struct *dir)2530{2531 int i, j;2532 struct exclude_list_group *group;2533 struct exclude_list *el;2534 struct exclude_stack *stk;25352536 for (i = EXC_CMDL; i <= EXC_FILE; i++) {2537 group = &dir->exclude_list_group[i];2538 for (j = 0; j < group->nr; j++) {2539 el = &group->el[j];2540 if (i == EXC_DIRS)2541 free((char *)el->src);2542 clear_exclude_list(el);2543 }2544 free(group->el);2545 }25462547 stk = dir->exclude_stack;2548 while (stk) {2549 struct exclude_stack *prev = stk->prev;2550 free(stk);2551 stk = prev;2552 }2553 strbuf_release(&dir->basebuf);2554}25552556struct ondisk_untracked_cache {2557 struct stat_data info_exclude_stat;2558 struct stat_data excludes_file_stat;2559 uint32_t dir_flags;2560};25612562#define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)25632564struct write_data {2565 int index; /* number of written untracked_cache_dir */2566 struct ewah_bitmap *check_only; /* from untracked_cache_dir */2567 struct ewah_bitmap *valid; /* from untracked_cache_dir */2568 struct ewah_bitmap *sha1_valid; /* set if exclude_sha1 is not null */2569 struct strbuf out;2570 struct strbuf sb_stat;2571 struct strbuf sb_sha1;2572};25732574static void stat_data_to_disk(struct stat_data *to, const struct stat_data *from)2575{2576 to->sd_ctime.sec = htonl(from->sd_ctime.sec);2577 to->sd_ctime.nsec = htonl(from->sd_ctime.nsec);2578 to->sd_mtime.sec = htonl(from->sd_mtime.sec);2579 to->sd_mtime.nsec = htonl(from->sd_mtime.nsec);2580 to->sd_dev = htonl(from->sd_dev);2581 to->sd_ino = htonl(from->sd_ino);2582 to->sd_uid = htonl(from->sd_uid);2583 to->sd_gid = htonl(from->sd_gid);2584 to->sd_size = htonl(from->sd_size);2585}25862587static void write_one_dir(struct untracked_cache_dir *untracked,2588 struct write_data *wd)2589{2590 struct stat_data stat_data;2591 struct strbuf *out = &wd->out;2592 unsigned char intbuf[16];2593 unsigned int intlen, value;2594 int i = wd->index++;25952596 /*2597 * untracked_nr should be reset whenever valid is clear, but2598 * for safety..2599 */2600 if (!untracked->valid) {2601 untracked->untracked_nr = 0;2602 untracked->check_only = 0;2603 }26042605 if (untracked->check_only)2606 ewah_set(wd->check_only, i);2607 if (untracked->valid) {2608 ewah_set(wd->valid, i);2609 stat_data_to_disk(&stat_data, &untracked->stat_data);2610 strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data));2611 }2612 if (!is_null_oid(&untracked->exclude_oid)) {2613 ewah_set(wd->sha1_valid, i);2614 strbuf_add(&wd->sb_sha1, untracked->exclude_oid.hash,2615 the_hash_algo->rawsz);2616 }26172618 intlen = encode_varint(untracked->untracked_nr, intbuf);2619 strbuf_add(out, intbuf, intlen);26202621 /* skip non-recurse directories */2622 for (i = 0, value = 0; i < untracked->dirs_nr; i++)2623 if (untracked->dirs[i]->recurse)2624 value++;2625 intlen = encode_varint(value, intbuf);2626 strbuf_add(out, intbuf, intlen);26272628 strbuf_add(out, untracked->name, strlen(untracked->name) + 1);26292630 for (i = 0; i < untracked->untracked_nr; i++)2631 strbuf_add(out, untracked->untracked[i],2632 strlen(untracked->untracked[i]) + 1);26332634 for (i = 0; i < untracked->dirs_nr; i++)2635 if (untracked->dirs[i]->recurse)2636 write_one_dir(untracked->dirs[i], wd);2637}26382639void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked)2640{2641 struct ondisk_untracked_cache *ouc;2642 struct write_data wd;2643 unsigned char varbuf[16];2644 int varint_len;2645 const unsigned hashsz = the_hash_algo->rawsz;26462647 ouc = xcalloc(1, sizeof(*ouc));2648 stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2649 stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2650 ouc->dir_flags = htonl(untracked->dir_flags);26512652 varint_len = encode_varint(untracked->ident.len, varbuf);2653 strbuf_add(out, varbuf, varint_len);2654 strbuf_addbuf(out, &untracked->ident);26552656 strbuf_add(out, ouc, sizeof(*ouc));2657 strbuf_add(out, untracked->ss_info_exclude.oid.hash, hashsz);2658 strbuf_add(out, untracked->ss_excludes_file.oid.hash, hashsz);2659 strbuf_add(out, untracked->exclude_per_dir, strlen(untracked->exclude_per_dir) + 1);2660 FREE_AND_NULL(ouc);26612662 if (!untracked->root) {2663 varint_len = encode_varint(0, varbuf);2664 strbuf_add(out, varbuf, varint_len);2665 return;2666 }26672668 wd.index = 0;2669 wd.check_only = ewah_new();2670 wd.valid = ewah_new();2671 wd.sha1_valid = ewah_new();2672 strbuf_init(&wd.out, 1024);2673 strbuf_init(&wd.sb_stat, 1024);2674 strbuf_init(&wd.sb_sha1, 1024);2675 write_one_dir(untracked->root, &wd);26762677 varint_len = encode_varint(wd.index, varbuf);2678 strbuf_add(out, varbuf, varint_len);2679 strbuf_addbuf(out, &wd.out);2680 ewah_serialize_strbuf(wd.valid, out);2681 ewah_serialize_strbuf(wd.check_only, out);2682 ewah_serialize_strbuf(wd.sha1_valid, out);2683 strbuf_addbuf(out, &wd.sb_stat);2684 strbuf_addbuf(out, &wd.sb_sha1);2685 strbuf_addch(out, '\0'); /* safe guard for string lists */26862687 ewah_free(wd.valid);2688 ewah_free(wd.check_only);2689 ewah_free(wd.sha1_valid);2690 strbuf_release(&wd.out);2691 strbuf_release(&wd.sb_stat);2692 strbuf_release(&wd.sb_sha1);2693}26942695static void free_untracked(struct untracked_cache_dir *ucd)2696{2697 int i;2698 if (!ucd)2699 return;2700 for (i = 0; i < ucd->dirs_nr; i++)2701 free_untracked(ucd->dirs[i]);2702 for (i = 0; i < ucd->untracked_nr; i++)2703 free(ucd->untracked[i]);2704 free(ucd->untracked);2705 free(ucd->dirs);2706 free(ucd);2707}27082709void free_untracked_cache(struct untracked_cache *uc)2710{2711 if (uc)2712 free_untracked(uc->root);2713 free(uc);2714}27152716struct read_data {2717 int index;2718 struct untracked_cache_dir **ucd;2719 struct ewah_bitmap *check_only;2720 struct ewah_bitmap *valid;2721 struct ewah_bitmap *sha1_valid;2722 const unsigned char *data;2723 const unsigned char *end;2724};27252726static void stat_data_from_disk(struct stat_data *to, const unsigned char *data)2727{2728 memcpy(to, data, sizeof(*to));2729 to->sd_ctime.sec = ntohl(to->sd_ctime.sec);2730 to->sd_ctime.nsec = ntohl(to->sd_ctime.nsec);2731 to->sd_mtime.sec = ntohl(to->sd_mtime.sec);2732 to->sd_mtime.nsec = ntohl(to->sd_mtime.nsec);2733 to->sd_dev = ntohl(to->sd_dev);2734 to->sd_ino = ntohl(to->sd_ino);2735 to->sd_uid = ntohl(to->sd_uid);2736 to->sd_gid = ntohl(to->sd_gid);2737 to->sd_size = ntohl(to->sd_size);2738}27392740static int read_one_dir(struct untracked_cache_dir **untracked_,2741 struct read_data *rd)2742{2743 struct untracked_cache_dir ud, *untracked;2744 const unsigned char *data = rd->data, *end = rd->end;2745 const unsigned char *eos;2746 unsigned int value;2747 int i;27482749 memset(&ud, 0, sizeof(ud));27502751 value = decode_varint(&data);2752 if (data > end)2753 return -1;2754 ud.recurse = 1;2755 ud.untracked_alloc = value;2756 ud.untracked_nr = value;2757 if (ud.untracked_nr)2758 ALLOC_ARRAY(ud.untracked, ud.untracked_nr);27592760 ud.dirs_alloc = ud.dirs_nr = decode_varint(&data);2761 if (data > end)2762 return -1;2763 ALLOC_ARRAY(ud.dirs, ud.dirs_nr);27642765 eos = memchr(data, '\0', end - data);2766 if (!eos || eos == end)2767 return -1;27682769 *untracked_ = untracked = xmalloc(st_add3(sizeof(*untracked), eos - data, 1));2770 memcpy(untracked, &ud, sizeof(ud));2771 memcpy(untracked->name, data, eos - data + 1);2772 data = eos + 1;27732774 for (i = 0; i < untracked->untracked_nr; i++) {2775 eos = memchr(data, '\0', end - data);2776 if (!eos || eos == end)2777 return -1;2778 untracked->untracked[i] = xmemdupz(data, eos - data);2779 data = eos + 1;2780 }27812782 rd->ucd[rd->index++] = untracked;2783 rd->data = data;27842785 for (i = 0; i < untracked->dirs_nr; i++) {2786 if (read_one_dir(untracked->dirs + i, rd) < 0)2787 return -1;2788 }2789 return 0;2790}27912792static void set_check_only(size_t pos, void *cb)2793{2794 struct read_data *rd = cb;2795 struct untracked_cache_dir *ud = rd->ucd[pos];2796 ud->check_only = 1;2797}27982799static void read_stat(size_t pos, void *cb)2800{2801 struct read_data *rd = cb;2802 struct untracked_cache_dir *ud = rd->ucd[pos];2803 if (rd->data + sizeof(struct stat_data) > rd->end) {2804 rd->data = rd->end + 1;2805 return;2806 }2807 stat_data_from_disk(&ud->stat_data, rd->data);2808 rd->data += sizeof(struct stat_data);2809 ud->valid = 1;2810}28112812static void read_oid(size_t pos, void *cb)2813{2814 struct read_data *rd = cb;2815 struct untracked_cache_dir *ud = rd->ucd[pos];2816 if (rd->data + the_hash_algo->rawsz > rd->end) {2817 rd->data = rd->end + 1;2818 return;2819 }2820 hashcpy(ud->exclude_oid.hash, rd->data);2821 rd->data += the_hash_algo->rawsz;2822}28232824static void load_oid_stat(struct oid_stat *oid_stat, const unsigned char *data,2825 const unsigned char *sha1)2826{2827 stat_data_from_disk(&oid_stat->stat, data);2828 hashcpy(oid_stat->oid.hash, sha1);2829 oid_stat->valid = 1;2830}28312832struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz)2833{2834 struct untracked_cache *uc;2835 struct read_data rd;2836 const unsigned char *next = data, *end = (const unsigned char *)data + sz;2837 const char *ident;2838 int ident_len;2839 ssize_t len;2840 const char *exclude_per_dir;2841 const unsigned hashsz = the_hash_algo->rawsz;2842 const unsigned offset = sizeof(struct ondisk_untracked_cache);2843 const unsigned exclude_per_dir_offset = offset + 2 * hashsz;28442845 if (sz <= 1 || end[-1] != '\0')2846 return NULL;2847 end--;28482849 ident_len = decode_varint(&next);2850 if (next + ident_len > end)2851 return NULL;2852 ident = (const char *)next;2853 next += ident_len;28542855 if (next + exclude_per_dir_offset + 1 > end)2856 return NULL;28572858 uc = xcalloc(1, sizeof(*uc));2859 strbuf_init(&uc->ident, ident_len);2860 strbuf_add(&uc->ident, ident, ident_len);2861 load_oid_stat(&uc->ss_info_exclude,2862 next + ouc_offset(info_exclude_stat),2863 next + offset);2864 load_oid_stat(&uc->ss_excludes_file,2865 next + ouc_offset(excludes_file_stat),2866 next + offset + hashsz);2867 uc->dir_flags = get_be32(next + ouc_offset(dir_flags));2868 exclude_per_dir = (const char *)next + exclude_per_dir_offset;2869 uc->exclude_per_dir = xstrdup(exclude_per_dir);2870 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */2871 next += exclude_per_dir_offset + strlen(exclude_per_dir) + 1;2872 if (next >= end)2873 goto done2;28742875 len = decode_varint(&next);2876 if (next > end || len == 0)2877 goto done2;28782879 rd.valid = ewah_new();2880 rd.check_only = ewah_new();2881 rd.sha1_valid = ewah_new();2882 rd.data = next;2883 rd.end = end;2884 rd.index = 0;2885 ALLOC_ARRAY(rd.ucd, len);28862887 if (read_one_dir(&uc->root, &rd) || rd.index != len)2888 goto done;28892890 next = rd.data;2891 len = ewah_read_mmap(rd.valid, next, end - next);2892 if (len < 0)2893 goto done;28942895 next += len;2896 len = ewah_read_mmap(rd.check_only, next, end - next);2897 if (len < 0)2898 goto done;28992900 next += len;2901 len = ewah_read_mmap(rd.sha1_valid, next, end - next);2902 if (len < 0)2903 goto done;29042905 ewah_each_bit(rd.check_only, set_check_only, &rd);2906 rd.data = next + len;2907 ewah_each_bit(rd.valid, read_stat, &rd);2908 ewah_each_bit(rd.sha1_valid, read_oid, &rd);2909 next = rd.data;29102911done:2912 free(rd.ucd);2913 ewah_free(rd.valid);2914 ewah_free(rd.check_only);2915 ewah_free(rd.sha1_valid);2916done2:2917 if (next != end) {2918 free_untracked_cache(uc);2919 uc = NULL;2920 }2921 return uc;2922}29232924static void invalidate_one_directory(struct untracked_cache *uc,2925 struct untracked_cache_dir *ucd)2926{2927 uc->dir_invalidated++;2928 ucd->valid = 0;2929 ucd->untracked_nr = 0;2930}29312932/*2933 * Normally when an entry is added or removed from a directory,2934 * invalidating that directory is enough. No need to touch its2935 * ancestors. When a directory is shown as "foo/bar/" in git-status2936 * however, deleting or adding an entry may have cascading effect.2937 *2938 * Say the "foo/bar/file" has become untracked, we need to tell the2939 * untracked_cache_dir of "foo" that "bar/" is not an untracked2940 * directory any more (because "bar" is managed by foo as an untracked2941 * "file").2942 *2943 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2944 * was the last untracked entry in the entire "foo", we should show2945 * "foo/" instead. Which means we have to invalidate past "bar" up to2946 * "foo".2947 *2948 * This function traverses all directories from root to leaf. If there2949 * is a chance of one of the above cases happening, we invalidate back2950 * to root. Otherwise we just invalidate the leaf. There may be a more2951 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2952 * detect these cases and avoid unnecessary invalidation, for example,2953 * checking for the untracked entry named "bar/" in "foo", but for now2954 * stick to something safe and simple.2955 */2956static int invalidate_one_component(struct untracked_cache *uc,2957 struct untracked_cache_dir *dir,2958 const char *path, int len)2959{2960 const char *rest = strchr(path, '/');29612962 if (rest) {2963 int component_len = rest - path;2964 struct untracked_cache_dir *d =2965 lookup_untracked(uc, dir, path, component_len);2966 int ret =2967 invalidate_one_component(uc, d, rest + 1,2968 len - (component_len + 1));2969 if (ret)2970 invalidate_one_directory(uc, dir);2971 return ret;2972 }29732974 invalidate_one_directory(uc, dir);2975 return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2976}29772978void untracked_cache_invalidate_path(struct index_state *istate,2979 const char *path, int safe_path)2980{2981 if (!istate->untracked || !istate->untracked->root)2982 return;2983 if (!safe_path && !verify_path(path, 0))2984 return;2985 invalidate_one_component(istate->untracked, istate->untracked->root,2986 path, strlen(path));2987}29882989void untracked_cache_remove_from_index(struct index_state *istate,2990 const char *path)2991{2992 untracked_cache_invalidate_path(istate, path, 1);2993}29942995void untracked_cache_add_to_index(struct index_state *istate,2996 const char *path)2997{2998 untracked_cache_invalidate_path(istate, path, 1);2999}30003001static void connect_wt_gitdir_in_nested(const char *sub_worktree,3002 const char *sub_gitdir)3003{3004 int i;3005 struct repository subrepo;3006 struct strbuf sub_wt = STRBUF_INIT;3007 struct strbuf sub_gd = STRBUF_INIT;30083009 const struct submodule *sub;30103011 /* If the submodule has no working tree, we can ignore it. */3012 if (repo_init(&subrepo, sub_gitdir, sub_worktree))3013 return;30143015 if (repo_read_index(&subrepo) < 0)3016 die(_("index file corrupt in repo %s"), subrepo.gitdir);30173018 for (i = 0; i < subrepo.index->cache_nr; i++) {3019 const struct cache_entry *ce = subrepo.index->cache[i];30203021 if (!S_ISGITLINK(ce->ce_mode))3022 continue;30233024 while (i + 1 < subrepo.index->cache_nr &&3025 !strcmp(ce->name, subrepo.index->cache[i + 1]->name))3026 /*3027 * Skip entries with the same name in different stages3028 * to make sure an entry is returned only once.3029 */3030 i++;30313032 sub = submodule_from_path(&subrepo, &null_oid, ce->name);3033 if (!sub || !is_submodule_active(&subrepo, ce->name))3034 /* .gitmodules broken or inactive sub */3035 continue;30363037 strbuf_reset(&sub_wt);3038 strbuf_reset(&sub_gd);3039 strbuf_addf(&sub_wt, "%s/%s", sub_worktree, sub->path);3040 strbuf_addf(&sub_gd, "%s/modules/%s", sub_gitdir, sub->name);30413042 connect_work_tree_and_git_dir(sub_wt.buf, sub_gd.buf, 1);3043 }3044 strbuf_release(&sub_wt);3045 strbuf_release(&sub_gd);3046 repo_clear(&subrepo);3047}30483049void connect_work_tree_and_git_dir(const char *work_tree_,3050 const char *git_dir_,3051 int recurse_into_nested)3052{3053 struct strbuf gitfile_sb = STRBUF_INIT;3054 struct strbuf cfg_sb = STRBUF_INIT;3055 struct strbuf rel_path = STRBUF_INIT;3056 char *git_dir, *work_tree;30573058 /* Prepare .git file */3059 strbuf_addf(&gitfile_sb, "%s/.git", work_tree_);3060 if (safe_create_leading_directories_const(gitfile_sb.buf))3061 die(_("could not create directories for %s"), gitfile_sb.buf);30623063 /* Prepare config file */3064 strbuf_addf(&cfg_sb, "%s/config", git_dir_);3065 if (safe_create_leading_directories_const(cfg_sb.buf))3066 die(_("could not create directories for %s"), cfg_sb.buf);30673068 git_dir = real_pathdup(git_dir_, 1);3069 work_tree = real_pathdup(work_tree_, 1);30703071 /* Write .git file */3072 write_file(gitfile_sb.buf, "gitdir: %s",3073 relative_path(git_dir, work_tree, &rel_path));3074 /* Update core.worktree setting */3075 git_config_set_in_file(cfg_sb.buf, "core.worktree",3076 relative_path(work_tree, git_dir, &rel_path));30773078 strbuf_release(&gitfile_sb);3079 strbuf_release(&cfg_sb);3080 strbuf_release(&rel_path);30813082 if (recurse_into_nested)3083 connect_wt_gitdir_in_nested(work_tree, git_dir);30843085 free(work_tree);3086 free(git_dir);3087}30883089/*3090 * Migrate the git directory of the given path from old_git_dir to new_git_dir.3091 */3092void relocate_gitdir(const char *path, const char *old_git_dir, const char *new_git_dir)3093{3094 if (rename(old_git_dir, new_git_dir) < 0)3095 die_errno(_("could not migrate git directory from '%s' to '%s'"),3096 old_git_dir, new_git_dir);30973098 connect_work_tree_and_git_dir(path, new_git_dir, 0);3099}