1/* 2 * This handles recursive filename detection with exclude 3 * files, index knowledge etc.. 4 * 5 * See Documentation/technical/api-directory-listing.txt 6 * 7 * Copyright (C) Linus Torvalds, 2005-2006 8 * Junio Hamano, 2005-2006 9 */ 10#define NO_THE_INDEX_COMPATIBILITY_MACROS 11#include "cache.h" 12#include "config.h" 13#include "dir.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 23/* 24 * Tells read_directory_recursive how a file or directory should be treated. 25 * Values are ordered by significance, e.g. if a directory contains both 26 * excluded and untracked files, it is listed as untracked because 27 * path_untracked > path_excluded. 28 */ 29enum path_treatment { 30 path_none = 0, 31 path_recurse, 32 path_excluded, 33 path_untracked 34}; 35 36/* 37 * Support data structure for our opendir/readdir/closedir wrappers 38 */ 39struct cached_dir { 40 DIR *fdir; 41 struct untracked_cache_dir *untracked; 42 int nr_files; 43 int nr_dirs; 44 45 struct dirent *de; 46 const char *file; 47 struct untracked_cache_dir *ucd; 48}; 49 50static enum path_treatment read_directory_recursive(struct dir_struct *dir, 51 struct index_state *istate, const char *path, int len, 52 struct untracked_cache_dir *untracked, 53 int check_only, int stop_at_first_file, const struct pathspec *pathspec); 54static int get_dtype(struct dirent *de, struct index_state *istate, 55 const char *path, int len); 56 57int count_slashes(const char *s) 58{ 59 int cnt = 0; 60 while (*s) 61 if (*s++ == '/') 62 cnt++; 63 return cnt; 64} 65 66int fspathcmp(const char *a, const char *b) 67{ 68 return ignore_case ? strcasecmp(a, b) : strcmp(a, b); 69} 70 71int fspathncmp(const char *a, const char *b, size_t count) 72{ 73 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count); 74} 75 76int git_fnmatch(const struct pathspec_item *item, 77 const char *pattern, const char *string, 78 int prefix) 79{ 80 if (prefix > 0) { 81 if (ps_strncmp(item, pattern, string, prefix)) 82 return WM_NOMATCH; 83 pattern += prefix; 84 string += prefix; 85 } 86 if (item->flags & PATHSPEC_ONESTAR) { 87 int pattern_len = strlen(++pattern); 88 int string_len = strlen(string); 89 return string_len < pattern_len || 90 ps_strcmp(item, pattern, 91 string + string_len - pattern_len); 92 } 93 if (item->magic & PATHSPEC_GLOB) 94 return wildmatch(pattern, string, 95 WM_PATHNAME | 96 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0)); 97 else 98 /* wildmatch has not learned no FNM_PATHNAME mode yet */ 99 return wildmatch(pattern, string, 100 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0); 101} 102 103static int fnmatch_icase_mem(const char *pattern, int patternlen, 104 const char *string, int stringlen, 105 int flags) 106{ 107 int match_status; 108 struct strbuf pat_buf = STRBUF_INIT; 109 struct strbuf str_buf = STRBUF_INIT; 110 const char *use_pat = pattern; 111 const char *use_str = string; 112 113 if (pattern[patternlen]) { 114 strbuf_add(&pat_buf, pattern, patternlen); 115 use_pat = pat_buf.buf; 116 } 117 if (string[stringlen]) { 118 strbuf_add(&str_buf, string, stringlen); 119 use_str = str_buf.buf; 120 } 121 122 if (ignore_case) 123 flags |= WM_CASEFOLD; 124 match_status = wildmatch(use_pat, use_str, flags); 125 126 strbuf_release(&pat_buf); 127 strbuf_release(&str_buf); 128 129 return match_status; 130} 131 132static size_t common_prefix_len(const struct pathspec *pathspec) 133{ 134 int n; 135 size_t max = 0; 136 137 /* 138 * ":(icase)path" is treated as a pathspec full of 139 * wildcard. In other words, only prefix is considered common 140 * prefix. If the pathspec is abc/foo abc/bar, running in 141 * subdir xyz, the common prefix is still xyz, not xuz/abc as 142 * in non-:(icase). 143 */ 144 GUARD_PATHSPEC(pathspec, 145 PATHSPEC_FROMTOP | 146 PATHSPEC_MAXDEPTH | 147 PATHSPEC_LITERAL | 148 PATHSPEC_GLOB | 149 PATHSPEC_ICASE | 150 PATHSPEC_EXCLUDE | 151 PATHSPEC_ATTR); 152 153 for (n = 0; n < pathspec->nr; n++) { 154 size_t i = 0, len = 0, item_len; 155 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE) 156 continue; 157 if (pathspec->items[n].magic & PATHSPEC_ICASE) 158 item_len = pathspec->items[n].prefix; 159 else 160 item_len = pathspec->items[n].nowildcard_len; 161 while (i < item_len && (n == 0 || i < max)) { 162 char c = pathspec->items[n].match[i]; 163 if (c != pathspec->items[0].match[i]) 164 break; 165 if (c == '/') 166 len = i + 1; 167 i++; 168 } 169 if (n == 0 || len < max) { 170 max = len; 171 if (!max) 172 break; 173 } 174 } 175 return max; 176} 177 178/* 179 * Returns a copy of the longest leading path common among all 180 * pathspecs. 181 */ 182char *common_prefix(const struct pathspec *pathspec) 183{ 184 unsigned long len = common_prefix_len(pathspec); 185 186 return len ? xmemdupz(pathspec->items[0].match, len) : NULL; 187} 188 189int fill_directory(struct dir_struct *dir, 190 struct index_state *istate, 191 const struct pathspec *pathspec) 192{ 193 const char *prefix; 194 size_t prefix_len; 195 196 /* 197 * Calculate common prefix for the pathspec, and 198 * use that to optimize the directory walk 199 */ 200 prefix_len = common_prefix_len(pathspec); 201 prefix = prefix_len ? pathspec->items[0].match : ""; 202 203 /* Read the directory and prune it */ 204 read_directory(dir, istate, prefix, prefix_len, pathspec); 205 206 return prefix_len; 207} 208 209int within_depth(const char *name, int namelen, 210 int depth, int max_depth) 211{ 212 const char *cp = name, *cpe = name + namelen; 213 214 while (cp < cpe) { 215 if (*cp++ != '/') 216 continue; 217 depth++; 218 if (depth > max_depth) 219 return 0; 220 } 221 return 1; 222} 223 224/* 225 * Read the contents of the blob with the given OID into a buffer. 226 * Append a trailing LF to the end if the last line doesn't have one. 227 * 228 * Returns: 229 * -1 when the OID is invalid or unknown or does not refer to a blob. 230 * 0 when the blob is empty. 231 * 1 along with { data, size } of the (possibly augmented) buffer 232 * when successful. 233 * 234 * Optionally updates the given oid_stat with the given OID (when valid). 235 */ 236static int do_read_blob(const struct object_id *oid, struct oid_stat *oid_stat, 237 size_t *size_out, char **data_out) 238{ 239 enum object_type type; 240 unsigned long sz; 241 char *data; 242 243 *size_out = 0; 244 *data_out = NULL; 245 246 data = read_object_file(oid, &type, &sz); 247 if (!data || type != OBJ_BLOB) { 248 free(data); 249 return -1; 250 } 251 252 if (oid_stat) { 253 memset(&oid_stat->stat, 0, sizeof(oid_stat->stat)); 254 oidcpy(&oid_stat->oid, oid); 255 } 256 257 if (sz == 0) { 258 free(data); 259 return 0; 260 } 261 262 if (data[sz - 1] != '\n') { 263 data = xrealloc(data, st_add(sz, 1)); 264 data[sz++] = '\n'; 265 } 266 267 *size_out = xsize_t(sz); 268 *data_out = data; 269 270 return 1; 271} 272 273#define DO_MATCH_EXCLUDE (1<<0) 274#define DO_MATCH_DIRECTORY (1<<1) 275#define DO_MATCH_SUBMODULE (1<<2) 276 277static int match_attrs(const char *name, int namelen, 278 const struct pathspec_item *item) 279{ 280 int i; 281 282 git_check_attr(name, item->attr_check); 283 for (i = 0; i < item->attr_match_nr; i++) { 284 const char *value; 285 int matched; 286 enum attr_match_mode match_mode; 287 288 value = item->attr_check->items[i].value; 289 match_mode = item->attr_match[i].match_mode; 290 291 if (ATTR_TRUE(value)) 292 matched = (match_mode == MATCH_SET); 293 else if (ATTR_FALSE(value)) 294 matched = (match_mode == MATCH_UNSET); 295 else if (ATTR_UNSET(value)) 296 matched = (match_mode == MATCH_UNSPECIFIED); 297 else 298 matched = (match_mode == MATCH_VALUE && 299 !strcmp(item->attr_match[i].value, value)); 300 if (!matched) 301 return 0; 302 } 303 304 return 1; 305} 306 307/* 308 * Does 'match' match the given name? 309 * A match is found if 310 * 311 * (1) the 'match' string is leading directory of 'name', or 312 * (2) the 'match' string is a wildcard and matches 'name', or 313 * (3) the 'match' string is exactly the same as 'name'. 314 * 315 * and the return value tells which case it was. 316 * 317 * It returns 0 when there is no match. 318 */ 319static int match_pathspec_item(const struct pathspec_item *item, int prefix, 320 const char *name, int namelen, unsigned flags) 321{ 322 /* name/namelen has prefix cut off by caller */ 323 const char *match = item->match + prefix; 324 int matchlen = item->len - prefix; 325 326 /* 327 * The normal call pattern is: 328 * 1. prefix = common_prefix_len(ps); 329 * 2. prune something, or fill_directory 330 * 3. match_pathspec() 331 * 332 * 'prefix' at #1 may be shorter than the command's prefix and 333 * it's ok for #2 to match extra files. Those extras will be 334 * trimmed at #3. 335 * 336 * Suppose the pathspec is 'foo' and '../bar' running from 337 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 338 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 339 * user does not want XYZ/foo, only the "foo" part should be 340 * case-insensitive. We need to filter out XYZ/foo here. In 341 * other words, we do not trust the caller on comparing the 342 * prefix part when :(icase) is involved. We do exact 343 * comparison ourselves. 344 * 345 * Normally the caller (common_prefix_len() in fact) does 346 * _exact_ matching on name[-prefix+1..-1] and we do not need 347 * to check that part. Be defensive and check it anyway, in 348 * case common_prefix_len is changed, or a new caller is 349 * introduced that does not use common_prefix_len. 350 * 351 * If the penalty turns out too high when prefix is really 352 * long, maybe change it to 353 * strncmp(match, name, item->prefix - prefix) 354 */ 355 if (item->prefix && (item->magic & PATHSPEC_ICASE) && 356 strncmp(item->match, name - prefix, item->prefix)) 357 return 0; 358 359 if (item->attr_match_nr && !match_attrs(name, namelen, item)) 360 return 0; 361 362 /* If the match was just the prefix, we matched */ 363 if (!*match) 364 return MATCHED_RECURSIVELY; 365 366 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 367 if (matchlen == namelen) 368 return MATCHED_EXACTLY; 369 370 if (match[matchlen-1] == '/' || name[matchlen] == '/') 371 return MATCHED_RECURSIVELY; 372 } else if ((flags & DO_MATCH_DIRECTORY) && 373 match[matchlen - 1] == '/' && 374 namelen == matchlen - 1 && 375 !ps_strncmp(item, match, name, namelen)) 376 return MATCHED_EXACTLY; 377 378 if (item->nowildcard_len < item->len && 379 !git_fnmatch(item, match, name, 380 item->nowildcard_len - prefix)) 381 return MATCHED_FNMATCH; 382 383 /* Perform checks to see if "name" is a super set of the pathspec */ 384 if (flags & DO_MATCH_SUBMODULE) { 385 /* name is a literal prefix of the pathspec */ 386 if ((namelen < matchlen) && 387 (match[namelen] == '/') && 388 !ps_strncmp(item, match, name, namelen)) 389 return MATCHED_RECURSIVELY; 390 391 /* name" doesn't match up to the first wild character */ 392 if (item->nowildcard_len < item->len && 393 ps_strncmp(item, match, name, 394 item->nowildcard_len - prefix)) 395 return 0; 396 397 /* 398 * Here is where we would perform a wildmatch to check if 399 * "name" can be matched as a directory (or a prefix) against 400 * the pathspec. Since wildmatch doesn't have this capability 401 * at the present we have to punt and say that it is a match, 402 * potentially returning a false positive 403 * The submodules themselves will be able to perform more 404 * accurate matching to determine if the pathspec matches. 405 */ 406 return MATCHED_RECURSIVELY; 407 } 408 409 return 0; 410} 411 412/* 413 * Given a name and a list of pathspecs, returns the nature of the 414 * closest (i.e. most specific) match of the name to any of the 415 * pathspecs. 416 * 417 * The caller typically calls this multiple times with the same 418 * pathspec and seen[] array but with different name/namelen 419 * (e.g. entries from the index) and is interested in seeing if and 420 * how each pathspec matches all the names it calls this function 421 * with. A mark is left in the seen[] array for each pathspec element 422 * indicating the closest type of match that element achieved, so if 423 * seen[n] remains zero after multiple invocations, that means the nth 424 * pathspec did not match any names, which could indicate that the 425 * user mistyped the nth pathspec. 426 */ 427static int do_match_pathspec(const struct pathspec *ps, 428 const char *name, int namelen, 429 int prefix, char *seen, 430 unsigned flags) 431{ 432 int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE; 433 434 GUARD_PATHSPEC(ps, 435 PATHSPEC_FROMTOP | 436 PATHSPEC_MAXDEPTH | 437 PATHSPEC_LITERAL | 438 PATHSPEC_GLOB | 439 PATHSPEC_ICASE | 440 PATHSPEC_EXCLUDE | 441 PATHSPEC_ATTR); 442 443 if (!ps->nr) { 444 if (!ps->recursive || 445 !(ps->magic & PATHSPEC_MAXDEPTH) || 446 ps->max_depth == -1) 447 return MATCHED_RECURSIVELY; 448 449 if (within_depth(name, namelen, 0, ps->max_depth)) 450 return MATCHED_EXACTLY; 451 else 452 return 0; 453 } 454 455 name += prefix; 456 namelen -= prefix; 457 458 for (i = ps->nr - 1; i >= 0; i--) { 459 int how; 460 461 if ((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 462 ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 463 continue; 464 465 if (seen && seen[i] == MATCHED_EXACTLY) 466 continue; 467 /* 468 * Make exclude patterns optional and never report 469 * "pathspec ':(exclude)foo' matches no files" 470 */ 471 if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 472 seen[i] = MATCHED_FNMATCH; 473 how = match_pathspec_item(ps->items+i, prefix, name, 474 namelen, flags); 475 if (ps->recursive && 476 (ps->magic & PATHSPEC_MAXDEPTH) && 477 ps->max_depth != -1 && 478 how && how != MATCHED_FNMATCH) { 479 int len = ps->items[i].len; 480 if (name[len] == '/') 481 len++; 482 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 483 how = MATCHED_EXACTLY; 484 else 485 how = 0; 486 } 487 if (how) { 488 if (retval < how) 489 retval = how; 490 if (seen && seen[i] < how) 491 seen[i] = how; 492 } 493 } 494 return retval; 495} 496 497int match_pathspec(const struct pathspec *ps, 498 const char *name, int namelen, 499 int prefix, char *seen, int is_dir) 500{ 501 int positive, negative; 502 unsigned flags = is_dir ? DO_MATCH_DIRECTORY : 0; 503 positive = do_match_pathspec(ps, name, namelen, 504 prefix, seen, flags); 505 if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 506 return positive; 507 negative = do_match_pathspec(ps, name, namelen, 508 prefix, seen, 509 flags | DO_MATCH_EXCLUDE); 510 return negative ? 0 : positive; 511} 512 513/** 514 * Check if a submodule is a superset of the pathspec 515 */ 516int submodule_path_match(const struct pathspec *ps, 517 const char *submodule_name, 518 char *seen) 519{ 520 int matched = do_match_pathspec(ps, submodule_name, 521 strlen(submodule_name), 522 0, seen, 523 DO_MATCH_DIRECTORY | 524 DO_MATCH_SUBMODULE); 525 return matched; 526} 527 528int report_path_error(const char *ps_matched, 529 const struct pathspec *pathspec, 530 const char *prefix) 531{ 532 /* 533 * Make sure all pathspec matched; otherwise it is an error. 534 */ 535 int num, errors = 0; 536 for (num = 0; num < pathspec->nr; num++) { 537 int other, found_dup; 538 539 if (ps_matched[num]) 540 continue; 541 /* 542 * The caller might have fed identical pathspec 543 * twice. Do not barf on such a mistake. 544 * FIXME: parse_pathspec should have eliminated 545 * duplicate pathspec. 546 */ 547 for (found_dup = other = 0; 548 !found_dup && other < pathspec->nr; 549 other++) { 550 if (other == num || !ps_matched[other]) 551 continue; 552 if (!strcmp(pathspec->items[other].original, 553 pathspec->items[num].original)) 554 /* 555 * Ok, we have a match already. 556 */ 557 found_dup = 1; 558 } 559 if (found_dup) 560 continue; 561 562 error("pathspec '%s' did not match any file(s) known to git.", 563 pathspec->items[num].original); 564 errors++; 565 } 566 return errors; 567} 568 569/* 570 * Return the length of the "simple" part of a path match limiter. 571 */ 572int simple_length(const char *match) 573{ 574 int len = -1; 575 576 for (;;) { 577 unsigned char c = *match++; 578 len++; 579 if (c == '\0' || is_glob_special(c)) 580 return len; 581 } 582} 583 584int no_wildcard(const char *string) 585{ 586 return string[simple_length(string)] == '\0'; 587} 588 589void parse_exclude_pattern(const char **pattern, 590 int *patternlen, 591 unsigned *flags, 592 int *nowildcardlen) 593{ 594 const char *p = *pattern; 595 size_t i, len; 596 597 *flags = 0; 598 if (*p == '!') { 599 *flags |= EXC_FLAG_NEGATIVE; 600 p++; 601 } 602 len = strlen(p); 603 if (len && p[len - 1] == '/') { 604 len--; 605 *flags |= EXC_FLAG_MUSTBEDIR; 606 } 607 for (i = 0; i < len; i++) { 608 if (p[i] == '/') 609 break; 610 } 611 if (i == len) 612 *flags |= EXC_FLAG_NODIR; 613 *nowildcardlen = simple_length(p); 614 /* 615 * we should have excluded the trailing slash from 'p' too, 616 * but that's one more allocation. Instead just make sure 617 * nowildcardlen does not exceed real patternlen 618 */ 619 if (*nowildcardlen > len) 620 *nowildcardlen = len; 621 if (*p == '*' && no_wildcard(p + 1)) 622 *flags |= EXC_FLAG_ENDSWITH; 623 *pattern = p; 624 *patternlen = len; 625} 626 627void add_exclude(const char *string, const char *base, 628 int baselen, struct exclude_list *el, int srcpos) 629{ 630 struct exclude *x; 631 int patternlen; 632 unsigned flags; 633 int nowildcardlen; 634 635 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 636 if (flags & EXC_FLAG_MUSTBEDIR) { 637 FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); 638 } else { 639 x = xmalloc(sizeof(*x)); 640 x->pattern = string; 641 } 642 x->patternlen = patternlen; 643 x->nowildcardlen = nowildcardlen; 644 x->base = base; 645 x->baselen = baselen; 646 x->flags = flags; 647 x->srcpos = srcpos; 648 ALLOC_GROW(el->excludes, el->nr + 1, el->alloc); 649 el->excludes[el->nr++] = x; 650 x->el = el; 651} 652 653static int read_skip_worktree_file_from_index(const struct index_state *istate, 654 const char *path, 655 size_t *size_out, char **data_out, 656 struct oid_stat *oid_stat) 657{ 658 int pos, len; 659 660 len = strlen(path); 661 pos = index_name_pos(istate, path, len); 662 if (pos < 0) 663 return -1; 664 if (!ce_skip_worktree(istate->cache[pos])) 665 return -1; 666 667 return do_read_blob(&istate->cache[pos]->oid, oid_stat, size_out, data_out); 668} 669 670/* 671 * Frees memory within el which was allocated for exclude patterns and 672 * the file buffer. Does not free el itself. 673 */ 674void clear_exclude_list(struct exclude_list *el) 675{ 676 int i; 677 678 for (i = 0; i < el->nr; i++) 679 free(el->excludes[i]); 680 free(el->excludes); 681 free(el->filebuf); 682 683 memset(el, 0, sizeof(*el)); 684} 685 686static void trim_trailing_spaces(char *buf) 687{ 688 char *p, *last_space = NULL; 689 690 for (p = buf; *p; p++) 691 switch (*p) { 692 case ' ': 693 if (!last_space) 694 last_space = p; 695 break; 696 case '\\': 697 p++; 698 if (!*p) 699 return; 700 /* fallthrough */ 701 default: 702 last_space = NULL; 703 } 704 705 if (last_space) 706 *last_space = '\0'; 707} 708 709/* 710 * Given a subdirectory name and "dir" of the current directory, 711 * search the subdir in "dir" and return it, or create a new one if it 712 * does not exist in "dir". 713 * 714 * If "name" has the trailing slash, it'll be excluded in the search. 715 */ 716static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc, 717 struct untracked_cache_dir *dir, 718 const char *name, int len) 719{ 720 int first, last; 721 struct untracked_cache_dir *d; 722 if (!dir) 723 return NULL; 724 if (len && name[len - 1] == '/') 725 len--; 726 first = 0; 727 last = dir->dirs_nr; 728 while (last > first) { 729 int cmp, next = (last + first) >> 1; 730 d = dir->dirs[next]; 731 cmp = strncmp(name, d->name, len); 732 if (!cmp && strlen(d->name) > len) 733 cmp = -1; 734 if (!cmp) 735 return d; 736 if (cmp < 0) { 737 last = next; 738 continue; 739 } 740 first = next+1; 741 } 742 743 uc->dir_created++; 744 FLEX_ALLOC_MEM(d, name, name, len); 745 746 ALLOC_GROW(dir->dirs, dir->dirs_nr + 1, dir->dirs_alloc); 747 MOVE_ARRAY(dir->dirs + first + 1, dir->dirs + first, 748 dir->dirs_nr - first); 749 dir->dirs_nr++; 750 dir->dirs[first] = d; 751 return d; 752} 753 754static void do_invalidate_gitignore(struct untracked_cache_dir *dir) 755{ 756 int i; 757 dir->valid = 0; 758 dir->untracked_nr = 0; 759 for (i = 0; i < dir->dirs_nr; i++) 760 do_invalidate_gitignore(dir->dirs[i]); 761} 762 763static void invalidate_gitignore(struct untracked_cache *uc, 764 struct untracked_cache_dir *dir) 765{ 766 uc->gitignore_invalidated++; 767 do_invalidate_gitignore(dir); 768} 769 770static void invalidate_directory(struct untracked_cache *uc, 771 struct untracked_cache_dir *dir) 772{ 773 int i; 774 775 /* 776 * Invalidation increment here is just roughly correct. If 777 * untracked_nr or any of dirs[].recurse is non-zero, we 778 * should increment dir_invalidated too. But that's more 779 * expensive to do. 780 */ 781 if (dir->valid) 782 uc->dir_invalidated++; 783 784 dir->valid = 0; 785 dir->untracked_nr = 0; 786 for (i = 0; i < dir->dirs_nr; i++) 787 dir->dirs[i]->recurse = 0; 788} 789 790static int add_excludes_from_buffer(char *buf, size_t size, 791 const char *base, int baselen, 792 struct exclude_list *el); 793 794/* 795 * Given a file with name "fname", read it (either from disk, or from 796 * an index if 'istate' is non-null), parse it and store the 797 * exclude rules in "el". 798 * 799 * If "ss" is not NULL, compute SHA-1 of the exclude file and fill 800 * stat data from disk (only valid if add_excludes returns zero). If 801 * ss_valid is non-zero, "ss" must contain good value as input. 802 */ 803static int add_excludes(const char *fname, const char *base, int baselen, 804 struct exclude_list *el, struct index_state *istate, 805 struct oid_stat *oid_stat) 806{ 807 struct stat st; 808 int r; 809 int fd; 810 size_t size = 0; 811 char *buf; 812 813 fd = open(fname, O_RDONLY); 814 if (fd < 0 || fstat(fd, &st) < 0) { 815 if (fd < 0) 816 warn_on_fopen_errors(fname); 817 else 818 close(fd); 819 if (!istate) 820 return -1; 821 r = read_skip_worktree_file_from_index(istate, fname, 822 &size, &buf, 823 oid_stat); 824 if (r != 1) 825 return r; 826 } else { 827 size = xsize_t(st.st_size); 828 if (size == 0) { 829 if (oid_stat) { 830 fill_stat_data(&oid_stat->stat, &st); 831 oidcpy(&oid_stat->oid, &empty_blob_oid); 832 oid_stat->valid = 1; 833 } 834 close(fd); 835 return 0; 836 } 837 buf = xmallocz(size); 838 if (read_in_full(fd, buf, size) != size) { 839 free(buf); 840 close(fd); 841 return -1; 842 } 843 buf[size++] = '\n'; 844 close(fd); 845 if (oid_stat) { 846 int pos; 847 if (oid_stat->valid && 848 !match_stat_data_racy(istate, &oid_stat->stat, &st)) 849 ; /* no content change, ss->sha1 still good */ 850 else if (istate && 851 (pos = index_name_pos(istate, fname, strlen(fname))) >= 0 && 852 !ce_stage(istate->cache[pos]) && 853 ce_uptodate(istate->cache[pos]) && 854 !would_convert_to_git(istate, fname)) 855 oidcpy(&oid_stat->oid, 856 &istate->cache[pos]->oid); 857 else 858 hash_object_file(buf, size, "blob", 859 &oid_stat->oid); 860 fill_stat_data(&oid_stat->stat, &st); 861 oid_stat->valid = 1; 862 } 863 } 864 865 add_excludes_from_buffer(buf, size, base, baselen, el); 866 return 0; 867} 868 869static int add_excludes_from_buffer(char *buf, size_t size, 870 const char *base, int baselen, 871 struct exclude_list *el) 872{ 873 int i, lineno = 1; 874 char *entry; 875 876 el->filebuf = buf; 877 878 if (skip_utf8_bom(&buf, size)) 879 size -= buf - el->filebuf; 880 881 entry = buf; 882 883 for (i = 0; i < size; i++) { 884 if (buf[i] == '\n') { 885 if (entry != buf + i && entry[0] != '#') { 886 buf[i - (i && buf[i-1] == '\r')] = 0; 887 trim_trailing_spaces(entry); 888 add_exclude(entry, base, baselen, el, lineno); 889 } 890 lineno++; 891 entry = buf + i + 1; 892 } 893 } 894 return 0; 895} 896 897int add_excludes_from_file_to_list(const char *fname, const char *base, 898 int baselen, struct exclude_list *el, 899 struct index_state *istate) 900{ 901 return add_excludes(fname, base, baselen, el, istate, NULL); 902} 903 904int add_excludes_from_blob_to_list( 905 struct object_id *oid, 906 const char *base, int baselen, 907 struct exclude_list *el) 908{ 909 char *buf; 910 size_t size; 911 int r; 912 913 r = do_read_blob(oid, NULL, &size, &buf); 914 if (r != 1) 915 return r; 916 917 add_excludes_from_buffer(buf, size, base, baselen, el); 918 return 0; 919} 920 921struct exclude_list *add_exclude_list(struct dir_struct *dir, 922 int group_type, const char *src) 923{ 924 struct exclude_list *el; 925 struct exclude_list_group *group; 926 927 group = &dir->exclude_list_group[group_type]; 928 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 929 el = &group->el[group->nr++]; 930 memset(el, 0, sizeof(*el)); 931 el->src = src; 932 return el; 933} 934 935/* 936 * Used to set up core.excludesfile and .git/info/exclude lists. 937 */ 938static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname, 939 struct oid_stat *oid_stat) 940{ 941 struct exclude_list *el; 942 /* 943 * catch setup_standard_excludes() that's called before 944 * dir->untracked is assigned. That function behaves 945 * differently when dir->untracked is non-NULL. 946 */ 947 if (!dir->untracked) 948 dir->unmanaged_exclude_files++; 949 el = add_exclude_list(dir, EXC_FILE, fname); 950 if (add_excludes(fname, "", 0, el, NULL, oid_stat) < 0) 951 die("cannot use %s as an exclude file", fname); 952} 953 954void add_excludes_from_file(struct dir_struct *dir, const char *fname) 955{ 956 dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */ 957 add_excludes_from_file_1(dir, fname, NULL); 958} 959 960int match_basename(const char *basename, int basenamelen, 961 const char *pattern, int prefix, int patternlen, 962 unsigned flags) 963{ 964 if (prefix == patternlen) { 965 if (patternlen == basenamelen && 966 !fspathncmp(pattern, basename, basenamelen)) 967 return 1; 968 } else if (flags & EXC_FLAG_ENDSWITH) { 969 /* "*literal" matching against "fooliteral" */ 970 if (patternlen - 1 <= basenamelen && 971 !fspathncmp(pattern + 1, 972 basename + basenamelen - (patternlen - 1), 973 patternlen - 1)) 974 return 1; 975 } else { 976 if (fnmatch_icase_mem(pattern, patternlen, 977 basename, basenamelen, 978 0) == 0) 979 return 1; 980 } 981 return 0; 982} 983 984int match_pathname(const char *pathname, int pathlen, 985 const char *base, int baselen, 986 const char *pattern, int prefix, int patternlen, 987 unsigned flags) 988{ 989 const char *name; 990 int namelen; 991 992 /* 993 * match with FNM_PATHNAME; the pattern has base implicitly 994 * in front of it. 995 */ 996 if (*pattern == '/') { 997 pattern++; 998 patternlen--; 999 prefix--;1000 }10011002 /*1003 * baselen does not count the trailing slash. base[] may or1004 * may not end with a trailing slash though.1005 */1006 if (pathlen < baselen + 1 ||1007 (baselen && pathname[baselen] != '/') ||1008 fspathncmp(pathname, base, baselen))1009 return 0;10101011 namelen = baselen ? pathlen - baselen - 1 : pathlen;1012 name = pathname + pathlen - namelen;10131014 if (prefix) {1015 /*1016 * if the non-wildcard part is longer than the1017 * remaining pathname, surely it cannot match.1018 */1019 if (prefix > namelen)1020 return 0;10211022 if (fspathncmp(pattern, name, prefix))1023 return 0;1024 pattern += prefix;1025 patternlen -= prefix;1026 name += prefix;1027 namelen -= prefix;10281029 /*1030 * If the whole pattern did not have a wildcard,1031 * then our prefix match is all we need; we1032 * do not need to call fnmatch at all.1033 */1034 if (!patternlen && !namelen)1035 return 1;1036 }10371038 return fnmatch_icase_mem(pattern, patternlen,1039 name, namelen,1040 WM_PATHNAME) == 0;1041}10421043/*1044 * Scan the given exclude list in reverse to see whether pathname1045 * should be ignored. The first match (i.e. the last on the list), if1046 * any, determines the fate. Returns the exclude_list element which1047 * matched, or NULL for undecided.1048 */1049static struct exclude *last_exclude_matching_from_list(const char *pathname,1050 int pathlen,1051 const char *basename,1052 int *dtype,1053 struct exclude_list *el,1054 struct index_state *istate)1055{1056 struct exclude *exc = NULL; /* undecided */1057 int i;10581059 if (!el->nr)1060 return NULL; /* undefined */10611062 for (i = el->nr - 1; 0 <= i; i--) {1063 struct exclude *x = el->excludes[i];1064 const char *exclude = x->pattern;1065 int prefix = x->nowildcardlen;10661067 if (x->flags & EXC_FLAG_MUSTBEDIR) {1068 if (*dtype == DT_UNKNOWN)1069 *dtype = get_dtype(NULL, istate, pathname, pathlen);1070 if (*dtype != DT_DIR)1071 continue;1072 }10731074 if (x->flags & EXC_FLAG_NODIR) {1075 if (match_basename(basename,1076 pathlen - (basename - pathname),1077 exclude, prefix, x->patternlen,1078 x->flags)) {1079 exc = x;1080 break;1081 }1082 continue;1083 }10841085 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/');1086 if (match_pathname(pathname, pathlen,1087 x->base, x->baselen ? x->baselen - 1 : 0,1088 exclude, prefix, x->patternlen, x->flags)) {1089 exc = x;1090 break;1091 }1092 }1093 return exc;1094}10951096/*1097 * Scan the list and let the last match determine the fate.1098 * Return 1 for exclude, 0 for include and -1 for undecided.1099 */1100int is_excluded_from_list(const char *pathname,1101 int pathlen, const char *basename, int *dtype,1102 struct exclude_list *el, struct index_state *istate)1103{1104 struct exclude *exclude;1105 exclude = last_exclude_matching_from_list(pathname, pathlen, basename,1106 dtype, el, istate);1107 if (exclude)1108 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1109 return -1; /* undecided */1110}11111112static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,1113 struct index_state *istate,1114 const char *pathname, int pathlen, const char *basename,1115 int *dtype_p)1116{1117 int i, j;1118 struct exclude_list_group *group;1119 struct exclude *exclude;1120 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1121 group = &dir->exclude_list_group[i];1122 for (j = group->nr - 1; j >= 0; j--) {1123 exclude = last_exclude_matching_from_list(1124 pathname, pathlen, basename, dtype_p,1125 &group->el[j], istate);1126 if (exclude)1127 return exclude;1128 }1129 }1130 return NULL;1131}11321133/*1134 * Loads the per-directory exclude list for the substring of base1135 * which has a char length of baselen.1136 */1137static void prep_exclude(struct dir_struct *dir,1138 struct index_state *istate,1139 const char *base, int baselen)1140{1141 struct exclude_list_group *group;1142 struct exclude_list *el;1143 struct exclude_stack *stk = NULL;1144 struct untracked_cache_dir *untracked;1145 int current;11461147 group = &dir->exclude_list_group[EXC_DIRS];11481149 /*1150 * Pop the exclude lists from the EXCL_DIRS exclude_list_group1151 * which originate from directories not in the prefix of the1152 * path being checked.1153 */1154 while ((stk = dir->exclude_stack) != NULL) {1155 if (stk->baselen <= baselen &&1156 !strncmp(dir->basebuf.buf, base, stk->baselen))1157 break;1158 el = &group->el[dir->exclude_stack->exclude_ix];1159 dir->exclude_stack = stk->prev;1160 dir->exclude = NULL;1161 free((char *)el->src); /* see strbuf_detach() below */1162 clear_exclude_list(el);1163 free(stk);1164 group->nr--;1165 }11661167 /* Skip traversing into sub directories if the parent is excluded */1168 if (dir->exclude)1169 return;11701171 /*1172 * Lazy initialization. All call sites currently just1173 * memset(dir, 0, sizeof(*dir)) before use. Changing all of1174 * them seems lots of work for little benefit.1175 */1176 if (!dir->basebuf.buf)1177 strbuf_init(&dir->basebuf, PATH_MAX);11781179 /* Read from the parent directories and push them down. */1180 current = stk ? stk->baselen : -1;1181 strbuf_setlen(&dir->basebuf, current < 0 ? 0 : current);1182 if (dir->untracked)1183 untracked = stk ? stk->ucd : dir->untracked->root;1184 else1185 untracked = NULL;11861187 while (current < baselen) {1188 const char *cp;1189 struct oid_stat oid_stat;11901191 stk = xcalloc(1, sizeof(*stk));1192 if (current < 0) {1193 cp = base;1194 current = 0;1195 } else {1196 cp = strchr(base + current + 1, '/');1197 if (!cp)1198 die("oops in prep_exclude");1199 cp++;1200 untracked =1201 lookup_untracked(dir->untracked, untracked,1202 base + current,1203 cp - base - current);1204 }1205 stk->prev = dir->exclude_stack;1206 stk->baselen = cp - base;1207 stk->exclude_ix = group->nr;1208 stk->ucd = untracked;1209 el = add_exclude_list(dir, EXC_DIRS, NULL);1210 strbuf_add(&dir->basebuf, base + current, stk->baselen - current);1211 assert(stk->baselen == dir->basebuf.len);12121213 /* Abort if the directory is excluded */1214 if (stk->baselen) {1215 int dt = DT_DIR;1216 dir->basebuf.buf[stk->baselen - 1] = 0;1217 dir->exclude = last_exclude_matching_from_lists(dir,1218 istate,1219 dir->basebuf.buf, stk->baselen - 1,1220 dir->basebuf.buf + current, &dt);1221 dir->basebuf.buf[stk->baselen - 1] = '/';1222 if (dir->exclude &&1223 dir->exclude->flags & EXC_FLAG_NEGATIVE)1224 dir->exclude = NULL;1225 if (dir->exclude) {1226 dir->exclude_stack = stk;1227 return;1228 }1229 }12301231 /* Try to read per-directory file */1232 oidclr(&oid_stat.oid);1233 oid_stat.valid = 0;1234 if (dir->exclude_per_dir &&1235 /*1236 * If we know that no files have been added in1237 * this directory (i.e. valid_cached_dir() has1238 * been executed and set untracked->valid) ..1239 */1240 (!untracked || !untracked->valid ||1241 /*1242 * .. and .gitignore does not exist before1243 * (i.e. null exclude_sha1). Then we can skip1244 * loading .gitignore, which would result in1245 * ENOENT anyway.1246 */1247 !is_null_sha1(untracked->exclude_sha1))) {1248 /*1249 * dir->basebuf gets reused by the traversal, but we1250 * need fname to remain unchanged to ensure the src1251 * member of each struct exclude correctly1252 * back-references its source file. Other invocations1253 * of add_exclude_list provide stable strings, so we1254 * strbuf_detach() and free() here in the caller.1255 */1256 struct strbuf sb = STRBUF_INIT;1257 strbuf_addbuf(&sb, &dir->basebuf);1258 strbuf_addstr(&sb, dir->exclude_per_dir);1259 el->src = strbuf_detach(&sb, NULL);1260 add_excludes(el->src, el->src, stk->baselen, el, istate,1261 untracked ? &oid_stat : NULL);1262 }1263 /*1264 * NEEDSWORK: when untracked cache is enabled, prep_exclude()1265 * will first be called in valid_cached_dir() then maybe many1266 * times more in last_exclude_matching(). When the cache is1267 * used, last_exclude_matching() will not be called and1268 * reading .gitignore content will be a waste.1269 *1270 * So when it's called by valid_cached_dir() and we can get1271 * .gitignore SHA-1 from the index (i.e. .gitignore is not1272 * modified on work tree), we could delay reading the1273 * .gitignore content until we absolutely need it in1274 * last_exclude_matching(). Be careful about ignore rule1275 * order, though, if you do that.1276 */1277 if (untracked &&1278 hashcmp(oid_stat.oid.hash, untracked->exclude_sha1)) {1279 invalidate_gitignore(dir->untracked, untracked);1280 hashcpy(untracked->exclude_sha1, oid_stat.oid.hash);1281 }1282 dir->exclude_stack = stk;1283 current = stk->baselen;1284 }1285 strbuf_setlen(&dir->basebuf, baselen);1286}12871288/*1289 * Loads the exclude lists for the directory containing pathname, then1290 * scans all exclude lists to determine whether pathname is excluded.1291 * Returns the exclude_list element which matched, or NULL for1292 * undecided.1293 */1294struct exclude *last_exclude_matching(struct dir_struct *dir,1295 struct index_state *istate,1296 const char *pathname,1297 int *dtype_p)1298{1299 int pathlen = strlen(pathname);1300 const char *basename = strrchr(pathname, '/');1301 basename = (basename) ? basename+1 : pathname;13021303 prep_exclude(dir, istate, pathname, basename-pathname);13041305 if (dir->exclude)1306 return dir->exclude;13071308 return last_exclude_matching_from_lists(dir, istate, pathname, pathlen,1309 basename, dtype_p);1310}13111312/*1313 * Loads the exclude lists for the directory containing pathname, then1314 * scans all exclude lists to determine whether pathname is excluded.1315 * Returns 1 if true, otherwise 0.1316 */1317int is_excluded(struct dir_struct *dir, struct index_state *istate,1318 const char *pathname, int *dtype_p)1319{1320 struct exclude *exclude =1321 last_exclude_matching(dir, istate, pathname, dtype_p);1322 if (exclude)1323 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;1324 return 0;1325}13261327static struct dir_entry *dir_entry_new(const char *pathname, int len)1328{1329 struct dir_entry *ent;13301331 FLEX_ALLOC_MEM(ent, name, pathname, len);1332 ent->len = len;1333 return ent;1334}13351336static struct dir_entry *dir_add_name(struct dir_struct *dir,1337 struct index_state *istate,1338 const char *pathname, int len)1339{1340 if (index_file_exists(istate, pathname, len, ignore_case))1341 return NULL;13421343 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);1344 return dir->entries[dir->nr++] = dir_entry_new(pathname, len);1345}13461347struct dir_entry *dir_add_ignored(struct dir_struct *dir,1348 struct index_state *istate,1349 const char *pathname, int len)1350{1351 if (!index_name_is_other(istate, pathname, len))1352 return NULL;13531354 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);1355 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);1356}13571358enum exist_status {1359 index_nonexistent = 0,1360 index_directory,1361 index_gitdir1362};13631364/*1365 * Do not use the alphabetically sorted index to look up1366 * the directory name; instead, use the case insensitive1367 * directory hash.1368 */1369static enum exist_status directory_exists_in_index_icase(struct index_state *istate,1370 const char *dirname, int len)1371{1372 struct cache_entry *ce;13731374 if (index_dir_exists(istate, dirname, len))1375 return index_directory;13761377 ce = index_file_exists(istate, dirname, len, ignore_case);1378 if (ce && S_ISGITLINK(ce->ce_mode))1379 return index_gitdir;13801381 return index_nonexistent;1382}13831384/*1385 * The index sorts alphabetically by entry name, which1386 * means that a gitlink sorts as '\0' at the end, while1387 * a directory (which is defined not as an entry, but as1388 * the files it contains) will sort with the '/' at the1389 * end.1390 */1391static enum exist_status directory_exists_in_index(struct index_state *istate,1392 const char *dirname, int len)1393{1394 int pos;13951396 if (ignore_case)1397 return directory_exists_in_index_icase(istate, dirname, len);13981399 pos = index_name_pos(istate, dirname, len);1400 if (pos < 0)1401 pos = -pos-1;1402 while (pos < istate->cache_nr) {1403 const struct cache_entry *ce = istate->cache[pos++];1404 unsigned char endchar;14051406 if (strncmp(ce->name, dirname, len))1407 break;1408 endchar = ce->name[len];1409 if (endchar > '/')1410 break;1411 if (endchar == '/')1412 return index_directory;1413 if (!endchar && S_ISGITLINK(ce->ce_mode))1414 return index_gitdir;1415 }1416 return index_nonexistent;1417}14181419/*1420 * When we find a directory when traversing the filesystem, we1421 * have three distinct cases:1422 *1423 * - ignore it1424 * - see it as a directory1425 * - recurse into it1426 *1427 * and which one we choose depends on a combination of existing1428 * git index contents and the flags passed into the directory1429 * traversal routine.1430 *1431 * Case 1: If we *already* have entries in the index under that1432 * directory name, we always recurse into the directory to see1433 * all the files.1434 *1435 * Case 2: If we *already* have that directory name as a gitlink,1436 * we always continue to see it as a gitlink, regardless of whether1437 * there is an actual git directory there or not (it might not1438 * be checked out as a subproject!)1439 *1440 * Case 3: if we didn't have it in the index previously, we1441 * have a few sub-cases:1442 *1443 * (a) if "show_other_directories" is true, we show it as1444 * just a directory, unless "hide_empty_directories" is1445 * also true, in which case we need to check if it contains any1446 * untracked and / or ignored files.1447 * (b) if it looks like a git directory, and we don't have1448 * 'no_gitlinks' set we treat it as a gitlink, and show it1449 * as a directory.1450 * (c) otherwise, we recurse into it.1451 */1452static enum path_treatment treat_directory(struct dir_struct *dir,1453 struct index_state *istate,1454 struct untracked_cache_dir *untracked,1455 const char *dirname, int len, int baselen, int exclude,1456 const struct pathspec *pathspec)1457{1458 /* The "len-1" is to strip the final '/' */1459 switch (directory_exists_in_index(istate, dirname, len-1)) {1460 case index_directory:1461 return path_recurse;14621463 case index_gitdir:1464 return path_none;14651466 case index_nonexistent:1467 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1468 break;1469 if (exclude &&1470 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1471 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING)) {14721473 /*1474 * This is an excluded directory and we are1475 * showing ignored paths that match an exclude1476 * pattern. (e.g. show directory as ignored1477 * only if it matches an exclude pattern).1478 * This path will either be 'path_excluded`1479 * (if we are showing empty directories or if1480 * the directory is not empty), or will be1481 * 'path_none' (empty directory, and we are1482 * not showing empty directories).1483 */1484 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1485 return path_excluded;14861487 if (read_directory_recursive(dir, istate, dirname, len,1488 untracked, 1, 1, pathspec) == path_excluded)1489 return path_excluded;14901491 return path_none;1492 }1493 if (!(dir->flags & DIR_NO_GITLINKS)) {1494 struct object_id oid;1495 if (resolve_gitlink_ref(dirname, "HEAD", &oid) == 0)1496 return exclude ? path_excluded : path_untracked;1497 }1498 return path_recurse;1499 }15001501 /* This is the "show_other_directories" case */15021503 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1504 return exclude ? path_excluded : path_untracked;15051506 untracked = lookup_untracked(dir->untracked, untracked,1507 dirname + baselen, len - baselen);15081509 /*1510 * If this is an excluded directory, then we only need to check if1511 * the directory contains any files.1512 */1513 return read_directory_recursive(dir, istate, dirname, len,1514 untracked, 1, exclude, pathspec);1515}15161517/*1518 * This is an inexact early pruning of any recursive directory1519 * reading - if the path cannot possibly be in the pathspec,1520 * return true, and we'll skip it early.1521 */1522static int simplify_away(const char *path, int pathlen,1523 const struct pathspec *pathspec)1524{1525 int i;15261527 if (!pathspec || !pathspec->nr)1528 return 0;15291530 GUARD_PATHSPEC(pathspec,1531 PATHSPEC_FROMTOP |1532 PATHSPEC_MAXDEPTH |1533 PATHSPEC_LITERAL |1534 PATHSPEC_GLOB |1535 PATHSPEC_ICASE |1536 PATHSPEC_EXCLUDE |1537 PATHSPEC_ATTR);15381539 for (i = 0; i < pathspec->nr; i++) {1540 const struct pathspec_item *item = &pathspec->items[i];1541 int len = item->nowildcard_len;15421543 if (len > pathlen)1544 len = pathlen;1545 if (!ps_strncmp(item, item->match, path, len))1546 return 0;1547 }15481549 return 1;1550}15511552/*1553 * This function tells us whether an excluded path matches a1554 * list of "interesting" pathspecs. That is, whether a path matched1555 * by any of the pathspecs could possibly be ignored by excluding1556 * the specified path. This can happen if:1557 *1558 * 1. the path is mentioned explicitly in the pathspec1559 *1560 * 2. the path is a directory prefix of some element in the1561 * pathspec1562 */1563static int exclude_matches_pathspec(const char *path, int pathlen,1564 const struct pathspec *pathspec)1565{1566 int i;15671568 if (!pathspec || !pathspec->nr)1569 return 0;15701571 GUARD_PATHSPEC(pathspec,1572 PATHSPEC_FROMTOP |1573 PATHSPEC_MAXDEPTH |1574 PATHSPEC_LITERAL |1575 PATHSPEC_GLOB |1576 PATHSPEC_ICASE |1577 PATHSPEC_EXCLUDE);15781579 for (i = 0; i < pathspec->nr; i++) {1580 const struct pathspec_item *item = &pathspec->items[i];1581 int len = item->nowildcard_len;15821583 if (len == pathlen &&1584 !ps_strncmp(item, item->match, path, pathlen))1585 return 1;1586 if (len > pathlen &&1587 item->match[pathlen] == '/' &&1588 !ps_strncmp(item, item->match, path, pathlen))1589 return 1;1590 }1591 return 0;1592}15931594static int get_index_dtype(struct index_state *istate,1595 const char *path, int len)1596{1597 int pos;1598 const struct cache_entry *ce;15991600 ce = index_file_exists(istate, path, len, 0);1601 if (ce) {1602 if (!ce_uptodate(ce))1603 return DT_UNKNOWN;1604 if (S_ISGITLINK(ce->ce_mode))1605 return DT_DIR;1606 /*1607 * Nobody actually cares about the1608 * difference between DT_LNK and DT_REG1609 */1610 return DT_REG;1611 }16121613 /* Try to look it up as a directory */1614 pos = index_name_pos(istate, path, len);1615 if (pos >= 0)1616 return DT_UNKNOWN;1617 pos = -pos-1;1618 while (pos < istate->cache_nr) {1619 ce = istate->cache[pos++];1620 if (strncmp(ce->name, path, len))1621 break;1622 if (ce->name[len] > '/')1623 break;1624 if (ce->name[len] < '/')1625 continue;1626 if (!ce_uptodate(ce))1627 break; /* continue? */1628 return DT_DIR;1629 }1630 return DT_UNKNOWN;1631}16321633static int get_dtype(struct dirent *de, struct index_state *istate,1634 const char *path, int len)1635{1636 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1637 struct stat st;16381639 if (dtype != DT_UNKNOWN)1640 return dtype;1641 dtype = get_index_dtype(istate, path, len);1642 if (dtype != DT_UNKNOWN)1643 return dtype;1644 if (lstat(path, &st))1645 return dtype;1646 if (S_ISREG(st.st_mode))1647 return DT_REG;1648 if (S_ISDIR(st.st_mode))1649 return DT_DIR;1650 if (S_ISLNK(st.st_mode))1651 return DT_LNK;1652 return dtype;1653}16541655static enum path_treatment treat_one_path(struct dir_struct *dir,1656 struct untracked_cache_dir *untracked,1657 struct index_state *istate,1658 struct strbuf *path,1659 int baselen,1660 const struct pathspec *pathspec,1661 int dtype, struct dirent *de)1662{1663 int exclude;1664 int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);1665 enum path_treatment path_treatment;16661667 if (dtype == DT_UNKNOWN)1668 dtype = get_dtype(de, istate, path->buf, path->len);16691670 /* Always exclude indexed files */1671 if (dtype != DT_DIR && has_path_in_index)1672 return path_none;16731674 /*1675 * When we are looking at a directory P in the working tree,1676 * there are three cases:1677 *1678 * (1) P exists in the index. Everything inside the directory P in1679 * the working tree needs to go when P is checked out from the1680 * index.1681 *1682 * (2) P does not exist in the index, but there is P/Q in the index.1683 * We know P will stay a directory when we check out the contents1684 * of the index, but we do not know yet if there is a directory1685 * P/Q in the working tree to be killed, so we need to recurse.1686 *1687 * (3) P does not exist in the index, and there is no P/Q in the index1688 * to require P to be a directory, either. Only in this case, we1689 * know that everything inside P will not be killed without1690 * recursing.1691 */1692 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1693 (dtype == DT_DIR) &&1694 !has_path_in_index &&1695 (directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))1696 return path_none;16971698 exclude = is_excluded(dir, istate, path->buf, &dtype);16991700 /*1701 * Excluded? If we don't explicitly want to show1702 * ignored files, ignore it1703 */1704 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1705 return path_excluded;17061707 switch (dtype) {1708 default:1709 return path_none;1710 case DT_DIR:1711 strbuf_addch(path, '/');1712 path_treatment = treat_directory(dir, istate, untracked,1713 path->buf, path->len,1714 baselen, exclude, pathspec);1715 /*1716 * If 1) we only want to return directories that1717 * match an exclude pattern and 2) this directory does1718 * not match an exclude pattern but all of its1719 * contents are excluded, then indicate that we should1720 * recurse into this directory (instead of marking the1721 * directory itself as an ignored path).1722 */1723 if (!exclude &&1724 path_treatment == path_excluded &&1725 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1726 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING))1727 return path_recurse;1728 return path_treatment;1729 case DT_REG:1730 case DT_LNK:1731 return exclude ? path_excluded : path_untracked;1732 }1733}17341735static enum path_treatment treat_path_fast(struct dir_struct *dir,1736 struct untracked_cache_dir *untracked,1737 struct cached_dir *cdir,1738 struct index_state *istate,1739 struct strbuf *path,1740 int baselen,1741 const struct pathspec *pathspec)1742{1743 strbuf_setlen(path, baselen);1744 if (!cdir->ucd) {1745 strbuf_addstr(path, cdir->file);1746 return path_untracked;1747 }1748 strbuf_addstr(path, cdir->ucd->name);1749 /* treat_one_path() does this before it calls treat_directory() */1750 strbuf_complete(path, '/');1751 if (cdir->ucd->check_only)1752 /*1753 * check_only is set as a result of treat_directory() getting1754 * to its bottom. Verify again the same set of directories1755 * with check_only set.1756 */1757 return read_directory_recursive(dir, istate, path->buf, path->len,1758 cdir->ucd, 1, 0, pathspec);1759 /*1760 * We get path_recurse in the first run when1761 * directory_exists_in_index() returns index_nonexistent. We1762 * are sure that new changes in the index does not impact the1763 * outcome. Return now.1764 */1765 return path_recurse;1766}17671768static enum path_treatment treat_path(struct dir_struct *dir,1769 struct untracked_cache_dir *untracked,1770 struct cached_dir *cdir,1771 struct index_state *istate,1772 struct strbuf *path,1773 int baselen,1774 const struct pathspec *pathspec)1775{1776 int dtype;1777 struct dirent *de = cdir->de;17781779 if (!de)1780 return treat_path_fast(dir, untracked, cdir, istate, path,1781 baselen, pathspec);1782 if (is_dot_or_dotdot(de->d_name) || !fspathcmp(de->d_name, ".git"))1783 return path_none;1784 strbuf_setlen(path, baselen);1785 strbuf_addstr(path, de->d_name);1786 if (simplify_away(path->buf, path->len, pathspec))1787 return path_none;17881789 dtype = DTYPE(de);1790 return treat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);1791}17921793static void add_untracked(struct untracked_cache_dir *dir, const char *name)1794{1795 if (!dir)1796 return;1797 ALLOC_GROW(dir->untracked, dir->untracked_nr + 1,1798 dir->untracked_alloc);1799 dir->untracked[dir->untracked_nr++] = xstrdup(name);1800}18011802static int valid_cached_dir(struct dir_struct *dir,1803 struct untracked_cache_dir *untracked,1804 struct index_state *istate,1805 struct strbuf *path,1806 int check_only)1807{1808 struct stat st;18091810 if (!untracked)1811 return 0;18121813 /*1814 * With fsmonitor, we can trust the untracked cache's valid field.1815 */1816 refresh_fsmonitor(istate);1817 if (!(dir->untracked->use_fsmonitor && untracked->valid)) {1818 if (lstat(path->len ? path->buf : ".", &st)) {1819 memset(&untracked->stat_data, 0, sizeof(untracked->stat_data));1820 return 0;1821 }1822 if (!untracked->valid ||1823 match_stat_data_racy(istate, &untracked->stat_data, &st)) {1824 fill_stat_data(&untracked->stat_data, &st);1825 return 0;1826 }1827 }18281829 if (untracked->check_only != !!check_only)1830 return 0;18311832 /*1833 * prep_exclude will be called eventually on this directory,1834 * but it's called much later in last_exclude_matching(). We1835 * need it now to determine the validity of the cache for this1836 * path. The next calls will be nearly no-op, the way1837 * prep_exclude() is designed.1838 */1839 if (path->len && path->buf[path->len - 1] != '/') {1840 strbuf_addch(path, '/');1841 prep_exclude(dir, istate, path->buf, path->len);1842 strbuf_setlen(path, path->len - 1);1843 } else1844 prep_exclude(dir, istate, path->buf, path->len);18451846 /* hopefully prep_exclude() haven't invalidated this entry... */1847 return untracked->valid;1848}18491850static int open_cached_dir(struct cached_dir *cdir,1851 struct dir_struct *dir,1852 struct untracked_cache_dir *untracked,1853 struct index_state *istate,1854 struct strbuf *path,1855 int check_only)1856{1857 const char *c_path;18581859 memset(cdir, 0, sizeof(*cdir));1860 cdir->untracked = untracked;1861 if (valid_cached_dir(dir, untracked, istate, path, check_only))1862 return 0;1863 c_path = path->len ? path->buf : ".";1864 cdir->fdir = opendir(c_path);1865 if (!cdir->fdir)1866 warning_errno(_("could not open directory '%s'"), c_path);1867 if (dir->untracked) {1868 invalidate_directory(dir->untracked, untracked);1869 dir->untracked->dir_opened++;1870 }1871 if (!cdir->fdir)1872 return -1;1873 return 0;1874}18751876static int read_cached_dir(struct cached_dir *cdir)1877{1878 if (cdir->fdir) {1879 cdir->de = readdir(cdir->fdir);1880 if (!cdir->de)1881 return -1;1882 return 0;1883 }1884 while (cdir->nr_dirs < cdir->untracked->dirs_nr) {1885 struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];1886 if (!d->recurse) {1887 cdir->nr_dirs++;1888 continue;1889 }1890 cdir->ucd = d;1891 cdir->nr_dirs++;1892 return 0;1893 }1894 cdir->ucd = NULL;1895 if (cdir->nr_files < cdir->untracked->untracked_nr) {1896 struct untracked_cache_dir *d = cdir->untracked;1897 cdir->file = d->untracked[cdir->nr_files++];1898 return 0;1899 }1900 return -1;1901}19021903static void close_cached_dir(struct cached_dir *cdir)1904{1905 if (cdir->fdir)1906 closedir(cdir->fdir);1907 /*1908 * We have gone through this directory and found no untracked1909 * entries. Mark it valid.1910 */1911 if (cdir->untracked) {1912 cdir->untracked->valid = 1;1913 cdir->untracked->recurse = 1;1914 }1915}19161917/*1918 * Read a directory tree. We currently ignore anything but1919 * directories, regular files and symlinks. That's because git1920 * doesn't handle them at all yet. Maybe that will change some1921 * day.1922 *1923 * Also, we ignore the name ".git" (even if it is not a directory).1924 * That likely will not change.1925 *1926 * If 'stop_at_first_file' is specified, 'path_excluded' is returned1927 * to signal that a file was found. This is the least significant value that1928 * indicates that a file was encountered that does not depend on the order of1929 * whether an untracked or exluded path was encountered first.1930 *1931 * Returns the most significant path_treatment value encountered in the scan.1932 * If 'stop_at_first_file' is specified, `path_excluded` is the most1933 * significant path_treatment value that will be returned.1934 */19351936static enum path_treatment read_directory_recursive(struct dir_struct *dir,1937 struct index_state *istate, const char *base, int baselen,1938 struct untracked_cache_dir *untracked, int check_only,1939 int stop_at_first_file, const struct pathspec *pathspec)1940{1941 struct cached_dir cdir;1942 enum path_treatment state, subdir_state, dir_state = path_none;1943 struct strbuf path = STRBUF_INIT;19441945 strbuf_add(&path, base, baselen);19461947 if (open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))1948 goto out;19491950 if (untracked)1951 untracked->check_only = !!check_only;19521953 while (!read_cached_dir(&cdir)) {1954 /* check how the file or directory should be treated */1955 state = treat_path(dir, untracked, &cdir, istate, &path,1956 baselen, pathspec);19571958 if (state > dir_state)1959 dir_state = state;19601961 /* recurse into subdir if instructed by treat_path */1962 if ((state == path_recurse) ||1963 ((state == path_untracked) &&1964 (dir->flags & DIR_SHOW_IGNORED_TOO) &&1965 (get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {1966 struct untracked_cache_dir *ud;1967 ud = lookup_untracked(dir->untracked, untracked,1968 path.buf + baselen,1969 path.len - baselen);1970 subdir_state =1971 read_directory_recursive(dir, istate, path.buf,1972 path.len, ud,1973 check_only, stop_at_first_file, pathspec);1974 if (subdir_state > dir_state)1975 dir_state = subdir_state;1976 }19771978 if (check_only) {1979 if (stop_at_first_file) {1980 /*1981 * If stopping at first file, then1982 * signal that a file was found by1983 * returning `path_excluded`. This is1984 * to return a consistent value1985 * regardless of whether an ignored or1986 * excluded file happened to be1987 * encountered 1st.1988 *1989 * In current usage, the1990 * `stop_at_first_file` is passed when1991 * an ancestor directory has matched1992 * an exclude pattern, so any found1993 * files will be excluded.1994 */1995 if (dir_state >= path_excluded) {1996 dir_state = path_excluded;1997 break;1998 }1999 }20002001 /* abort early if maximum state has been reached */2002 if (dir_state == path_untracked) {2003 if (cdir.fdir)2004 add_untracked(untracked, path.buf + baselen);2005 break;2006 }2007 /* skip the dir_add_* part */2008 continue;2009 }20102011 /* add the path to the appropriate result list */2012 switch (state) {2013 case path_excluded:2014 if (dir->flags & DIR_SHOW_IGNORED)2015 dir_add_name(dir, istate, path.buf, path.len);2016 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||2017 ((dir->flags & DIR_COLLECT_IGNORED) &&2018 exclude_matches_pathspec(path.buf, path.len,2019 pathspec)))2020 dir_add_ignored(dir, istate, path.buf, path.len);2021 break;20222023 case path_untracked:2024 if (dir->flags & DIR_SHOW_IGNORED)2025 break;2026 dir_add_name(dir, istate, path.buf, path.len);2027 if (cdir.fdir)2028 add_untracked(untracked, path.buf + baselen);2029 break;20302031 default:2032 break;2033 }2034 }2035 close_cached_dir(&cdir);2036 out:2037 strbuf_release(&path);20382039 return dir_state;2040}20412042int cmp_dir_entry(const void *p1, const void *p2)2043{2044 const struct dir_entry *e1 = *(const struct dir_entry **)p1;2045 const struct dir_entry *e2 = *(const struct dir_entry **)p2;20462047 return name_compare(e1->name, e1->len, e2->name, e2->len);2048}20492050/* check if *out lexically strictly contains *in */2051int check_dir_entry_contains(const struct dir_entry *out, const struct dir_entry *in)2052{2053 return (out->len < in->len) &&2054 (out->name[out->len - 1] == '/') &&2055 !memcmp(out->name, in->name, out->len);2056}20572058static int treat_leading_path(struct dir_struct *dir,2059 struct index_state *istate,2060 const char *path, int len,2061 const struct pathspec *pathspec)2062{2063 struct strbuf sb = STRBUF_INIT;2064 int baselen, rc = 0;2065 const char *cp;2066 int old_flags = dir->flags;20672068 while (len && path[len - 1] == '/')2069 len--;2070 if (!len)2071 return 1;2072 baselen = 0;2073 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;2074 while (1) {2075 cp = path + baselen + !!baselen;2076 cp = memchr(cp, '/', path + len - cp);2077 if (!cp)2078 baselen = len;2079 else2080 baselen = cp - path;2081 strbuf_setlen(&sb, 0);2082 strbuf_add(&sb, path, baselen);2083 if (!is_directory(sb.buf))2084 break;2085 if (simplify_away(sb.buf, sb.len, pathspec))2086 break;2087 if (treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,2088 DT_DIR, NULL) == path_none)2089 break; /* do not recurse into it */2090 if (len <= baselen) {2091 rc = 1;2092 break; /* finished checking */2093 }2094 }2095 strbuf_release(&sb);2096 dir->flags = old_flags;2097 return rc;2098}20992100static const char *get_ident_string(void)2101{2102 static struct strbuf sb = STRBUF_INIT;2103 struct utsname uts;21042105 if (sb.len)2106 return sb.buf;2107 if (uname(&uts) < 0)2108 die_errno(_("failed to get kernel name and information"));2109 strbuf_addf(&sb, "Location %s, system %s", get_git_work_tree(),2110 uts.sysname);2111 return sb.buf;2112}21132114static int ident_in_untracked(const struct untracked_cache *uc)2115{2116 /*2117 * Previous git versions may have saved many NUL separated2118 * strings in the "ident" field, but it is insane to manage2119 * many locations, so just take care of the first one.2120 */21212122 return !strcmp(uc->ident.buf, get_ident_string());2123}21242125static void set_untracked_ident(struct untracked_cache *uc)2126{2127 strbuf_reset(&uc->ident);2128 strbuf_addstr(&uc->ident, get_ident_string());21292130 /*2131 * This strbuf used to contain a list of NUL separated2132 * strings, so save NUL too for backward compatibility.2133 */2134 strbuf_addch(&uc->ident, 0);2135}21362137static void new_untracked_cache(struct index_state *istate)2138{2139 struct untracked_cache *uc = xcalloc(1, sizeof(*uc));2140 strbuf_init(&uc->ident, 100);2141 uc->exclude_per_dir = ".gitignore";2142 /* should be the same flags used by git-status */2143 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;2144 set_untracked_ident(uc);2145 istate->untracked = uc;2146 istate->cache_changed |= UNTRACKED_CHANGED;2147}21482149void add_untracked_cache(struct index_state *istate)2150{2151 if (!istate->untracked) {2152 new_untracked_cache(istate);2153 } else {2154 if (!ident_in_untracked(istate->untracked)) {2155 free_untracked_cache(istate->untracked);2156 new_untracked_cache(istate);2157 }2158 }2159}21602161void remove_untracked_cache(struct index_state *istate)2162{2163 if (istate->untracked) {2164 free_untracked_cache(istate->untracked);2165 istate->untracked = NULL;2166 istate->cache_changed |= UNTRACKED_CHANGED;2167 }2168}21692170static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,2171 int base_len,2172 const struct pathspec *pathspec)2173{2174 struct untracked_cache_dir *root;2175 static int untracked_cache_disabled = -1;21762177 if (!dir->untracked)2178 return NULL;2179 if (untracked_cache_disabled < 0)2180 untracked_cache_disabled = git_env_bool("GIT_DISABLE_UNTRACKED_CACHE", 0);2181 if (untracked_cache_disabled)2182 return NULL;21832184 /*2185 * We only support $GIT_DIR/info/exclude and core.excludesfile2186 * as the global ignore rule files. Any other additions2187 * (e.g. from command line) invalidate the cache. This2188 * condition also catches running setup_standard_excludes()2189 * before setting dir->untracked!2190 */2191 if (dir->unmanaged_exclude_files)2192 return NULL;21932194 /*2195 * Optimize for the main use case only: whole-tree git2196 * status. More work involved in treat_leading_path() if we2197 * use cache on just a subset of the worktree. pathspec2198 * support could make the matter even worse.2199 */2200 if (base_len || (pathspec && pathspec->nr))2201 return NULL;22022203 /* Different set of flags may produce different results */2204 if (dir->flags != dir->untracked->dir_flags ||2205 /*2206 * See treat_directory(), case index_nonexistent. Without2207 * this flag, we may need to also cache .git file content2208 * for the resolve_gitlink_ref() call, which we don't.2209 */2210 !(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||2211 /* We don't support collecting ignore files */2212 (dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |2213 DIR_COLLECT_IGNORED)))2214 return NULL;22152216 /*2217 * If we use .gitignore in the cache and now you change it to2218 * .gitexclude, everything will go wrong.2219 */2220 if (dir->exclude_per_dir != dir->untracked->exclude_per_dir &&2221 strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))2222 return NULL;22232224 /*2225 * EXC_CMDL is not considered in the cache. If people set it,2226 * skip the cache.2227 */2228 if (dir->exclude_list_group[EXC_CMDL].nr)2229 return NULL;22302231 if (!ident_in_untracked(dir->untracked)) {2232 warning(_("Untracked cache is disabled on this system or location."));2233 return NULL;2234 }22352236 if (!dir->untracked->root) {2237 const int len = sizeof(*dir->untracked->root);2238 dir->untracked->root = xmalloc(len);2239 memset(dir->untracked->root, 0, len);2240 }22412242 /* Validate $GIT_DIR/info/exclude and core.excludesfile */2243 root = dir->untracked->root;2244 if (oidcmp(&dir->ss_info_exclude.oid,2245 &dir->untracked->ss_info_exclude.oid)) {2246 invalidate_gitignore(dir->untracked, root);2247 dir->untracked->ss_info_exclude = dir->ss_info_exclude;2248 }2249 if (oidcmp(&dir->ss_excludes_file.oid,2250 &dir->untracked->ss_excludes_file.oid)) {2251 invalidate_gitignore(dir->untracked, root);2252 dir->untracked->ss_excludes_file = dir->ss_excludes_file;2253 }22542255 /* Make sure this directory is not dropped out at saving phase */2256 root->recurse = 1;2257 return root;2258}22592260int read_directory(struct dir_struct *dir, struct index_state *istate,2261 const char *path, int len, const struct pathspec *pathspec)2262{2263 struct untracked_cache_dir *untracked;2264 uint64_t start = getnanotime();22652266 if (has_symlink_leading_path(path, len))2267 return dir->nr;22682269 untracked = validate_untracked_cache(dir, len, pathspec);2270 if (!untracked)2271 /*2272 * make sure untracked cache code path is disabled,2273 * e.g. prep_exclude()2274 */2275 dir->untracked = NULL;2276 if (!len || treat_leading_path(dir, istate, path, len, pathspec))2277 read_directory_recursive(dir, istate, path, len, untracked, 0, 0, pathspec);2278 QSORT(dir->entries, dir->nr, cmp_dir_entry);2279 QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);22802281 /*2282 * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will2283 * also pick up untracked contents of untracked dirs; by default2284 * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.2285 */2286 if ((dir->flags & DIR_SHOW_IGNORED_TOO) &&2287 !(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {2288 int i, j;22892290 /* remove from dir->entries untracked contents of untracked dirs */2291 for (i = j = 0; j < dir->nr; j++) {2292 if (i &&2293 check_dir_entry_contains(dir->entries[i - 1], dir->entries[j])) {2294 FREE_AND_NULL(dir->entries[j]);2295 } else {2296 dir->entries[i++] = dir->entries[j];2297 }2298 }22992300 dir->nr = i;2301 }23022303 trace_performance_since(start, "read directory %.*s", len, path);2304 if (dir->untracked) {2305 static int force_untracked_cache = -1;2306 static struct trace_key trace_untracked_stats = TRACE_KEY_INIT(UNTRACKED_STATS);23072308 if (force_untracked_cache < 0)2309 force_untracked_cache =2310 git_env_bool("GIT_FORCE_UNTRACKED_CACHE", 0);2311 trace_printf_key(&trace_untracked_stats,2312 "node creation: %u\n"2313 "gitignore invalidation: %u\n"2314 "directory invalidation: %u\n"2315 "opendir: %u\n",2316 dir->untracked->dir_created,2317 dir->untracked->gitignore_invalidated,2318 dir->untracked->dir_invalidated,2319 dir->untracked->dir_opened);2320 if (force_untracked_cache &&2321 dir->untracked == istate->untracked &&2322 (dir->untracked->dir_opened ||2323 dir->untracked->gitignore_invalidated ||2324 dir->untracked->dir_invalidated))2325 istate->cache_changed |= UNTRACKED_CHANGED;2326 if (dir->untracked != istate->untracked) {2327 FREE_AND_NULL(dir->untracked);2328 }2329 }2330 return dir->nr;2331}23322333int file_exists(const char *f)2334{2335 struct stat sb;2336 return lstat(f, &sb) == 0;2337}23382339static int cmp_icase(char a, char b)2340{2341 if (a == b)2342 return 0;2343 if (ignore_case)2344 return toupper(a) - toupper(b);2345 return a - b;2346}23472348/*2349 * Given two normalized paths (a trailing slash is ok), if subdir is2350 * outside dir, return -1. Otherwise return the offset in subdir that2351 * can be used as relative path to dir.2352 */2353int dir_inside_of(const char *subdir, const char *dir)2354{2355 int offset = 0;23562357 assert(dir && subdir && *dir && *subdir);23582359 while (*dir && *subdir && !cmp_icase(*dir, *subdir)) {2360 dir++;2361 subdir++;2362 offset++;2363 }23642365 /* hel[p]/me vs hel[l]/yeah */2366 if (*dir && *subdir)2367 return -1;23682369 if (!*subdir)2370 return !*dir ? offset : -1; /* same dir */23712372 /* foo/[b]ar vs foo/[] */2373 if (is_dir_sep(dir[-1]))2374 return is_dir_sep(subdir[-1]) ? offset : -1;23752376 /* foo[/]bar vs foo[] */2377 return is_dir_sep(*subdir) ? offset + 1 : -1;2378}23792380int is_inside_dir(const char *dir)2381{2382 char *cwd;2383 int rc;23842385 if (!dir)2386 return 0;23872388 cwd = xgetcwd();2389 rc = (dir_inside_of(cwd, dir) >= 0);2390 free(cwd);2391 return rc;2392}23932394int is_empty_dir(const char *path)2395{2396 DIR *dir = opendir(path);2397 struct dirent *e;2398 int ret = 1;23992400 if (!dir)2401 return 0;24022403 while ((e = readdir(dir)) != NULL)2404 if (!is_dot_or_dotdot(e->d_name)) {2405 ret = 0;2406 break;2407 }24082409 closedir(dir);2410 return ret;2411}24122413static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)2414{2415 DIR *dir;2416 struct dirent *e;2417 int ret = 0, original_len = path->len, len, kept_down = 0;2418 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);2419 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);2420 struct object_id submodule_head;24212422 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&2423 !resolve_gitlink_ref(path->buf, "HEAD", &submodule_head)) {2424 /* Do not descend and nuke a nested git work tree. */2425 if (kept_up)2426 *kept_up = 1;2427 return 0;2428 }24292430 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;2431 dir = opendir(path->buf);2432 if (!dir) {2433 if (errno == ENOENT)2434 return keep_toplevel ? -1 : 0;2435 else if (errno == EACCES && !keep_toplevel)2436 /*2437 * An empty dir could be removable even if it2438 * is unreadable:2439 */2440 return rmdir(path->buf);2441 else2442 return -1;2443 }2444 strbuf_complete(path, '/');24452446 len = path->len;2447 while ((e = readdir(dir)) != NULL) {2448 struct stat st;2449 if (is_dot_or_dotdot(e->d_name))2450 continue;24512452 strbuf_setlen(path, len);2453 strbuf_addstr(path, e->d_name);2454 if (lstat(path->buf, &st)) {2455 if (errno == ENOENT)2456 /*2457 * file disappeared, which is what we2458 * wanted anyway2459 */2460 continue;2461 /* fall thru */2462 } else if (S_ISDIR(st.st_mode)) {2463 if (!remove_dir_recurse(path, flag, &kept_down))2464 continue; /* happy */2465 } else if (!only_empty &&2466 (!unlink(path->buf) || errno == ENOENT)) {2467 continue; /* happy, too */2468 }24692470 /* path too long, stat fails, or non-directory still exists */2471 ret = -1;2472 break;2473 }2474 closedir(dir);24752476 strbuf_setlen(path, original_len);2477 if (!ret && !keep_toplevel && !kept_down)2478 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;2479 else if (kept_up)2480 /*2481 * report the uplevel that it is not an error that we2482 * did not rmdir() our directory.2483 */2484 *kept_up = !ret;2485 return ret;2486}24872488int remove_dir_recursively(struct strbuf *path, int flag)2489{2490 return remove_dir_recurse(path, flag, NULL);2491}24922493static GIT_PATH_FUNC(git_path_info_exclude, "info/exclude")24942495void setup_standard_excludes(struct dir_struct *dir)2496{2497 dir->exclude_per_dir = ".gitignore";24982499 /* core.excludefile defaulting to $XDG_HOME/git/ignore */2500 if (!excludes_file)2501 excludes_file = xdg_config_home("ignore");2502 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))2503 add_excludes_from_file_1(dir, excludes_file,2504 dir->untracked ? &dir->ss_excludes_file : NULL);25052506 /* per repository user preference */2507 if (startup_info->have_repository) {2508 const char *path = git_path_info_exclude();2509 if (!access_or_warn(path, R_OK, 0))2510 add_excludes_from_file_1(dir, path,2511 dir->untracked ? &dir->ss_info_exclude : NULL);2512 }2513}25142515int remove_path(const char *name)2516{2517 char *slash;25182519 if (unlink(name) && !is_missing_file_error(errno))2520 return -1;25212522 slash = strrchr(name, '/');2523 if (slash) {2524 char *dirs = xstrdup(name);2525 slash = dirs + (slash - name);2526 do {2527 *slash = '\0';2528 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));2529 free(dirs);2530 }2531 return 0;2532}25332534/*2535 * Frees memory within dir which was allocated for exclude lists and2536 * the exclude_stack. Does not free dir itself.2537 */2538void clear_directory(struct dir_struct *dir)2539{2540 int i, j;2541 struct exclude_list_group *group;2542 struct exclude_list *el;2543 struct exclude_stack *stk;25442545 for (i = EXC_CMDL; i <= EXC_FILE; i++) {2546 group = &dir->exclude_list_group[i];2547 for (j = 0; j < group->nr; j++) {2548 el = &group->el[j];2549 if (i == EXC_DIRS)2550 free((char *)el->src);2551 clear_exclude_list(el);2552 }2553 free(group->el);2554 }25552556 stk = dir->exclude_stack;2557 while (stk) {2558 struct exclude_stack *prev = stk->prev;2559 free(stk);2560 stk = prev;2561 }2562 strbuf_release(&dir->basebuf);2563}25642565struct ondisk_untracked_cache {2566 struct stat_data info_exclude_stat;2567 struct stat_data excludes_file_stat;2568 uint32_t dir_flags;2569 unsigned char info_exclude_sha1[20];2570 unsigned char excludes_file_sha1[20];2571 char exclude_per_dir[FLEX_ARRAY];2572};25732574#define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)2575#define ouc_size(len) (ouc_offset(exclude_per_dir) + len + 1)25762577struct write_data {2578 int index; /* number of written untracked_cache_dir */2579 struct ewah_bitmap *check_only; /* from untracked_cache_dir */2580 struct ewah_bitmap *valid; /* from untracked_cache_dir */2581 struct ewah_bitmap *sha1_valid; /* set if exclude_sha1 is not null */2582 struct strbuf out;2583 struct strbuf sb_stat;2584 struct strbuf sb_sha1;2585};25862587static void stat_data_to_disk(struct stat_data *to, const struct stat_data *from)2588{2589 to->sd_ctime.sec = htonl(from->sd_ctime.sec);2590 to->sd_ctime.nsec = htonl(from->sd_ctime.nsec);2591 to->sd_mtime.sec = htonl(from->sd_mtime.sec);2592 to->sd_mtime.nsec = htonl(from->sd_mtime.nsec);2593 to->sd_dev = htonl(from->sd_dev);2594 to->sd_ino = htonl(from->sd_ino);2595 to->sd_uid = htonl(from->sd_uid);2596 to->sd_gid = htonl(from->sd_gid);2597 to->sd_size = htonl(from->sd_size);2598}25992600static void write_one_dir(struct untracked_cache_dir *untracked,2601 struct write_data *wd)2602{2603 struct stat_data stat_data;2604 struct strbuf *out = &wd->out;2605 unsigned char intbuf[16];2606 unsigned int intlen, value;2607 int i = wd->index++;26082609 /*2610 * untracked_nr should be reset whenever valid is clear, but2611 * for safety..2612 */2613 if (!untracked->valid) {2614 untracked->untracked_nr = 0;2615 untracked->check_only = 0;2616 }26172618 if (untracked->check_only)2619 ewah_set(wd->check_only, i);2620 if (untracked->valid) {2621 ewah_set(wd->valid, i);2622 stat_data_to_disk(&stat_data, &untracked->stat_data);2623 strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data));2624 }2625 if (!is_null_sha1(untracked->exclude_sha1)) {2626 ewah_set(wd->sha1_valid, i);2627 strbuf_add(&wd->sb_sha1, untracked->exclude_sha1, 20);2628 }26292630 intlen = encode_varint(untracked->untracked_nr, intbuf);2631 strbuf_add(out, intbuf, intlen);26322633 /* skip non-recurse directories */2634 for (i = 0, value = 0; i < untracked->dirs_nr; i++)2635 if (untracked->dirs[i]->recurse)2636 value++;2637 intlen = encode_varint(value, intbuf);2638 strbuf_add(out, intbuf, intlen);26392640 strbuf_add(out, untracked->name, strlen(untracked->name) + 1);26412642 for (i = 0; i < untracked->untracked_nr; i++)2643 strbuf_add(out, untracked->untracked[i],2644 strlen(untracked->untracked[i]) + 1);26452646 for (i = 0; i < untracked->dirs_nr; i++)2647 if (untracked->dirs[i]->recurse)2648 write_one_dir(untracked->dirs[i], wd);2649}26502651void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked)2652{2653 struct ondisk_untracked_cache *ouc;2654 struct write_data wd;2655 unsigned char varbuf[16];2656 int varint_len;2657 size_t len = strlen(untracked->exclude_per_dir);26582659 FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);2660 stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);2661 stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);2662 hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.oid.hash);2663 hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.oid.hash);2664 ouc->dir_flags = htonl(untracked->dir_flags);26652666 varint_len = encode_varint(untracked->ident.len, varbuf);2667 strbuf_add(out, varbuf, varint_len);2668 strbuf_addbuf(out, &untracked->ident);26692670 strbuf_add(out, ouc, ouc_size(len));2671 FREE_AND_NULL(ouc);26722673 if (!untracked->root) {2674 varint_len = encode_varint(0, varbuf);2675 strbuf_add(out, varbuf, varint_len);2676 return;2677 }26782679 wd.index = 0;2680 wd.check_only = ewah_new();2681 wd.valid = ewah_new();2682 wd.sha1_valid = ewah_new();2683 strbuf_init(&wd.out, 1024);2684 strbuf_init(&wd.sb_stat, 1024);2685 strbuf_init(&wd.sb_sha1, 1024);2686 write_one_dir(untracked->root, &wd);26872688 varint_len = encode_varint(wd.index, varbuf);2689 strbuf_add(out, varbuf, varint_len);2690 strbuf_addbuf(out, &wd.out);2691 ewah_serialize_strbuf(wd.valid, out);2692 ewah_serialize_strbuf(wd.check_only, out);2693 ewah_serialize_strbuf(wd.sha1_valid, out);2694 strbuf_addbuf(out, &wd.sb_stat);2695 strbuf_addbuf(out, &wd.sb_sha1);2696 strbuf_addch(out, '\0'); /* safe guard for string lists */26972698 ewah_free(wd.valid);2699 ewah_free(wd.check_only);2700 ewah_free(wd.sha1_valid);2701 strbuf_release(&wd.out);2702 strbuf_release(&wd.sb_stat);2703 strbuf_release(&wd.sb_sha1);2704}27052706static void free_untracked(struct untracked_cache_dir *ucd)2707{2708 int i;2709 if (!ucd)2710 return;2711 for (i = 0; i < ucd->dirs_nr; i++)2712 free_untracked(ucd->dirs[i]);2713 for (i = 0; i < ucd->untracked_nr; i++)2714 free(ucd->untracked[i]);2715 free(ucd->untracked);2716 free(ucd->dirs);2717 free(ucd);2718}27192720void free_untracked_cache(struct untracked_cache *uc)2721{2722 if (uc)2723 free_untracked(uc->root);2724 free(uc);2725}27262727struct read_data {2728 int index;2729 struct untracked_cache_dir **ucd;2730 struct ewah_bitmap *check_only;2731 struct ewah_bitmap *valid;2732 struct ewah_bitmap *sha1_valid;2733 const unsigned char *data;2734 const unsigned char *end;2735};27362737static void stat_data_from_disk(struct stat_data *to, const unsigned char *data)2738{2739 memcpy(to, data, sizeof(*to));2740 to->sd_ctime.sec = ntohl(to->sd_ctime.sec);2741 to->sd_ctime.nsec = ntohl(to->sd_ctime.nsec);2742 to->sd_mtime.sec = ntohl(to->sd_mtime.sec);2743 to->sd_mtime.nsec = ntohl(to->sd_mtime.nsec);2744 to->sd_dev = ntohl(to->sd_dev);2745 to->sd_ino = ntohl(to->sd_ino);2746 to->sd_uid = ntohl(to->sd_uid);2747 to->sd_gid = ntohl(to->sd_gid);2748 to->sd_size = ntohl(to->sd_size);2749}27502751static int read_one_dir(struct untracked_cache_dir **untracked_,2752 struct read_data *rd)2753{2754 struct untracked_cache_dir ud, *untracked;2755 const unsigned char *next, *data = rd->data, *end = rd->end;2756 unsigned int value;2757 int i, len;27582759 memset(&ud, 0, sizeof(ud));27602761 next = data;2762 value = decode_varint(&next);2763 if (next > end)2764 return -1;2765 ud.recurse = 1;2766 ud.untracked_alloc = value;2767 ud.untracked_nr = value;2768 if (ud.untracked_nr)2769 ALLOC_ARRAY(ud.untracked, ud.untracked_nr);2770 data = next;27712772 next = data;2773 ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);2774 if (next > end)2775 return -1;2776 ALLOC_ARRAY(ud.dirs, ud.dirs_nr);2777 data = next;27782779 len = strlen((const char *)data);2780 next = data + len + 1;2781 if (next > rd->end)2782 return -1;2783 *untracked_ = untracked = xmalloc(st_add(sizeof(*untracked), len));2784 memcpy(untracked, &ud, sizeof(ud));2785 memcpy(untracked->name, data, len + 1);2786 data = next;27872788 for (i = 0; i < untracked->untracked_nr; i++) {2789 len = strlen((const char *)data);2790 next = data + len + 1;2791 if (next > rd->end)2792 return -1;2793 untracked->untracked[i] = xstrdup((const char*)data);2794 data = next;2795 }27962797 rd->ucd[rd->index++] = untracked;2798 rd->data = data;27992800 for (i = 0; i < untracked->dirs_nr; i++) {2801 len = read_one_dir(untracked->dirs + i, rd);2802 if (len < 0)2803 return -1;2804 }2805 return 0;2806}28072808static void set_check_only(size_t pos, void *cb)2809{2810 struct read_data *rd = cb;2811 struct untracked_cache_dir *ud = rd->ucd[pos];2812 ud->check_only = 1;2813}28142815static void read_stat(size_t pos, void *cb)2816{2817 struct read_data *rd = cb;2818 struct untracked_cache_dir *ud = rd->ucd[pos];2819 if (rd->data + sizeof(struct stat_data) > rd->end) {2820 rd->data = rd->end + 1;2821 return;2822 }2823 stat_data_from_disk(&ud->stat_data, rd->data);2824 rd->data += sizeof(struct stat_data);2825 ud->valid = 1;2826}28272828static void read_sha1(size_t pos, void *cb)2829{2830 struct read_data *rd = cb;2831 struct untracked_cache_dir *ud = rd->ucd[pos];2832 if (rd->data + 20 > rd->end) {2833 rd->data = rd->end + 1;2834 return;2835 }2836 hashcpy(ud->exclude_sha1, rd->data);2837 rd->data += 20;2838}28392840static void load_oid_stat(struct oid_stat *oid_stat, const unsigned char *data,2841 const unsigned char *sha1)2842{2843 stat_data_from_disk(&oid_stat->stat, data);2844 hashcpy(oid_stat->oid.hash, sha1);2845 oid_stat->valid = 1;2846}28472848struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz)2849{2850 struct untracked_cache *uc;2851 struct read_data rd;2852 const unsigned char *next = data, *end = (const unsigned char *)data + sz;2853 const char *ident;2854 int ident_len, len;2855 const char *exclude_per_dir;28562857 if (sz <= 1 || end[-1] != '\0')2858 return NULL;2859 end--;28602861 ident_len = decode_varint(&next);2862 if (next + ident_len > end)2863 return NULL;2864 ident = (const char *)next;2865 next += ident_len;28662867 if (next + ouc_size(0) > end)2868 return NULL;28692870 uc = xcalloc(1, sizeof(*uc));2871 strbuf_init(&uc->ident, ident_len);2872 strbuf_add(&uc->ident, ident, ident_len);2873 load_oid_stat(&uc->ss_info_exclude,2874 next + ouc_offset(info_exclude_stat),2875 next + ouc_offset(info_exclude_sha1));2876 load_oid_stat(&uc->ss_excludes_file,2877 next + ouc_offset(excludes_file_stat),2878 next + ouc_offset(excludes_file_sha1));2879 uc->dir_flags = get_be32(next + ouc_offset(dir_flags));2880 exclude_per_dir = (const char *)next + ouc_offset(exclude_per_dir);2881 uc->exclude_per_dir = xstrdup(exclude_per_dir);2882 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */2883 next += ouc_size(strlen(exclude_per_dir));2884 if (next >= end)2885 goto done2;28862887 len = decode_varint(&next);2888 if (next > end || len == 0)2889 goto done2;28902891 rd.valid = ewah_new();2892 rd.check_only = ewah_new();2893 rd.sha1_valid = ewah_new();2894 rd.data = next;2895 rd.end = end;2896 rd.index = 0;2897 ALLOC_ARRAY(rd.ucd, len);28982899 if (read_one_dir(&uc->root, &rd) || rd.index != len)2900 goto done;29012902 next = rd.data;2903 len = ewah_read_mmap(rd.valid, next, end - next);2904 if (len < 0)2905 goto done;29062907 next += len;2908 len = ewah_read_mmap(rd.check_only, next, end - next);2909 if (len < 0)2910 goto done;29112912 next += len;2913 len = ewah_read_mmap(rd.sha1_valid, next, end - next);2914 if (len < 0)2915 goto done;29162917 ewah_each_bit(rd.check_only, set_check_only, &rd);2918 rd.data = next + len;2919 ewah_each_bit(rd.valid, read_stat, &rd);2920 ewah_each_bit(rd.sha1_valid, read_sha1, &rd);2921 next = rd.data;29222923done:2924 free(rd.ucd);2925 ewah_free(rd.valid);2926 ewah_free(rd.check_only);2927 ewah_free(rd.sha1_valid);2928done2:2929 if (next != end) {2930 free_untracked_cache(uc);2931 uc = NULL;2932 }2933 return uc;2934}29352936static void invalidate_one_directory(struct untracked_cache *uc,2937 struct untracked_cache_dir *ucd)2938{2939 uc->dir_invalidated++;2940 ucd->valid = 0;2941 ucd->untracked_nr = 0;2942}29432944/*2945 * Normally when an entry is added or removed from a directory,2946 * invalidating that directory is enough. No need to touch its2947 * ancestors. When a directory is shown as "foo/bar/" in git-status2948 * however, deleting or adding an entry may have cascading effect.2949 *2950 * Say the "foo/bar/file" has become untracked, we need to tell the2951 * untracked_cache_dir of "foo" that "bar/" is not an untracked2952 * directory any more (because "bar" is managed by foo as an untracked2953 * "file").2954 *2955 * Similarly, if "foo/bar/file" moves from untracked to tracked and it2956 * was the last untracked entry in the entire "foo", we should show2957 * "foo/" instead. Which means we have to invalidate past "bar" up to2958 * "foo".2959 *2960 * This function traverses all directories from root to leaf. If there2961 * is a chance of one of the above cases happening, we invalidate back2962 * to root. Otherwise we just invalidate the leaf. There may be a more2963 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to2964 * detect these cases and avoid unnecessary invalidation, for example,2965 * checking for the untracked entry named "bar/" in "foo", but for now2966 * stick to something safe and simple.2967 */2968static int invalidate_one_component(struct untracked_cache *uc,2969 struct untracked_cache_dir *dir,2970 const char *path, int len)2971{2972 const char *rest = strchr(path, '/');29732974 if (rest) {2975 int component_len = rest - path;2976 struct untracked_cache_dir *d =2977 lookup_untracked(uc, dir, path, component_len);2978 int ret =2979 invalidate_one_component(uc, d, rest + 1,2980 len - (component_len + 1));2981 if (ret)2982 invalidate_one_directory(uc, dir);2983 return ret;2984 }29852986 invalidate_one_directory(uc, dir);2987 return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;2988}29892990void untracked_cache_invalidate_path(struct index_state *istate,2991 const char *path, int safe_path)2992{2993 if (!istate->untracked || !istate->untracked->root)2994 return;2995 if (!safe_path && !verify_path(path))2996 return;2997 invalidate_one_component(istate->untracked, istate->untracked->root,2998 path, strlen(path));2999}30003001void untracked_cache_remove_from_index(struct index_state *istate,3002 const char *path)3003{3004 untracked_cache_invalidate_path(istate, path, 1);3005}30063007void untracked_cache_add_to_index(struct index_state *istate,3008 const char *path)3009{3010 untracked_cache_invalidate_path(istate, path, 1);3011}30123013/* Update gitfile and core.worktree setting to connect work tree and git dir */3014void connect_work_tree_and_git_dir(const char *work_tree_, const char *git_dir_)3015{3016 struct strbuf gitfile_sb = STRBUF_INIT;3017 struct strbuf cfg_sb = STRBUF_INIT;3018 struct strbuf rel_path = STRBUF_INIT;3019 char *git_dir, *work_tree;30203021 /* Prepare .git file */3022 strbuf_addf(&gitfile_sb, "%s/.git", work_tree_);3023 if (safe_create_leading_directories_const(gitfile_sb.buf))3024 die(_("could not create directories for %s"), gitfile_sb.buf);30253026 /* Prepare config file */3027 strbuf_addf(&cfg_sb, "%s/config", git_dir_);3028 if (safe_create_leading_directories_const(cfg_sb.buf))3029 die(_("could not create directories for %s"), cfg_sb.buf);30303031 git_dir = real_pathdup(git_dir_, 1);3032 work_tree = real_pathdup(work_tree_, 1);30333034 /* Write .git file */3035 write_file(gitfile_sb.buf, "gitdir: %s",3036 relative_path(git_dir, work_tree, &rel_path));3037 /* Update core.worktree setting */3038 git_config_set_in_file(cfg_sb.buf, "core.worktree",3039 relative_path(work_tree, git_dir, &rel_path));30403041 strbuf_release(&gitfile_sb);3042 strbuf_release(&cfg_sb);3043 strbuf_release(&rel_path);3044 free(work_tree);3045 free(git_dir);3046}30473048/*3049 * Migrate the git directory of the given path from old_git_dir to new_git_dir.3050 */3051void relocate_gitdir(const char *path, const char *old_git_dir, const char *new_git_dir)3052{3053 if (rename(old_git_dir, new_git_dir) < 0)3054 die_errno(_("could not migrate git directory from '%s' to '%s'"),3055 old_git_dir, new_git_dir);30563057 connect_work_tree_and_git_dir(path, new_git_dir);3058}