1/* 2 * This handles recursive filename detection with exclude 3 * files, index knowledge etc.. 4 * 5 * See Documentation/technical/api-directory-listing.txt 6 * 7 * Copyright (C) Linus Torvalds, 2005-2006 8 * Junio Hamano, 2005-2006 9 */ 10#include "cache.h" 11#include "dir.h" 12#include "refs.h" 13#include "wildmatch.h" 14#include "pathspec.h" 15 16struct path_simplify { 17 int len; 18 const char *path; 19}; 20 21/* 22 * Tells read_directory_recursive how a file or directory should be treated. 23 * Values are ordered by significance, e.g. if a directory contains both 24 * excluded and untracked files, it is listed as untracked because 25 * path_untracked > path_excluded. 26 */ 27enum path_treatment { 28 path_none = 0, 29 path_recurse, 30 path_excluded, 31 path_untracked 32}; 33 34static enum path_treatment read_directory_recursive(struct dir_struct *dir, 35 const char *path, int len, 36 int check_only, const struct path_simplify *simplify); 37static int get_dtype(struct dirent *de, const char *path, int len); 38 39/* helper string functions with support for the ignore_case flag */ 40int strcmp_icase(const char *a, const char *b) 41{ 42 return ignore_case ? strcasecmp(a, b) : strcmp(a, b); 43} 44 45int strncmp_icase(const char *a, const char *b, size_t count) 46{ 47 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count); 48} 49 50int fnmatch_icase(const char *pattern, const char *string, int flags) 51{ 52 return wildmatch(pattern, string, 53 flags | (ignore_case ? WM_CASEFOLD : 0), 54 NULL); 55} 56 57int git_fnmatch(const struct pathspec_item *item, 58 const char *pattern, const char *string, 59 int prefix) 60{ 61 if (prefix > 0) { 62 if (ps_strncmp(item, pattern, string, prefix)) 63 return WM_NOMATCH; 64 pattern += prefix; 65 string += prefix; 66 } 67 if (item->flags & PATHSPEC_ONESTAR) { 68 int pattern_len = strlen(++pattern); 69 int string_len = strlen(string); 70 return string_len < pattern_len || 71 ps_strcmp(item, pattern, 72 string + string_len - pattern_len); 73 } 74 if (item->magic & PATHSPEC_GLOB) 75 return wildmatch(pattern, string, 76 WM_PATHNAME | 77 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0), 78 NULL); 79 else 80 /* wildmatch has not learned no FNM_PATHNAME mode yet */ 81 return wildmatch(pattern, string, 82 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0, 83 NULL); 84} 85 86static int fnmatch_icase_mem(const char *pattern, int patternlen, 87 const char *string, int stringlen, 88 int flags) 89{ 90 int match_status; 91 struct strbuf pat_buf = STRBUF_INIT; 92 struct strbuf str_buf = STRBUF_INIT; 93 const char *use_pat = pattern; 94 const char *use_str = string; 95 96 if (pattern[patternlen]) { 97 strbuf_add(&pat_buf, pattern, patternlen); 98 use_pat = pat_buf.buf; 99 } 100 if (string[stringlen]) { 101 strbuf_add(&str_buf, string, stringlen); 102 use_str = str_buf.buf; 103 } 104 105 if (ignore_case) 106 flags |= WM_CASEFOLD; 107 match_status = wildmatch(use_pat, use_str, flags, NULL); 108 109 strbuf_release(&pat_buf); 110 strbuf_release(&str_buf); 111 112 return match_status; 113} 114 115static size_t common_prefix_len(const struct pathspec *pathspec) 116{ 117 int n; 118 size_t max = 0; 119 120 /* 121 * ":(icase)path" is treated as a pathspec full of 122 * wildcard. In other words, only prefix is considered common 123 * prefix. If the pathspec is abc/foo abc/bar, running in 124 * subdir xyz, the common prefix is still xyz, not xuz/abc as 125 * in non-:(icase). 126 */ 127 GUARD_PATHSPEC(pathspec, 128 PATHSPEC_FROMTOP | 129 PATHSPEC_MAXDEPTH | 130 PATHSPEC_LITERAL | 131 PATHSPEC_GLOB | 132 PATHSPEC_ICASE | 133 PATHSPEC_EXCLUDE); 134 135 for (n = 0; n < pathspec->nr; n++) { 136 size_t i = 0, len = 0, item_len; 137 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE) 138 continue; 139 if (pathspec->items[n].magic & PATHSPEC_ICASE) 140 item_len = pathspec->items[n].prefix; 141 else 142 item_len = pathspec->items[n].nowildcard_len; 143 while (i < item_len && (n == 0 || i < max)) { 144 char c = pathspec->items[n].match[i]; 145 if (c != pathspec->items[0].match[i]) 146 break; 147 if (c == '/') 148 len = i + 1; 149 i++; 150 } 151 if (n == 0 || len < max) { 152 max = len; 153 if (!max) 154 break; 155 } 156 } 157 return max; 158} 159 160/* 161 * Returns a copy of the longest leading path common among all 162 * pathspecs. 163 */ 164char *common_prefix(const struct pathspec *pathspec) 165{ 166 unsigned long len = common_prefix_len(pathspec); 167 168 return len ? xmemdupz(pathspec->items[0].match, len) : NULL; 169} 170 171int fill_directory(struct dir_struct *dir, const struct pathspec *pathspec) 172{ 173 size_t len; 174 175 /* 176 * Calculate common prefix for the pathspec, and 177 * use that to optimize the directory walk 178 */ 179 len = common_prefix_len(pathspec); 180 181 /* Read the directory and prune it */ 182 read_directory(dir, pathspec->nr ? pathspec->_raw[0] : "", len, pathspec); 183 return len; 184} 185 186int within_depth(const char *name, int namelen, 187 int depth, int max_depth) 188{ 189 const char *cp = name, *cpe = name + namelen; 190 191 while (cp < cpe) { 192 if (*cp++ != '/') 193 continue; 194 depth++; 195 if (depth > max_depth) 196 return 0; 197 } 198 return 1; 199} 200 201#define DO_MATCH_EXCLUDE 1 202#define DO_MATCH_DIRECTORY 2 203 204/* 205 * Does 'match' match the given name? 206 * A match is found if 207 * 208 * (1) the 'match' string is leading directory of 'name', or 209 * (2) the 'match' string is a wildcard and matches 'name', or 210 * (3) the 'match' string is exactly the same as 'name'. 211 * 212 * and the return value tells which case it was. 213 * 214 * It returns 0 when there is no match. 215 */ 216static int match_pathspec_item(const struct pathspec_item *item, int prefix, 217 const char *name, int namelen, unsigned flags) 218{ 219 /* name/namelen has prefix cut off by caller */ 220 const char *match = item->match + prefix; 221 int matchlen = item->len - prefix; 222 223 /* 224 * The normal call pattern is: 225 * 1. prefix = common_prefix_len(ps); 226 * 2. prune something, or fill_directory 227 * 3. match_pathspec() 228 * 229 * 'prefix' at #1 may be shorter than the command's prefix and 230 * it's ok for #2 to match extra files. Those extras will be 231 * trimmed at #3. 232 * 233 * Suppose the pathspec is 'foo' and '../bar' running from 234 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 235 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 236 * user does not want XYZ/foo, only the "foo" part should be 237 * case-insensitive. We need to filter out XYZ/foo here. In 238 * other words, we do not trust the caller on comparing the 239 * prefix part when :(icase) is involved. We do exact 240 * comparison ourselves. 241 * 242 * Normally the caller (common_prefix_len() in fact) does 243 * _exact_ matching on name[-prefix+1..-1] and we do not need 244 * to check that part. Be defensive and check it anyway, in 245 * case common_prefix_len is changed, or a new caller is 246 * introduced that does not use common_prefix_len. 247 * 248 * If the penalty turns out too high when prefix is really 249 * long, maybe change it to 250 * strncmp(match, name, item->prefix - prefix) 251 */ 252 if (item->prefix && (item->magic & PATHSPEC_ICASE) && 253 strncmp(item->match, name - prefix, item->prefix)) 254 return 0; 255 256 /* If the match was just the prefix, we matched */ 257 if (!*match) 258 return MATCHED_RECURSIVELY; 259 260 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 261 if (matchlen == namelen) 262 return MATCHED_EXACTLY; 263 264 if (match[matchlen-1] == '/' || name[matchlen] == '/') 265 return MATCHED_RECURSIVELY; 266 } else if ((flags & DO_MATCH_DIRECTORY) && 267 match[matchlen - 1] == '/' && 268 namelen == matchlen - 1 && 269 !ps_strncmp(item, match, name, namelen)) 270 return MATCHED_EXACTLY; 271 272 if (item->nowildcard_len < item->len && 273 !git_fnmatch(item, match, name, 274 item->nowildcard_len - prefix)) 275 return MATCHED_FNMATCH; 276 277 return 0; 278} 279 280/* 281 * Given a name and a list of pathspecs, returns the nature of the 282 * closest (i.e. most specific) match of the name to any of the 283 * pathspecs. 284 * 285 * The caller typically calls this multiple times with the same 286 * pathspec and seen[] array but with different name/namelen 287 * (e.g. entries from the index) and is interested in seeing if and 288 * how each pathspec matches all the names it calls this function 289 * with. A mark is left in the seen[] array for each pathspec element 290 * indicating the closest type of match that element achieved, so if 291 * seen[n] remains zero after multiple invocations, that means the nth 292 * pathspec did not match any names, which could indicate that the 293 * user mistyped the nth pathspec. 294 */ 295static int do_match_pathspec(const struct pathspec *ps, 296 const char *name, int namelen, 297 int prefix, char *seen, 298 unsigned flags) 299{ 300 int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE; 301 302 GUARD_PATHSPEC(ps, 303 PATHSPEC_FROMTOP | 304 PATHSPEC_MAXDEPTH | 305 PATHSPEC_LITERAL | 306 PATHSPEC_GLOB | 307 PATHSPEC_ICASE | 308 PATHSPEC_EXCLUDE); 309 310 if (!ps->nr) { 311 if (!ps->recursive || 312 !(ps->magic & PATHSPEC_MAXDEPTH) || 313 ps->max_depth == -1) 314 return MATCHED_RECURSIVELY; 315 316 if (within_depth(name, namelen, 0, ps->max_depth)) 317 return MATCHED_EXACTLY; 318 else 319 return 0; 320 } 321 322 name += prefix; 323 namelen -= prefix; 324 325 for (i = ps->nr - 1; i >= 0; i--) { 326 int how; 327 328 if ((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 329 ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 330 continue; 331 332 if (seen && seen[i] == MATCHED_EXACTLY) 333 continue; 334 /* 335 * Make exclude patterns optional and never report 336 * "pathspec ':(exclude)foo' matches no files" 337 */ 338 if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 339 seen[i] = MATCHED_FNMATCH; 340 how = match_pathspec_item(ps->items+i, prefix, name, 341 namelen, flags); 342 if (ps->recursive && 343 (ps->magic & PATHSPEC_MAXDEPTH) && 344 ps->max_depth != -1 && 345 how && how != MATCHED_FNMATCH) { 346 int len = ps->items[i].len; 347 if (name[len] == '/') 348 len++; 349 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 350 how = MATCHED_EXACTLY; 351 else 352 how = 0; 353 } 354 if (how) { 355 if (retval < how) 356 retval = how; 357 if (seen && seen[i] < how) 358 seen[i] = how; 359 } 360 } 361 return retval; 362} 363 364int match_pathspec(const struct pathspec *ps, 365 const char *name, int namelen, 366 int prefix, char *seen, int is_dir) 367{ 368 int positive, negative; 369 unsigned flags = is_dir ? DO_MATCH_DIRECTORY : 0; 370 positive = do_match_pathspec(ps, name, namelen, 371 prefix, seen, flags); 372 if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 373 return positive; 374 negative = do_match_pathspec(ps, name, namelen, 375 prefix, seen, 376 flags | DO_MATCH_EXCLUDE); 377 return negative ? 0 : positive; 378} 379 380/* 381 * Return the length of the "simple" part of a path match limiter. 382 */ 383int simple_length(const char *match) 384{ 385 int len = -1; 386 387 for (;;) { 388 unsigned char c = *match++; 389 len++; 390 if (c == '\0' || is_glob_special(c)) 391 return len; 392 } 393} 394 395int no_wildcard(const char *string) 396{ 397 return string[simple_length(string)] == '\0'; 398} 399 400void parse_exclude_pattern(const char **pattern, 401 int *patternlen, 402 int *flags, 403 int *nowildcardlen) 404{ 405 const char *p = *pattern; 406 size_t i, len; 407 408 *flags = 0; 409 if (*p == '!') { 410 *flags |= EXC_FLAG_NEGATIVE; 411 p++; 412 } 413 len = strlen(p); 414 if (len && p[len - 1] == '/') { 415 len--; 416 *flags |= EXC_FLAG_MUSTBEDIR; 417 } 418 for (i = 0; i < len; i++) { 419 if (p[i] == '/') 420 break; 421 } 422 if (i == len) 423 *flags |= EXC_FLAG_NODIR; 424 *nowildcardlen = simple_length(p); 425 /* 426 * we should have excluded the trailing slash from 'p' too, 427 * but that's one more allocation. Instead just make sure 428 * nowildcardlen does not exceed real patternlen 429 */ 430 if (*nowildcardlen > len) 431 *nowildcardlen = len; 432 if (*p == '*' && no_wildcard(p + 1)) 433 *flags |= EXC_FLAG_ENDSWITH; 434 *pattern = p; 435 *patternlen = len; 436} 437 438void add_exclude(const char *string, const char *base, 439 int baselen, struct exclude_list *el, int srcpos) 440{ 441 struct exclude *x; 442 int patternlen; 443 int flags; 444 int nowildcardlen; 445 446 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 447 if (flags & EXC_FLAG_MUSTBEDIR) { 448 char *s; 449 x = xmalloc(sizeof(*x) + patternlen + 1); 450 s = (char *)(x+1); 451 memcpy(s, string, patternlen); 452 s[patternlen] = '\0'; 453 x->pattern = s; 454 } else { 455 x = xmalloc(sizeof(*x)); 456 x->pattern = string; 457 } 458 x->patternlen = patternlen; 459 x->nowildcardlen = nowildcardlen; 460 x->base = base; 461 x->baselen = baselen; 462 x->flags = flags; 463 x->srcpos = srcpos; 464 ALLOC_GROW(el->excludes, el->nr + 1, el->alloc); 465 el->excludes[el->nr++] = x; 466 x->el = el; 467} 468 469static void *read_skip_worktree_file_from_index(const char *path, size_t *size) 470{ 471 int pos, len; 472 unsigned long sz; 473 enum object_type type; 474 void *data; 475 476 len = strlen(path); 477 pos = cache_name_pos(path, len); 478 if (pos < 0) 479 return NULL; 480 if (!ce_skip_worktree(active_cache[pos])) 481 return NULL; 482 data = read_sha1_file(active_cache[pos]->sha1, &type, &sz); 483 if (!data || type != OBJ_BLOB) { 484 free(data); 485 return NULL; 486 } 487 *size = xsize_t(sz); 488 return data; 489} 490 491/* 492 * Frees memory within el which was allocated for exclude patterns and 493 * the file buffer. Does not free el itself. 494 */ 495void clear_exclude_list(struct exclude_list *el) 496{ 497 int i; 498 499 for (i = 0; i < el->nr; i++) 500 free(el->excludes[i]); 501 free(el->excludes); 502 free(el->filebuf); 503 504 el->nr = 0; 505 el->excludes = NULL; 506 el->filebuf = NULL; 507} 508 509static void trim_trailing_spaces(char *buf) 510{ 511 char *p, *last_space = NULL; 512 513 for (p = buf; *p; p++) 514 switch (*p) { 515 case ' ': 516 if (!last_space) 517 last_space = p; 518 break; 519 case '\\': 520 p++; 521 if (!*p) 522 return; 523 /* fallthrough */ 524 default: 525 last_space = NULL; 526 } 527 528 if (last_space) 529 *last_space = '\0'; 530} 531 532int add_excludes_from_file_to_list(const char *fname, 533 const char *base, 534 int baselen, 535 struct exclude_list *el, 536 int check_index) 537{ 538 struct stat st; 539 int fd, i, lineno = 1; 540 size_t size = 0; 541 char *buf, *entry; 542 543 fd = open(fname, O_RDONLY); 544 if (fd < 0 || fstat(fd, &st) < 0) { 545 if (errno != ENOENT) 546 warn_on_inaccessible(fname); 547 if (0 <= fd) 548 close(fd); 549 if (!check_index || 550 (buf = read_skip_worktree_file_from_index(fname, &size)) == NULL) 551 return -1; 552 if (size == 0) { 553 free(buf); 554 return 0; 555 } 556 if (buf[size-1] != '\n') { 557 buf = xrealloc(buf, size+1); 558 buf[size++] = '\n'; 559 } 560 } else { 561 size = xsize_t(st.st_size); 562 if (size == 0) { 563 close(fd); 564 return 0; 565 } 566 buf = xmalloc(size+1); 567 if (read_in_full(fd, buf, size) != size) { 568 free(buf); 569 close(fd); 570 return -1; 571 } 572 buf[size++] = '\n'; 573 close(fd); 574 } 575 576 el->filebuf = buf; 577 entry = buf; 578 for (i = 0; i < size; i++) { 579 if (buf[i] == '\n') { 580 if (entry != buf + i && entry[0] != '#') { 581 buf[i - (i && buf[i-1] == '\r')] = 0; 582 trim_trailing_spaces(entry); 583 add_exclude(entry, base, baselen, el, lineno); 584 } 585 lineno++; 586 entry = buf + i + 1; 587 } 588 } 589 return 0; 590} 591 592struct exclude_list *add_exclude_list(struct dir_struct *dir, 593 int group_type, const char *src) 594{ 595 struct exclude_list *el; 596 struct exclude_list_group *group; 597 598 group = &dir->exclude_list_group[group_type]; 599 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 600 el = &group->el[group->nr++]; 601 memset(el, 0, sizeof(*el)); 602 el->src = src; 603 return el; 604} 605 606/* 607 * Used to set up core.excludesfile and .git/info/exclude lists. 608 */ 609void add_excludes_from_file(struct dir_struct *dir, const char *fname) 610{ 611 struct exclude_list *el; 612 el = add_exclude_list(dir, EXC_FILE, fname); 613 if (add_excludes_from_file_to_list(fname, "", 0, el, 0) < 0) 614 die("cannot use %s as an exclude file", fname); 615} 616 617int match_basename(const char *basename, int basenamelen, 618 const char *pattern, int prefix, int patternlen, 619 int flags) 620{ 621 if (prefix == patternlen) { 622 if (patternlen == basenamelen && 623 !strncmp_icase(pattern, basename, basenamelen)) 624 return 1; 625 } else if (flags & EXC_FLAG_ENDSWITH) { 626 /* "*literal" matching against "fooliteral" */ 627 if (patternlen - 1 <= basenamelen && 628 !strncmp_icase(pattern + 1, 629 basename + basenamelen - (patternlen - 1), 630 patternlen - 1)) 631 return 1; 632 } else { 633 if (fnmatch_icase_mem(pattern, patternlen, 634 basename, basenamelen, 635 0) == 0) 636 return 1; 637 } 638 return 0; 639} 640 641int match_pathname(const char *pathname, int pathlen, 642 const char *base, int baselen, 643 const char *pattern, int prefix, int patternlen, 644 int flags) 645{ 646 const char *name; 647 int namelen; 648 649 /* 650 * match with FNM_PATHNAME; the pattern has base implicitly 651 * in front of it. 652 */ 653 if (*pattern == '/') { 654 pattern++; 655 patternlen--; 656 prefix--; 657 } 658 659 /* 660 * baselen does not count the trailing slash. base[] may or 661 * may not end with a trailing slash though. 662 */ 663 if (pathlen < baselen + 1 || 664 (baselen && pathname[baselen] != '/') || 665 strncmp_icase(pathname, base, baselen)) 666 return 0; 667 668 namelen = baselen ? pathlen - baselen - 1 : pathlen; 669 name = pathname + pathlen - namelen; 670 671 if (prefix) { 672 /* 673 * if the non-wildcard part is longer than the 674 * remaining pathname, surely it cannot match. 675 */ 676 if (prefix > namelen) 677 return 0; 678 679 if (strncmp_icase(pattern, name, prefix)) 680 return 0; 681 pattern += prefix; 682 patternlen -= prefix; 683 name += prefix; 684 namelen -= prefix; 685 686 /* 687 * If the whole pattern did not have a wildcard, 688 * then our prefix match is all we need; we 689 * do not need to call fnmatch at all. 690 */ 691 if (!patternlen && !namelen) 692 return 1; 693 } 694 695 return fnmatch_icase_mem(pattern, patternlen, 696 name, namelen, 697 WM_PATHNAME) == 0; 698} 699 700/* 701 * Scan the given exclude list in reverse to see whether pathname 702 * should be ignored. The first match (i.e. the last on the list), if 703 * any, determines the fate. Returns the exclude_list element which 704 * matched, or NULL for undecided. 705 */ 706static struct exclude *last_exclude_matching_from_list(const char *pathname, 707 int pathlen, 708 const char *basename, 709 int *dtype, 710 struct exclude_list *el) 711{ 712 int i; 713 714 if (!el->nr) 715 return NULL; /* undefined */ 716 717 for (i = el->nr - 1; 0 <= i; i--) { 718 struct exclude *x = el->excludes[i]; 719 const char *exclude = x->pattern; 720 int prefix = x->nowildcardlen; 721 722 if (x->flags & EXC_FLAG_MUSTBEDIR) { 723 if (*dtype == DT_UNKNOWN) 724 *dtype = get_dtype(NULL, pathname, pathlen); 725 if (*dtype != DT_DIR) 726 continue; 727 } 728 729 if (x->flags & EXC_FLAG_NODIR) { 730 if (match_basename(basename, 731 pathlen - (basename - pathname), 732 exclude, prefix, x->patternlen, 733 x->flags)) 734 return x; 735 continue; 736 } 737 738 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/'); 739 if (match_pathname(pathname, pathlen, 740 x->base, x->baselen ? x->baselen - 1 : 0, 741 exclude, prefix, x->patternlen, x->flags)) 742 return x; 743 } 744 return NULL; /* undecided */ 745} 746 747/* 748 * Scan the list and let the last match determine the fate. 749 * Return 1 for exclude, 0 for include and -1 for undecided. 750 */ 751int is_excluded_from_list(const char *pathname, 752 int pathlen, const char *basename, int *dtype, 753 struct exclude_list *el) 754{ 755 struct exclude *exclude; 756 exclude = last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el); 757 if (exclude) 758 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 759 return -1; /* undecided */ 760} 761 762static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir, 763 const char *pathname, int pathlen, const char *basename, 764 int *dtype_p) 765{ 766 int i, j; 767 struct exclude_list_group *group; 768 struct exclude *exclude; 769 for (i = EXC_CMDL; i <= EXC_FILE; i++) { 770 group = &dir->exclude_list_group[i]; 771 for (j = group->nr - 1; j >= 0; j--) { 772 exclude = last_exclude_matching_from_list( 773 pathname, pathlen, basename, dtype_p, 774 &group->el[j]); 775 if (exclude) 776 return exclude; 777 } 778 } 779 return NULL; 780} 781 782/* 783 * Loads the per-directory exclude list for the substring of base 784 * which has a char length of baselen. 785 */ 786static void prep_exclude(struct dir_struct *dir, const char *base, int baselen) 787{ 788 struct exclude_list_group *group; 789 struct exclude_list *el; 790 struct exclude_stack *stk = NULL; 791 int current; 792 793 group = &dir->exclude_list_group[EXC_DIRS]; 794 795 /* 796 * Pop the exclude lists from the EXCL_DIRS exclude_list_group 797 * which originate from directories not in the prefix of the 798 * path being checked. 799 */ 800 while ((stk = dir->exclude_stack) != NULL) { 801 if (stk->baselen <= baselen && 802 !strncmp(dir->basebuf.buf, base, stk->baselen)) 803 break; 804 el = &group->el[dir->exclude_stack->exclude_ix]; 805 dir->exclude_stack = stk->prev; 806 dir->exclude = NULL; 807 free((char *)el->src); /* see strbuf_detach() below */ 808 clear_exclude_list(el); 809 free(stk); 810 group->nr--; 811 } 812 813 /* Skip traversing into sub directories if the parent is excluded */ 814 if (dir->exclude) 815 return; 816 817 /* 818 * Lazy initialization. All call sites currently just 819 * memset(dir, 0, sizeof(*dir)) before use. Changing all of 820 * them seems lots of work for little benefit. 821 */ 822 if (!dir->basebuf.buf) 823 strbuf_init(&dir->basebuf, PATH_MAX); 824 825 /* Read from the parent directories and push them down. */ 826 current = stk ? stk->baselen : -1; 827 strbuf_setlen(&dir->basebuf, current < 0 ? 0 : current); 828 while (current < baselen) { 829 const char *cp; 830 831 stk = xcalloc(1, sizeof(*stk)); 832 if (current < 0) { 833 cp = base; 834 current = 0; 835 } else { 836 cp = strchr(base + current + 1, '/'); 837 if (!cp) 838 die("oops in prep_exclude"); 839 cp++; 840 } 841 stk->prev = dir->exclude_stack; 842 stk->baselen = cp - base; 843 stk->exclude_ix = group->nr; 844 el = add_exclude_list(dir, EXC_DIRS, NULL); 845 strbuf_add(&dir->basebuf, base + current, stk->baselen - current); 846 assert(stk->baselen == dir->basebuf.len); 847 848 /* Abort if the directory is excluded */ 849 if (stk->baselen) { 850 int dt = DT_DIR; 851 dir->basebuf.buf[stk->baselen - 1] = 0; 852 dir->exclude = last_exclude_matching_from_lists(dir, 853 dir->basebuf.buf, stk->baselen - 1, 854 dir->basebuf.buf + current, &dt); 855 dir->basebuf.buf[stk->baselen - 1] = '/'; 856 if (dir->exclude && 857 dir->exclude->flags & EXC_FLAG_NEGATIVE) 858 dir->exclude = NULL; 859 if (dir->exclude) { 860 dir->exclude_stack = stk; 861 return; 862 } 863 } 864 865 /* Try to read per-directory file */ 866 if (dir->exclude_per_dir) { 867 /* 868 * dir->basebuf gets reused by the traversal, but we 869 * need fname to remain unchanged to ensure the src 870 * member of each struct exclude correctly 871 * back-references its source file. Other invocations 872 * of add_exclude_list provide stable strings, so we 873 * strbuf_detach() and free() here in the caller. 874 */ 875 struct strbuf sb = STRBUF_INIT; 876 strbuf_addbuf(&sb, &dir->basebuf); 877 strbuf_addstr(&sb, dir->exclude_per_dir); 878 el->src = strbuf_detach(&sb, NULL); 879 add_excludes_from_file_to_list(el->src, el->src, 880 stk->baselen, el, 1); 881 } 882 dir->exclude_stack = stk; 883 current = stk->baselen; 884 } 885 strbuf_setlen(&dir->basebuf, baselen); 886} 887 888/* 889 * Loads the exclude lists for the directory containing pathname, then 890 * scans all exclude lists to determine whether pathname is excluded. 891 * Returns the exclude_list element which matched, or NULL for 892 * undecided. 893 */ 894struct exclude *last_exclude_matching(struct dir_struct *dir, 895 const char *pathname, 896 int *dtype_p) 897{ 898 int pathlen = strlen(pathname); 899 const char *basename = strrchr(pathname, '/'); 900 basename = (basename) ? basename+1 : pathname; 901 902 prep_exclude(dir, pathname, basename-pathname); 903 904 if (dir->exclude) 905 return dir->exclude; 906 907 return last_exclude_matching_from_lists(dir, pathname, pathlen, 908 basename, dtype_p); 909} 910 911/* 912 * Loads the exclude lists for the directory containing pathname, then 913 * scans all exclude lists to determine whether pathname is excluded. 914 * Returns 1 if true, otherwise 0. 915 */ 916int is_excluded(struct dir_struct *dir, const char *pathname, int *dtype_p) 917{ 918 struct exclude *exclude = 919 last_exclude_matching(dir, pathname, dtype_p); 920 if (exclude) 921 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 922 return 0; 923} 924 925static struct dir_entry *dir_entry_new(const char *pathname, int len) 926{ 927 struct dir_entry *ent; 928 929 ent = xmalloc(sizeof(*ent) + len + 1); 930 ent->len = len; 931 memcpy(ent->name, pathname, len); 932 ent->name[len] = 0; 933 return ent; 934} 935 936static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len) 937{ 938 if (cache_file_exists(pathname, len, ignore_case)) 939 return NULL; 940 941 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc); 942 return dir->entries[dir->nr++] = dir_entry_new(pathname, len); 943} 944 945struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len) 946{ 947 if (!cache_name_is_other(pathname, len)) 948 return NULL; 949 950 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc); 951 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len); 952} 953 954enum exist_status { 955 index_nonexistent = 0, 956 index_directory, 957 index_gitdir 958}; 959 960/* 961 * Do not use the alphabetically sorted index to look up 962 * the directory name; instead, use the case insensitive 963 * directory hash. 964 */ 965static enum exist_status directory_exists_in_index_icase(const char *dirname, int len) 966{ 967 const struct cache_entry *ce = cache_dir_exists(dirname, len); 968 unsigned char endchar; 969 970 if (!ce) 971 return index_nonexistent; 972 endchar = ce->name[len]; 973 974 /* 975 * The cache_entry structure returned will contain this dirname 976 * and possibly additional path components. 977 */ 978 if (endchar == '/') 979 return index_directory; 980 981 /* 982 * If there are no additional path components, then this cache_entry 983 * represents a submodule. Submodules, despite being directories, 984 * are stored in the cache without a closing slash. 985 */ 986 if (!endchar && S_ISGITLINK(ce->ce_mode)) 987 return index_gitdir; 988 989 /* This should never be hit, but it exists just in case. */ 990 return index_nonexistent; 991} 992 993/* 994 * The index sorts alphabetically by entry name, which 995 * means that a gitlink sorts as '\0' at the end, while 996 * a directory (which is defined not as an entry, but as 997 * the files it contains) will sort with the '/' at the 998 * end. 999 */1000static enum exist_status directory_exists_in_index(const char *dirname, int len)1001{1002 int pos;10031004 if (ignore_case)1005 return directory_exists_in_index_icase(dirname, len);10061007 pos = cache_name_pos(dirname, len);1008 if (pos < 0)1009 pos = -pos-1;1010 while (pos < active_nr) {1011 const struct cache_entry *ce = active_cache[pos++];1012 unsigned char endchar;10131014 if (strncmp(ce->name, dirname, len))1015 break;1016 endchar = ce->name[len];1017 if (endchar > '/')1018 break;1019 if (endchar == '/')1020 return index_directory;1021 if (!endchar && S_ISGITLINK(ce->ce_mode))1022 return index_gitdir;1023 }1024 return index_nonexistent;1025}10261027/*1028 * When we find a directory when traversing the filesystem, we1029 * have three distinct cases:1030 *1031 * - ignore it1032 * - see it as a directory1033 * - recurse into it1034 *1035 * and which one we choose depends on a combination of existing1036 * git index contents and the flags passed into the directory1037 * traversal routine.1038 *1039 * Case 1: If we *already* have entries in the index under that1040 * directory name, we always recurse into the directory to see1041 * all the files.1042 *1043 * Case 2: If we *already* have that directory name as a gitlink,1044 * we always continue to see it as a gitlink, regardless of whether1045 * there is an actual git directory there or not (it might not1046 * be checked out as a subproject!)1047 *1048 * Case 3: if we didn't have it in the index previously, we1049 * have a few sub-cases:1050 *1051 * (a) if "show_other_directories" is true, we show it as1052 * just a directory, unless "hide_empty_directories" is1053 * also true, in which case we need to check if it contains any1054 * untracked and / or ignored files.1055 * (b) if it looks like a git directory, and we don't have1056 * 'no_gitlinks' set we treat it as a gitlink, and show it1057 * as a directory.1058 * (c) otherwise, we recurse into it.1059 */1060static enum path_treatment treat_directory(struct dir_struct *dir,1061 const char *dirname, int len, int exclude,1062 const struct path_simplify *simplify)1063{1064 /* The "len-1" is to strip the final '/' */1065 switch (directory_exists_in_index(dirname, len-1)) {1066 case index_directory:1067 return path_recurse;10681069 case index_gitdir:1070 return path_none;10711072 case index_nonexistent:1073 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1074 break;1075 if (!(dir->flags & DIR_NO_GITLINKS)) {1076 unsigned char sha1[20];1077 if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)1078 return path_untracked;1079 }1080 return path_recurse;1081 }10821083 /* This is the "show_other_directories" case */10841085 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1086 return exclude ? path_excluded : path_untracked;10871088 return read_directory_recursive(dir, dirname, len, 1, simplify);1089}10901091/*1092 * This is an inexact early pruning of any recursive directory1093 * reading - if the path cannot possibly be in the pathspec,1094 * return true, and we'll skip it early.1095 */1096static int simplify_away(const char *path, int pathlen, const struct path_simplify *simplify)1097{1098 if (simplify) {1099 for (;;) {1100 const char *match = simplify->path;1101 int len = simplify->len;11021103 if (!match)1104 break;1105 if (len > pathlen)1106 len = pathlen;1107 if (!memcmp(path, match, len))1108 return 0;1109 simplify++;1110 }1111 return 1;1112 }1113 return 0;1114}11151116/*1117 * This function tells us whether an excluded path matches a1118 * list of "interesting" pathspecs. That is, whether a path matched1119 * by any of the pathspecs could possibly be ignored by excluding1120 * the specified path. This can happen if:1121 *1122 * 1. the path is mentioned explicitly in the pathspec1123 *1124 * 2. the path is a directory prefix of some element in the1125 * pathspec1126 */1127static int exclude_matches_pathspec(const char *path, int len,1128 const struct path_simplify *simplify)1129{1130 if (simplify) {1131 for (; simplify->path; simplify++) {1132 if (len == simplify->len1133 && !memcmp(path, simplify->path, len))1134 return 1;1135 if (len < simplify->len1136 && simplify->path[len] == '/'1137 && !memcmp(path, simplify->path, len))1138 return 1;1139 }1140 }1141 return 0;1142}11431144static int get_index_dtype(const char *path, int len)1145{1146 int pos;1147 const struct cache_entry *ce;11481149 ce = cache_file_exists(path, len, 0);1150 if (ce) {1151 if (!ce_uptodate(ce))1152 return DT_UNKNOWN;1153 if (S_ISGITLINK(ce->ce_mode))1154 return DT_DIR;1155 /*1156 * Nobody actually cares about the1157 * difference between DT_LNK and DT_REG1158 */1159 return DT_REG;1160 }11611162 /* Try to look it up as a directory */1163 pos = cache_name_pos(path, len);1164 if (pos >= 0)1165 return DT_UNKNOWN;1166 pos = -pos-1;1167 while (pos < active_nr) {1168 ce = active_cache[pos++];1169 if (strncmp(ce->name, path, len))1170 break;1171 if (ce->name[len] > '/')1172 break;1173 if (ce->name[len] < '/')1174 continue;1175 if (!ce_uptodate(ce))1176 break; /* continue? */1177 return DT_DIR;1178 }1179 return DT_UNKNOWN;1180}11811182static int get_dtype(struct dirent *de, const char *path, int len)1183{1184 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1185 struct stat st;11861187 if (dtype != DT_UNKNOWN)1188 return dtype;1189 dtype = get_index_dtype(path, len);1190 if (dtype != DT_UNKNOWN)1191 return dtype;1192 if (lstat(path, &st))1193 return dtype;1194 if (S_ISREG(st.st_mode))1195 return DT_REG;1196 if (S_ISDIR(st.st_mode))1197 return DT_DIR;1198 if (S_ISLNK(st.st_mode))1199 return DT_LNK;1200 return dtype;1201}12021203static enum path_treatment treat_one_path(struct dir_struct *dir,1204 struct strbuf *path,1205 const struct path_simplify *simplify,1206 int dtype, struct dirent *de)1207{1208 int exclude;1209 int has_path_in_index = !!cache_file_exists(path->buf, path->len, ignore_case);12101211 if (dtype == DT_UNKNOWN)1212 dtype = get_dtype(de, path->buf, path->len);12131214 /* Always exclude indexed files */1215 if (dtype != DT_DIR && has_path_in_index)1216 return path_none;12171218 /*1219 * When we are looking at a directory P in the working tree,1220 * there are three cases:1221 *1222 * (1) P exists in the index. Everything inside the directory P in1223 * the working tree needs to go when P is checked out from the1224 * index.1225 *1226 * (2) P does not exist in the index, but there is P/Q in the index.1227 * We know P will stay a directory when we check out the contents1228 * of the index, but we do not know yet if there is a directory1229 * P/Q in the working tree to be killed, so we need to recurse.1230 *1231 * (3) P does not exist in the index, and there is no P/Q in the index1232 * to require P to be a directory, either. Only in this case, we1233 * know that everything inside P will not be killed without1234 * recursing.1235 */1236 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1237 (dtype == DT_DIR) &&1238 !has_path_in_index &&1239 (directory_exists_in_index(path->buf, path->len) == index_nonexistent))1240 return path_none;12411242 exclude = is_excluded(dir, path->buf, &dtype);12431244 /*1245 * Excluded? If we don't explicitly want to show1246 * ignored files, ignore it1247 */1248 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1249 return path_excluded;12501251 switch (dtype) {1252 default:1253 return path_none;1254 case DT_DIR:1255 strbuf_addch(path, '/');1256 return treat_directory(dir, path->buf, path->len, exclude,1257 simplify);1258 case DT_REG:1259 case DT_LNK:1260 return exclude ? path_excluded : path_untracked;1261 }1262}12631264static enum path_treatment treat_path(struct dir_struct *dir,1265 struct dirent *de,1266 struct strbuf *path,1267 int baselen,1268 const struct path_simplify *simplify)1269{1270 int dtype;12711272 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))1273 return path_none;1274 strbuf_setlen(path, baselen);1275 strbuf_addstr(path, de->d_name);1276 if (simplify_away(path->buf, path->len, simplify))1277 return path_none;12781279 dtype = DTYPE(de);1280 return treat_one_path(dir, path, simplify, dtype, de);1281}12821283/*1284 * Read a directory tree. We currently ignore anything but1285 * directories, regular files and symlinks. That's because git1286 * doesn't handle them at all yet. Maybe that will change some1287 * day.1288 *1289 * Also, we ignore the name ".git" (even if it is not a directory).1290 * That likely will not change.1291 *1292 * Returns the most significant path_treatment value encountered in the scan.1293 */1294static enum path_treatment read_directory_recursive(struct dir_struct *dir,1295 const char *base, int baselen,1296 int check_only,1297 const struct path_simplify *simplify)1298{1299 DIR *fdir;1300 enum path_treatment state, subdir_state, dir_state = path_none;1301 struct dirent *de;1302 struct strbuf path = STRBUF_INIT;13031304 strbuf_add(&path, base, baselen);13051306 fdir = opendir(path.len ? path.buf : ".");1307 if (!fdir)1308 goto out;13091310 while ((de = readdir(fdir)) != NULL) {1311 /* check how the file or directory should be treated */1312 state = treat_path(dir, de, &path, baselen, simplify);1313 if (state > dir_state)1314 dir_state = state;13151316 /* recurse into subdir if instructed by treat_path */1317 if (state == path_recurse) {1318 subdir_state = read_directory_recursive(dir, path.buf,1319 path.len, check_only, simplify);1320 if (subdir_state > dir_state)1321 dir_state = subdir_state;1322 }13231324 if (check_only) {1325 /* abort early if maximum state has been reached */1326 if (dir_state == path_untracked)1327 break;1328 /* skip the dir_add_* part */1329 continue;1330 }13311332 /* add the path to the appropriate result list */1333 switch (state) {1334 case path_excluded:1335 if (dir->flags & DIR_SHOW_IGNORED)1336 dir_add_name(dir, path.buf, path.len);1337 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||1338 ((dir->flags & DIR_COLLECT_IGNORED) &&1339 exclude_matches_pathspec(path.buf, path.len,1340 simplify)))1341 dir_add_ignored(dir, path.buf, path.len);1342 break;13431344 case path_untracked:1345 if (!(dir->flags & DIR_SHOW_IGNORED))1346 dir_add_name(dir, path.buf, path.len);1347 break;13481349 default:1350 break;1351 }1352 }1353 closedir(fdir);1354 out:1355 strbuf_release(&path);13561357 return dir_state;1358}13591360static int cmp_name(const void *p1, const void *p2)1361{1362 const struct dir_entry *e1 = *(const struct dir_entry **)p1;1363 const struct dir_entry *e2 = *(const struct dir_entry **)p2;13641365 return name_compare(e1->name, e1->len, e2->name, e2->len);1366}13671368static struct path_simplify *create_simplify(const char **pathspec)1369{1370 int nr, alloc = 0;1371 struct path_simplify *simplify = NULL;13721373 if (!pathspec)1374 return NULL;13751376 for (nr = 0 ; ; nr++) {1377 const char *match;1378 ALLOC_GROW(simplify, nr + 1, alloc);1379 match = *pathspec++;1380 if (!match)1381 break;1382 simplify[nr].path = match;1383 simplify[nr].len = simple_length(match);1384 }1385 simplify[nr].path = NULL;1386 simplify[nr].len = 0;1387 return simplify;1388}13891390static void free_simplify(struct path_simplify *simplify)1391{1392 free(simplify);1393}13941395static int treat_leading_path(struct dir_struct *dir,1396 const char *path, int len,1397 const struct path_simplify *simplify)1398{1399 struct strbuf sb = STRBUF_INIT;1400 int baselen, rc = 0;1401 const char *cp;1402 int old_flags = dir->flags;14031404 while (len && path[len - 1] == '/')1405 len--;1406 if (!len)1407 return 1;1408 baselen = 0;1409 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1410 while (1) {1411 cp = path + baselen + !!baselen;1412 cp = memchr(cp, '/', path + len - cp);1413 if (!cp)1414 baselen = len;1415 else1416 baselen = cp - path;1417 strbuf_setlen(&sb, 0);1418 strbuf_add(&sb, path, baselen);1419 if (!is_directory(sb.buf))1420 break;1421 if (simplify_away(sb.buf, sb.len, simplify))1422 break;1423 if (treat_one_path(dir, &sb, simplify,1424 DT_DIR, NULL) == path_none)1425 break; /* do not recurse into it */1426 if (len <= baselen) {1427 rc = 1;1428 break; /* finished checking */1429 }1430 }1431 strbuf_release(&sb);1432 dir->flags = old_flags;1433 return rc;1434}14351436int read_directory(struct dir_struct *dir, const char *path, int len, const struct pathspec *pathspec)1437{1438 struct path_simplify *simplify;14391440 /*1441 * Check out create_simplify()1442 */1443 if (pathspec)1444 GUARD_PATHSPEC(pathspec,1445 PATHSPEC_FROMTOP |1446 PATHSPEC_MAXDEPTH |1447 PATHSPEC_LITERAL |1448 PATHSPEC_GLOB |1449 PATHSPEC_ICASE |1450 PATHSPEC_EXCLUDE);14511452 if (has_symlink_leading_path(path, len))1453 return dir->nr;14541455 /*1456 * exclude patterns are treated like positive ones in1457 * create_simplify. Usually exclude patterns should be a1458 * subset of positive ones, which has no impacts on1459 * create_simplify().1460 */1461 simplify = create_simplify(pathspec ? pathspec->_raw : NULL);1462 if (!len || treat_leading_path(dir, path, len, simplify))1463 read_directory_recursive(dir, path, len, 0, simplify);1464 free_simplify(simplify);1465 qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);1466 qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);1467 return dir->nr;1468}14691470int file_exists(const char *f)1471{1472 struct stat sb;1473 return lstat(f, &sb) == 0;1474}14751476/*1477 * Given two normalized paths (a trailing slash is ok), if subdir is1478 * outside dir, return -1. Otherwise return the offset in subdir that1479 * can be used as relative path to dir.1480 */1481int dir_inside_of(const char *subdir, const char *dir)1482{1483 int offset = 0;14841485 assert(dir && subdir && *dir && *subdir);14861487 while (*dir && *subdir && *dir == *subdir) {1488 dir++;1489 subdir++;1490 offset++;1491 }14921493 /* hel[p]/me vs hel[l]/yeah */1494 if (*dir && *subdir)1495 return -1;14961497 if (!*subdir)1498 return !*dir ? offset : -1; /* same dir */14991500 /* foo/[b]ar vs foo/[] */1501 if (is_dir_sep(dir[-1]))1502 return is_dir_sep(subdir[-1]) ? offset : -1;15031504 /* foo[/]bar vs foo[] */1505 return is_dir_sep(*subdir) ? offset + 1 : -1;1506}15071508int is_inside_dir(const char *dir)1509{1510 char *cwd;1511 int rc;15121513 if (!dir)1514 return 0;15151516 cwd = xgetcwd();1517 rc = (dir_inside_of(cwd, dir) >= 0);1518 free(cwd);1519 return rc;1520}15211522int is_empty_dir(const char *path)1523{1524 DIR *dir = opendir(path);1525 struct dirent *e;1526 int ret = 1;15271528 if (!dir)1529 return 0;15301531 while ((e = readdir(dir)) != NULL)1532 if (!is_dot_or_dotdot(e->d_name)) {1533 ret = 0;1534 break;1535 }15361537 closedir(dir);1538 return ret;1539}15401541static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)1542{1543 DIR *dir;1544 struct dirent *e;1545 int ret = 0, original_len = path->len, len, kept_down = 0;1546 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);1547 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);1548 unsigned char submodule_head[20];15491550 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&1551 !resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {1552 /* Do not descend and nuke a nested git work tree. */1553 if (kept_up)1554 *kept_up = 1;1555 return 0;1556 }15571558 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;1559 dir = opendir(path->buf);1560 if (!dir) {1561 if (errno == ENOENT)1562 return keep_toplevel ? -1 : 0;1563 else if (errno == EACCES && !keep_toplevel)1564 /*1565 * An empty dir could be removable even if it1566 * is unreadable:1567 */1568 return rmdir(path->buf);1569 else1570 return -1;1571 }1572 if (path->buf[original_len - 1] != '/')1573 strbuf_addch(path, '/');15741575 len = path->len;1576 while ((e = readdir(dir)) != NULL) {1577 struct stat st;1578 if (is_dot_or_dotdot(e->d_name))1579 continue;15801581 strbuf_setlen(path, len);1582 strbuf_addstr(path, e->d_name);1583 if (lstat(path->buf, &st)) {1584 if (errno == ENOENT)1585 /*1586 * file disappeared, which is what we1587 * wanted anyway1588 */1589 continue;1590 /* fall thru */1591 } else if (S_ISDIR(st.st_mode)) {1592 if (!remove_dir_recurse(path, flag, &kept_down))1593 continue; /* happy */1594 } else if (!only_empty &&1595 (!unlink(path->buf) || errno == ENOENT)) {1596 continue; /* happy, too */1597 }15981599 /* path too long, stat fails, or non-directory still exists */1600 ret = -1;1601 break;1602 }1603 closedir(dir);16041605 strbuf_setlen(path, original_len);1606 if (!ret && !keep_toplevel && !kept_down)1607 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;1608 else if (kept_up)1609 /*1610 * report the uplevel that it is not an error that we1611 * did not rmdir() our directory.1612 */1613 *kept_up = !ret;1614 return ret;1615}16161617int remove_dir_recursively(struct strbuf *path, int flag)1618{1619 return remove_dir_recurse(path, flag, NULL);1620}16211622void setup_standard_excludes(struct dir_struct *dir)1623{1624 const char *path;1625 char *xdg_path;16261627 dir->exclude_per_dir = ".gitignore";1628 path = git_path("info/exclude");1629 if (!excludes_file) {1630 home_config_paths(NULL, &xdg_path, "ignore");1631 excludes_file = xdg_path;1632 }1633 if (!access_or_warn(path, R_OK, 0))1634 add_excludes_from_file(dir, path);1635 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))1636 add_excludes_from_file(dir, excludes_file);1637}16381639int remove_path(const char *name)1640{1641 char *slash;16421643 if (unlink(name) && errno != ENOENT && errno != ENOTDIR)1644 return -1;16451646 slash = strrchr(name, '/');1647 if (slash) {1648 char *dirs = xstrdup(name);1649 slash = dirs + (slash - name);1650 do {1651 *slash = '\0';1652 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));1653 free(dirs);1654 }1655 return 0;1656}16571658/*1659 * Frees memory within dir which was allocated for exclude lists and1660 * the exclude_stack. Does not free dir itself.1661 */1662void clear_directory(struct dir_struct *dir)1663{1664 int i, j;1665 struct exclude_list_group *group;1666 struct exclude_list *el;1667 struct exclude_stack *stk;16681669 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1670 group = &dir->exclude_list_group[i];1671 for (j = 0; j < group->nr; j++) {1672 el = &group->el[j];1673 if (i == EXC_DIRS)1674 free((char *)el->src);1675 clear_exclude_list(el);1676 }1677 free(group->el);1678 }16791680 stk = dir->exclude_stack;1681 while (stk) {1682 struct exclude_stack *prev = stk->prev;1683 free(stk);1684 stk = prev;1685 }1686 strbuf_release(&dir->basebuf);1687}