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 fnmatch(pattern, string, flags | (ignore_case ? FNM_CASEFOLD : 0)); 53} 54 55inline int git_fnmatch(const struct pathspec_item *item, 56 const char *pattern, const char *string, 57 int prefix) 58{ 59 if (prefix > 0) { 60 if (ps_strncmp(item, pattern, string, prefix)) 61 return FNM_NOMATCH; 62 pattern += prefix; 63 string += prefix; 64 } 65 if (item->flags & PATHSPEC_ONESTAR) { 66 int pattern_len = strlen(++pattern); 67 int string_len = strlen(string); 68 return string_len < pattern_len || 69 ps_strcmp(item, pattern, 70 string + string_len - pattern_len); 71 } 72 if (item->magic & PATHSPEC_GLOB) 73 return wildmatch(pattern, string, 74 WM_PATHNAME | 75 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0), 76 NULL); 77 else 78 /* wildmatch has not learned no FNM_PATHNAME mode yet */ 79 return fnmatch(pattern, string, 80 item->magic & PATHSPEC_ICASE ? FNM_CASEFOLD : 0); 81} 82 83static int fnmatch_icase_mem(const char *pattern, int patternlen, 84 const char *string, int stringlen, 85 int flags) 86{ 87 int match_status; 88 struct strbuf pat_buf = STRBUF_INIT; 89 struct strbuf str_buf = STRBUF_INIT; 90 const char *use_pat = pattern; 91 const char *use_str = string; 92 93 if (pattern[patternlen]) { 94 strbuf_add(&pat_buf, pattern, patternlen); 95 use_pat = pat_buf.buf; 96 } 97 if (string[stringlen]) { 98 strbuf_add(&str_buf, string, stringlen); 99 use_str = str_buf.buf; 100 } 101 102 if (ignore_case) 103 flags |= WM_CASEFOLD; 104 match_status = wildmatch(use_pat, use_str, flags, NULL); 105 106 strbuf_release(&pat_buf); 107 strbuf_release(&str_buf); 108 109 return match_status; 110} 111 112static size_t common_prefix_len(const struct pathspec *pathspec) 113{ 114 int n; 115 size_t max = 0; 116 117 /* 118 * ":(icase)path" is treated as a pathspec full of 119 * wildcard. In other words, only prefix is considered common 120 * prefix. If the pathspec is abc/foo abc/bar, running in 121 * subdir xyz, the common prefix is still xyz, not xuz/abc as 122 * in non-:(icase). 123 */ 124 GUARD_PATHSPEC(pathspec, 125 PATHSPEC_FROMTOP | 126 PATHSPEC_MAXDEPTH | 127 PATHSPEC_LITERAL | 128 PATHSPEC_GLOB | 129 PATHSPEC_ICASE | 130 PATHSPEC_EXCLUDE); 131 132 for (n = 0; n < pathspec->nr; n++) { 133 size_t i = 0, len = 0, item_len; 134 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE) 135 continue; 136 if (pathspec->items[n].magic & PATHSPEC_ICASE) 137 item_len = pathspec->items[n].prefix; 138 else 139 item_len = pathspec->items[n].nowildcard_len; 140 while (i < item_len && (n == 0 || i < max)) { 141 char c = pathspec->items[n].match[i]; 142 if (c != pathspec->items[0].match[i]) 143 break; 144 if (c == '/') 145 len = i + 1; 146 i++; 147 } 148 if (n == 0 || len < max) { 149 max = len; 150 if (!max) 151 break; 152 } 153 } 154 return max; 155} 156 157/* 158 * Returns a copy of the longest leading path common among all 159 * pathspecs. 160 */ 161char *common_prefix(const struct pathspec *pathspec) 162{ 163 unsigned long len = common_prefix_len(pathspec); 164 165 return len ? xmemdupz(pathspec->items[0].match, len) : NULL; 166} 167 168int fill_directory(struct dir_struct *dir, const struct pathspec *pathspec) 169{ 170 size_t len; 171 172 /* 173 * Calculate common prefix for the pathspec, and 174 * use that to optimize the directory walk 175 */ 176 len = common_prefix_len(pathspec); 177 178 /* Read the directory and prune it */ 179 read_directory(dir, pathspec->nr ? pathspec->_raw[0] : "", len, pathspec); 180 return len; 181} 182 183int within_depth(const char *name, int namelen, 184 int depth, int max_depth) 185{ 186 const char *cp = name, *cpe = name + namelen; 187 188 while (cp < cpe) { 189 if (*cp++ != '/') 190 continue; 191 depth++; 192 if (depth > max_depth) 193 return 0; 194 } 195 return 1; 196} 197 198#define DO_MATCH_EXCLUDE 1 199 200/* 201 * Does 'match' match the given name? 202 * A match is found if 203 * 204 * (1) the 'match' string is leading directory of 'name', or 205 * (2) the 'match' string is a wildcard and matches 'name', or 206 * (3) the 'match' string is exactly the same as 'name'. 207 * 208 * and the return value tells which case it was. 209 * 210 * It returns 0 when there is no match. 211 */ 212static int match_pathspec_item(const struct pathspec_item *item, int prefix, 213 const char *name, int namelen, unsigned flags) 214{ 215 /* name/namelen has prefix cut off by caller */ 216 const char *match = item->match + prefix; 217 int matchlen = item->len - prefix; 218 219 /* 220 * The normal call pattern is: 221 * 1. prefix = common_prefix_len(ps); 222 * 2. prune something, or fill_directory 223 * 3. match_pathspec() 224 * 225 * 'prefix' at #1 may be shorter than the command's prefix and 226 * it's ok for #2 to match extra files. Those extras will be 227 * trimmed at #3. 228 * 229 * Suppose the pathspec is 'foo' and '../bar' running from 230 * subdir 'xyz'. The common prefix at #1 will be empty, thanks 231 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The 232 * user does not want XYZ/foo, only the "foo" part should be 233 * case-insensitive. We need to filter out XYZ/foo here. In 234 * other words, we do not trust the caller on comparing the 235 * prefix part when :(icase) is involved. We do exact 236 * comparison ourselves. 237 * 238 * Normally the caller (common_prefix_len() in fact) does 239 * _exact_ matching on name[-prefix+1..-1] and we do not need 240 * to check that part. Be defensive and check it anyway, in 241 * case common_prefix_len is changed, or a new caller is 242 * introduced that does not use common_prefix_len. 243 * 244 * If the penalty turns out too high when prefix is really 245 * long, maybe change it to 246 * strncmp(match, name, item->prefix - prefix) 247 */ 248 if (item->prefix && (item->magic & PATHSPEC_ICASE) && 249 strncmp(item->match, name - prefix, item->prefix)) 250 return 0; 251 252 /* If the match was just the prefix, we matched */ 253 if (!*match) 254 return MATCHED_RECURSIVELY; 255 256 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) { 257 if (matchlen == namelen) 258 return MATCHED_EXACTLY; 259 260 if (match[matchlen-1] == '/' || name[matchlen] == '/') 261 return MATCHED_RECURSIVELY; 262 } 263 264 if (item->nowildcard_len < item->len && 265 !git_fnmatch(item, match, name, 266 item->nowildcard_len - prefix)) 267 return MATCHED_FNMATCH; 268 269 return 0; 270} 271 272/* 273 * Given a name and a list of pathspecs, returns the nature of the 274 * closest (i.e. most specific) match of the name to any of the 275 * pathspecs. 276 * 277 * The caller typically calls this multiple times with the same 278 * pathspec and seen[] array but with different name/namelen 279 * (e.g. entries from the index) and is interested in seeing if and 280 * how each pathspec matches all the names it calls this function 281 * with. A mark is left in the seen[] array for each pathspec element 282 * indicating the closest type of match that element achieved, so if 283 * seen[n] remains zero after multiple invocations, that means the nth 284 * pathspec did not match any names, which could indicate that the 285 * user mistyped the nth pathspec. 286 */ 287static int do_match_pathspec(const struct pathspec *ps, 288 const char *name, int namelen, 289 int prefix, char *seen, 290 unsigned flags) 291{ 292 int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE; 293 294 GUARD_PATHSPEC(ps, 295 PATHSPEC_FROMTOP | 296 PATHSPEC_MAXDEPTH | 297 PATHSPEC_LITERAL | 298 PATHSPEC_GLOB | 299 PATHSPEC_ICASE | 300 PATHSPEC_EXCLUDE); 301 302 if (!ps->nr) { 303 if (!ps->recursive || 304 !(ps->magic & PATHSPEC_MAXDEPTH) || 305 ps->max_depth == -1) 306 return MATCHED_RECURSIVELY; 307 308 if (within_depth(name, namelen, 0, ps->max_depth)) 309 return MATCHED_EXACTLY; 310 else 311 return 0; 312 } 313 314 name += prefix; 315 namelen -= prefix; 316 317 for (i = ps->nr - 1; i >= 0; i--) { 318 int how; 319 320 if ((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) || 321 ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE))) 322 continue; 323 324 if (seen && seen[i] == MATCHED_EXACTLY) 325 continue; 326 /* 327 * Make exclude patterns optional and never report 328 * "pathspec ':(exclude)foo' matches no files" 329 */ 330 if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE) 331 seen[i] = MATCHED_FNMATCH; 332 how = match_pathspec_item(ps->items+i, prefix, name, 333 namelen, flags); 334 if (ps->recursive && 335 (ps->magic & PATHSPEC_MAXDEPTH) && 336 ps->max_depth != -1 && 337 how && how != MATCHED_FNMATCH) { 338 int len = ps->items[i].len; 339 if (name[len] == '/') 340 len++; 341 if (within_depth(name+len, namelen-len, 0, ps->max_depth)) 342 how = MATCHED_EXACTLY; 343 else 344 how = 0; 345 } 346 if (how) { 347 if (retval < how) 348 retval = how; 349 if (seen && seen[i] < how) 350 seen[i] = how; 351 } 352 } 353 return retval; 354} 355 356int match_pathspec(const struct pathspec *ps, 357 const char *name, int namelen, 358 int prefix, char *seen) 359{ 360 int positive, negative; 361 unsigned flags = 0; 362 positive = do_match_pathspec(ps, name, namelen, 363 prefix, seen, flags); 364 if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive) 365 return positive; 366 negative = do_match_pathspec(ps, name, namelen, 367 prefix, seen, 368 flags | DO_MATCH_EXCLUDE); 369 return negative ? 0 : positive; 370} 371 372/* 373 * Return the length of the "simple" part of a path match limiter. 374 */ 375int simple_length(const char *match) 376{ 377 int len = -1; 378 379 for (;;) { 380 unsigned char c = *match++; 381 len++; 382 if (c == '\0' || is_glob_special(c)) 383 return len; 384 } 385} 386 387int no_wildcard(const char *string) 388{ 389 return string[simple_length(string)] == '\0'; 390} 391 392void parse_exclude_pattern(const char **pattern, 393 int *patternlen, 394 int *flags, 395 int *nowildcardlen) 396{ 397 const char *p = *pattern; 398 size_t i, len; 399 400 *flags = 0; 401 if (*p == '!') { 402 *flags |= EXC_FLAG_NEGATIVE; 403 p++; 404 } 405 len = strlen(p); 406 if (len && p[len - 1] == '/') { 407 len--; 408 *flags |= EXC_FLAG_MUSTBEDIR; 409 } 410 for (i = 0; i < len; i++) { 411 if (p[i] == '/') 412 break; 413 } 414 if (i == len) 415 *flags |= EXC_FLAG_NODIR; 416 *nowildcardlen = simple_length(p); 417 /* 418 * we should have excluded the trailing slash from 'p' too, 419 * but that's one more allocation. Instead just make sure 420 * nowildcardlen does not exceed real patternlen 421 */ 422 if (*nowildcardlen > len) 423 *nowildcardlen = len; 424 if (*p == '*' && no_wildcard(p + 1)) 425 *flags |= EXC_FLAG_ENDSWITH; 426 *pattern = p; 427 *patternlen = len; 428} 429 430void add_exclude(const char *string, const char *base, 431 int baselen, struct exclude_list *el, int srcpos) 432{ 433 struct exclude *x; 434 int patternlen; 435 int flags; 436 int nowildcardlen; 437 438 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); 439 if (flags & EXC_FLAG_MUSTBEDIR) { 440 char *s; 441 x = xmalloc(sizeof(*x) + patternlen + 1); 442 s = (char *)(x+1); 443 memcpy(s, string, patternlen); 444 s[patternlen] = '\0'; 445 x->pattern = s; 446 } else { 447 x = xmalloc(sizeof(*x)); 448 x->pattern = string; 449 } 450 x->patternlen = patternlen; 451 x->nowildcardlen = nowildcardlen; 452 x->base = base; 453 x->baselen = baselen; 454 x->flags = flags; 455 x->srcpos = srcpos; 456 ALLOC_GROW(el->excludes, el->nr + 1, el->alloc); 457 el->excludes[el->nr++] = x; 458 x->el = el; 459} 460 461static void *read_skip_worktree_file_from_index(const char *path, size_t *size) 462{ 463 int pos, len; 464 unsigned long sz; 465 enum object_type type; 466 void *data; 467 468 len = strlen(path); 469 pos = cache_name_pos(path, len); 470 if (pos < 0) 471 return NULL; 472 if (!ce_skip_worktree(active_cache[pos])) 473 return NULL; 474 data = read_sha1_file(active_cache[pos]->sha1, &type, &sz); 475 if (!data || type != OBJ_BLOB) { 476 free(data); 477 return NULL; 478 } 479 *size = xsize_t(sz); 480 return data; 481} 482 483/* 484 * Frees memory within el which was allocated for exclude patterns and 485 * the file buffer. Does not free el itself. 486 */ 487void clear_exclude_list(struct exclude_list *el) 488{ 489 int i; 490 491 for (i = 0; i < el->nr; i++) 492 free(el->excludes[i]); 493 free(el->excludes); 494 free(el->filebuf); 495 496 el->nr = 0; 497 el->excludes = NULL; 498 el->filebuf = NULL; 499} 500 501int add_excludes_from_file_to_list(const char *fname, 502 const char *base, 503 int baselen, 504 struct exclude_list *el, 505 int check_index) 506{ 507 struct stat st; 508 int fd, i, lineno = 1; 509 size_t size = 0; 510 char *buf, *entry; 511 512 fd = open(fname, O_RDONLY); 513 if (fd < 0 || fstat(fd, &st) < 0) { 514 if (errno != ENOENT) 515 warn_on_inaccessible(fname); 516 if (0 <= fd) 517 close(fd); 518 if (!check_index || 519 (buf = read_skip_worktree_file_from_index(fname, &size)) == NULL) 520 return -1; 521 if (size == 0) { 522 free(buf); 523 return 0; 524 } 525 if (buf[size-1] != '\n') { 526 buf = xrealloc(buf, size+1); 527 buf[size++] = '\n'; 528 } 529 } 530 else { 531 size = xsize_t(st.st_size); 532 if (size == 0) { 533 close(fd); 534 return 0; 535 } 536 buf = xmalloc(size+1); 537 if (read_in_full(fd, buf, size) != size) { 538 free(buf); 539 close(fd); 540 return -1; 541 } 542 buf[size++] = '\n'; 543 close(fd); 544 } 545 546 el->filebuf = buf; 547 entry = buf; 548 for (i = 0; i < size; i++) { 549 if (buf[i] == '\n') { 550 if (entry != buf + i && entry[0] != '#') { 551 buf[i - (i && buf[i-1] == '\r')] = 0; 552 add_exclude(entry, base, baselen, el, lineno); 553 } 554 lineno++; 555 entry = buf + i + 1; 556 } 557 } 558 return 0; 559} 560 561struct exclude_list *add_exclude_list(struct dir_struct *dir, 562 int group_type, const char *src) 563{ 564 struct exclude_list *el; 565 struct exclude_list_group *group; 566 567 group = &dir->exclude_list_group[group_type]; 568 ALLOC_GROW(group->el, group->nr + 1, group->alloc); 569 el = &group->el[group->nr++]; 570 memset(el, 0, sizeof(*el)); 571 el->src = src; 572 return el; 573} 574 575/* 576 * Used to set up core.excludesfile and .git/info/exclude lists. 577 */ 578void add_excludes_from_file(struct dir_struct *dir, const char *fname) 579{ 580 struct exclude_list *el; 581 el = add_exclude_list(dir, EXC_FILE, fname); 582 if (add_excludes_from_file_to_list(fname, "", 0, el, 0) < 0) 583 die("cannot use %s as an exclude file", fname); 584} 585 586int match_basename(const char *basename, int basenamelen, 587 const char *pattern, int prefix, int patternlen, 588 int flags) 589{ 590 if (prefix == patternlen) { 591 if (patternlen == basenamelen && 592 !strncmp_icase(pattern, basename, basenamelen)) 593 return 1; 594 } else if (flags & EXC_FLAG_ENDSWITH) { 595 /* "*literal" matching against "fooliteral" */ 596 if (patternlen - 1 <= basenamelen && 597 !strncmp_icase(pattern + 1, 598 basename + basenamelen - (patternlen - 1), 599 patternlen - 1)) 600 return 1; 601 } else { 602 if (fnmatch_icase_mem(pattern, patternlen, 603 basename, basenamelen, 604 0) == 0) 605 return 1; 606 } 607 return 0; 608} 609 610int match_pathname(const char *pathname, int pathlen, 611 const char *base, int baselen, 612 const char *pattern, int prefix, int patternlen, 613 int flags) 614{ 615 const char *name; 616 int namelen; 617 618 /* 619 * match with FNM_PATHNAME; the pattern has base implicitly 620 * in front of it. 621 */ 622 if (*pattern == '/') { 623 pattern++; 624 patternlen--; 625 prefix--; 626 } 627 628 /* 629 * baselen does not count the trailing slash. base[] may or 630 * may not end with a trailing slash though. 631 */ 632 if (pathlen < baselen + 1 || 633 (baselen && pathname[baselen] != '/') || 634 strncmp_icase(pathname, base, baselen)) 635 return 0; 636 637 namelen = baselen ? pathlen - baselen - 1 : pathlen; 638 name = pathname + pathlen - namelen; 639 640 if (prefix) { 641 /* 642 * if the non-wildcard part is longer than the 643 * remaining pathname, surely it cannot match. 644 */ 645 if (prefix > namelen) 646 return 0; 647 648 if (strncmp_icase(pattern, name, prefix)) 649 return 0; 650 pattern += prefix; 651 patternlen -= prefix; 652 name += prefix; 653 namelen -= prefix; 654 655 /* 656 * If the whole pattern did not have a wildcard, 657 * then our prefix match is all we need; we 658 * do not need to call fnmatch at all. 659 */ 660 if (!patternlen && !namelen) 661 return 1; 662 } 663 664 return fnmatch_icase_mem(pattern, patternlen, 665 name, namelen, 666 WM_PATHNAME) == 0; 667} 668 669/* 670 * Scan the given exclude list in reverse to see whether pathname 671 * should be ignored. The first match (i.e. the last on the list), if 672 * any, determines the fate. Returns the exclude_list element which 673 * matched, or NULL for undecided. 674 */ 675static struct exclude *last_exclude_matching_from_list(const char *pathname, 676 int pathlen, 677 const char *basename, 678 int *dtype, 679 struct exclude_list *el) 680{ 681 int i; 682 683 if (!el->nr) 684 return NULL; /* undefined */ 685 686 for (i = el->nr - 1; 0 <= i; i--) { 687 struct exclude *x = el->excludes[i]; 688 const char *exclude = x->pattern; 689 int prefix = x->nowildcardlen; 690 691 if (x->flags & EXC_FLAG_MUSTBEDIR) { 692 if (*dtype == DT_UNKNOWN) 693 *dtype = get_dtype(NULL, pathname, pathlen); 694 if (*dtype != DT_DIR) 695 continue; 696 } 697 698 if (x->flags & EXC_FLAG_NODIR) { 699 if (match_basename(basename, 700 pathlen - (basename - pathname), 701 exclude, prefix, x->patternlen, 702 x->flags)) 703 return x; 704 continue; 705 } 706 707 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/'); 708 if (match_pathname(pathname, pathlen, 709 x->base, x->baselen ? x->baselen - 1 : 0, 710 exclude, prefix, x->patternlen, x->flags)) 711 return x; 712 } 713 return NULL; /* undecided */ 714} 715 716/* 717 * Scan the list and let the last match determine the fate. 718 * Return 1 for exclude, 0 for include and -1 for undecided. 719 */ 720int is_excluded_from_list(const char *pathname, 721 int pathlen, const char *basename, int *dtype, 722 struct exclude_list *el) 723{ 724 struct exclude *exclude; 725 exclude = last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el); 726 if (exclude) 727 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 728 return -1; /* undecided */ 729} 730 731static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir, 732 const char *pathname, int pathlen, const char *basename, 733 int *dtype_p) 734{ 735 int i, j; 736 struct exclude_list_group *group; 737 struct exclude *exclude; 738 for (i = EXC_CMDL; i <= EXC_FILE; i++) { 739 group = &dir->exclude_list_group[i]; 740 for (j = group->nr - 1; j >= 0; j--) { 741 exclude = last_exclude_matching_from_list( 742 pathname, pathlen, basename, dtype_p, 743 &group->el[j]); 744 if (exclude) 745 return exclude; 746 } 747 } 748 return NULL; 749} 750 751/* 752 * Loads the per-directory exclude list for the substring of base 753 * which has a char length of baselen. 754 */ 755static void prep_exclude(struct dir_struct *dir, const char *base, int baselen) 756{ 757 struct exclude_list_group *group; 758 struct exclude_list *el; 759 struct exclude_stack *stk = NULL; 760 int current; 761 762 group = &dir->exclude_list_group[EXC_DIRS]; 763 764 /* Pop the exclude lists from the EXCL_DIRS exclude_list_group 765 * which originate from directories not in the prefix of the 766 * path being checked. */ 767 while ((stk = dir->exclude_stack) != NULL) { 768 if (stk->baselen <= baselen && 769 !strncmp(dir->basebuf, base, stk->baselen)) 770 break; 771 el = &group->el[dir->exclude_stack->exclude_ix]; 772 dir->exclude_stack = stk->prev; 773 dir->exclude = NULL; 774 free((char *)el->src); /* see strdup() below */ 775 clear_exclude_list(el); 776 free(stk); 777 group->nr--; 778 } 779 780 /* Skip traversing into sub directories if the parent is excluded */ 781 if (dir->exclude) 782 return; 783 784 /* Read from the parent directories and push them down. */ 785 current = stk ? stk->baselen : -1; 786 while (current < baselen) { 787 struct exclude_stack *stk = xcalloc(1, sizeof(*stk)); 788 const char *cp; 789 790 if (current < 0) { 791 cp = base; 792 current = 0; 793 } 794 else { 795 cp = strchr(base + current + 1, '/'); 796 if (!cp) 797 die("oops in prep_exclude"); 798 cp++; 799 } 800 stk->prev = dir->exclude_stack; 801 stk->baselen = cp - base; 802 stk->exclude_ix = group->nr; 803 el = add_exclude_list(dir, EXC_DIRS, NULL); 804 memcpy(dir->basebuf + current, base + current, 805 stk->baselen - current); 806 807 /* Abort if the directory is excluded */ 808 if (stk->baselen) { 809 int dt = DT_DIR; 810 dir->basebuf[stk->baselen - 1] = 0; 811 dir->exclude = last_exclude_matching_from_lists(dir, 812 dir->basebuf, stk->baselen - 1, 813 dir->basebuf + current, &dt); 814 dir->basebuf[stk->baselen - 1] = '/'; 815 if (dir->exclude && 816 dir->exclude->flags & EXC_FLAG_NEGATIVE) 817 dir->exclude = NULL; 818 if (dir->exclude) { 819 dir->basebuf[stk->baselen] = 0; 820 dir->exclude_stack = stk; 821 return; 822 } 823 } 824 825 /* Try to read per-directory file unless path is too long */ 826 if (dir->exclude_per_dir && 827 stk->baselen + strlen(dir->exclude_per_dir) < PATH_MAX) { 828 strcpy(dir->basebuf + stk->baselen, 829 dir->exclude_per_dir); 830 /* 831 * dir->basebuf gets reused by the traversal, but we 832 * need fname to remain unchanged to ensure the src 833 * member of each struct exclude correctly 834 * back-references its source file. Other invocations 835 * of add_exclude_list provide stable strings, so we 836 * strdup() and free() here in the caller. 837 */ 838 el->src = strdup(dir->basebuf); 839 add_excludes_from_file_to_list(dir->basebuf, 840 dir->basebuf, stk->baselen, el, 1); 841 } 842 dir->exclude_stack = stk; 843 current = stk->baselen; 844 } 845 dir->basebuf[baselen] = '\0'; 846} 847 848/* 849 * Loads the exclude lists for the directory containing pathname, then 850 * scans all exclude lists to determine whether pathname is excluded. 851 * Returns the exclude_list element which matched, or NULL for 852 * undecided. 853 */ 854struct exclude *last_exclude_matching(struct dir_struct *dir, 855 const char *pathname, 856 int *dtype_p) 857{ 858 int pathlen = strlen(pathname); 859 const char *basename = strrchr(pathname, '/'); 860 basename = (basename) ? basename+1 : pathname; 861 862 prep_exclude(dir, pathname, basename-pathname); 863 864 if (dir->exclude) 865 return dir->exclude; 866 867 return last_exclude_matching_from_lists(dir, pathname, pathlen, 868 basename, dtype_p); 869} 870 871/* 872 * Loads the exclude lists for the directory containing pathname, then 873 * scans all exclude lists to determine whether pathname is excluded. 874 * Returns 1 if true, otherwise 0. 875 */ 876int is_excluded(struct dir_struct *dir, const char *pathname, int *dtype_p) 877{ 878 struct exclude *exclude = 879 last_exclude_matching(dir, pathname, dtype_p); 880 if (exclude) 881 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; 882 return 0; 883} 884 885static struct dir_entry *dir_entry_new(const char *pathname, int len) 886{ 887 struct dir_entry *ent; 888 889 ent = xmalloc(sizeof(*ent) + len + 1); 890 ent->len = len; 891 memcpy(ent->name, pathname, len); 892 ent->name[len] = 0; 893 return ent; 894} 895 896static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len) 897{ 898 if (cache_file_exists(pathname, len, ignore_case)) 899 return NULL; 900 901 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc); 902 return dir->entries[dir->nr++] = dir_entry_new(pathname, len); 903} 904 905struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len) 906{ 907 if (!cache_name_is_other(pathname, len)) 908 return NULL; 909 910 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc); 911 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len); 912} 913 914enum exist_status { 915 index_nonexistent = 0, 916 index_directory, 917 index_gitdir 918}; 919 920/* 921 * Do not use the alphabetically sorted index to look up 922 * the directory name; instead, use the case insensitive 923 * directory hash. 924 */ 925static enum exist_status directory_exists_in_index_icase(const char *dirname, int len) 926{ 927 const struct cache_entry *ce = cache_dir_exists(dirname, len); 928 unsigned char endchar; 929 930 if (!ce) 931 return index_nonexistent; 932 endchar = ce->name[len]; 933 934 /* 935 * The cache_entry structure returned will contain this dirname 936 * and possibly additional path components. 937 */ 938 if (endchar == '/') 939 return index_directory; 940 941 /* 942 * If there are no additional path components, then this cache_entry 943 * represents a submodule. Submodules, despite being directories, 944 * are stored in the cache without a closing slash. 945 */ 946 if (!endchar && S_ISGITLINK(ce->ce_mode)) 947 return index_gitdir; 948 949 /* This should never be hit, but it exists just in case. */ 950 return index_nonexistent; 951} 952 953/* 954 * The index sorts alphabetically by entry name, which 955 * means that a gitlink sorts as '\0' at the end, while 956 * a directory (which is defined not as an entry, but as 957 * the files it contains) will sort with the '/' at the 958 * end. 959 */ 960static enum exist_status directory_exists_in_index(const char *dirname, int len) 961{ 962 int pos; 963 964 if (ignore_case) 965 return directory_exists_in_index_icase(dirname, len); 966 967 pos = cache_name_pos(dirname, len); 968 if (pos < 0) 969 pos = -pos-1; 970 while (pos < active_nr) { 971 const struct cache_entry *ce = active_cache[pos++]; 972 unsigned char endchar; 973 974 if (strncmp(ce->name, dirname, len)) 975 break; 976 endchar = ce->name[len]; 977 if (endchar > '/') 978 break; 979 if (endchar == '/') 980 return index_directory; 981 if (!endchar && S_ISGITLINK(ce->ce_mode)) 982 return index_gitdir; 983 } 984 return index_nonexistent; 985} 986 987/* 988 * When we find a directory when traversing the filesystem, we 989 * have three distinct cases: 990 * 991 * - ignore it 992 * - see it as a directory 993 * - recurse into it 994 * 995 * and which one we choose depends on a combination of existing 996 * git index contents and the flags passed into the directory 997 * traversal routine. 998 * 999 * Case 1: If we *already* have entries in the index under that1000 * directory name, we always recurse into the directory to see1001 * all the files.1002 *1003 * Case 2: If we *already* have that directory name as a gitlink,1004 * we always continue to see it as a gitlink, regardless of whether1005 * there is an actual git directory there or not (it might not1006 * be checked out as a subproject!)1007 *1008 * Case 3: if we didn't have it in the index previously, we1009 * have a few sub-cases:1010 *1011 * (a) if "show_other_directories" is true, we show it as1012 * just a directory, unless "hide_empty_directories" is1013 * also true, in which case we need to check if it contains any1014 * untracked and / or ignored files.1015 * (b) if it looks like a git directory, and we don't have1016 * 'no_gitlinks' set we treat it as a gitlink, and show it1017 * as a directory.1018 * (c) otherwise, we recurse into it.1019 */1020static enum path_treatment treat_directory(struct dir_struct *dir,1021 const char *dirname, int len, int exclude,1022 const struct path_simplify *simplify)1023{1024 /* The "len-1" is to strip the final '/' */1025 switch (directory_exists_in_index(dirname, len-1)) {1026 case index_directory:1027 return path_recurse;10281029 case index_gitdir:1030 return path_none;10311032 case index_nonexistent:1033 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)1034 break;1035 if (!(dir->flags & DIR_NO_GITLINKS)) {1036 unsigned char sha1[20];1037 if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)1038 return path_untracked;1039 }1040 return path_recurse;1041 }10421043 /* This is the "show_other_directories" case */10441045 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))1046 return exclude ? path_excluded : path_untracked;10471048 return read_directory_recursive(dir, dirname, len, 1, simplify);1049}10501051/*1052 * This is an inexact early pruning of any recursive directory1053 * reading - if the path cannot possibly be in the pathspec,1054 * return true, and we'll skip it early.1055 */1056static int simplify_away(const char *path, int pathlen, const struct path_simplify *simplify)1057{1058 if (simplify) {1059 for (;;) {1060 const char *match = simplify->path;1061 int len = simplify->len;10621063 if (!match)1064 break;1065 if (len > pathlen)1066 len = pathlen;1067 if (!memcmp(path, match, len))1068 return 0;1069 simplify++;1070 }1071 return 1;1072 }1073 return 0;1074}10751076/*1077 * This function tells us whether an excluded path matches a1078 * list of "interesting" pathspecs. That is, whether a path matched1079 * by any of the pathspecs could possibly be ignored by excluding1080 * the specified path. This can happen if:1081 *1082 * 1. the path is mentioned explicitly in the pathspec1083 *1084 * 2. the path is a directory prefix of some element in the1085 * pathspec1086 */1087static int exclude_matches_pathspec(const char *path, int len,1088 const struct path_simplify *simplify)1089{1090 if (simplify) {1091 for (; simplify->path; simplify++) {1092 if (len == simplify->len1093 && !memcmp(path, simplify->path, len))1094 return 1;1095 if (len < simplify->len1096 && simplify->path[len] == '/'1097 && !memcmp(path, simplify->path, len))1098 return 1;1099 }1100 }1101 return 0;1102}11031104static int get_index_dtype(const char *path, int len)1105{1106 int pos;1107 const struct cache_entry *ce;11081109 ce = cache_file_exists(path, len, 0);1110 if (ce) {1111 if (!ce_uptodate(ce))1112 return DT_UNKNOWN;1113 if (S_ISGITLINK(ce->ce_mode))1114 return DT_DIR;1115 /*1116 * Nobody actually cares about the1117 * difference between DT_LNK and DT_REG1118 */1119 return DT_REG;1120 }11211122 /* Try to look it up as a directory */1123 pos = cache_name_pos(path, len);1124 if (pos >= 0)1125 return DT_UNKNOWN;1126 pos = -pos-1;1127 while (pos < active_nr) {1128 ce = active_cache[pos++];1129 if (strncmp(ce->name, path, len))1130 break;1131 if (ce->name[len] > '/')1132 break;1133 if (ce->name[len] < '/')1134 continue;1135 if (!ce_uptodate(ce))1136 break; /* continue? */1137 return DT_DIR;1138 }1139 return DT_UNKNOWN;1140}11411142static int get_dtype(struct dirent *de, const char *path, int len)1143{1144 int dtype = de ? DTYPE(de) : DT_UNKNOWN;1145 struct stat st;11461147 if (dtype != DT_UNKNOWN)1148 return dtype;1149 dtype = get_index_dtype(path, len);1150 if (dtype != DT_UNKNOWN)1151 return dtype;1152 if (lstat(path, &st))1153 return dtype;1154 if (S_ISREG(st.st_mode))1155 return DT_REG;1156 if (S_ISDIR(st.st_mode))1157 return DT_DIR;1158 if (S_ISLNK(st.st_mode))1159 return DT_LNK;1160 return dtype;1161}11621163static enum path_treatment treat_one_path(struct dir_struct *dir,1164 struct strbuf *path,1165 const struct path_simplify *simplify,1166 int dtype, struct dirent *de)1167{1168 int exclude;1169 int has_path_in_index = !!cache_file_exists(path->buf, path->len, ignore_case);11701171 if (dtype == DT_UNKNOWN)1172 dtype = get_dtype(de, path->buf, path->len);11731174 /* Always exclude indexed files */1175 if (dtype != DT_DIR && has_path_in_index)1176 return path_none;11771178 /*1179 * When we are looking at a directory P in the working tree,1180 * there are three cases:1181 *1182 * (1) P exists in the index. Everything inside the directory P in1183 * the working tree needs to go when P is checked out from the1184 * index.1185 *1186 * (2) P does not exist in the index, but there is P/Q in the index.1187 * We know P will stay a directory when we check out the contents1188 * of the index, but we do not know yet if there is a directory1189 * P/Q in the working tree to be killed, so we need to recurse.1190 *1191 * (3) P does not exist in the index, and there is no P/Q in the index1192 * to require P to be a directory, either. Only in this case, we1193 * know that everything inside P will not be killed without1194 * recursing.1195 */1196 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&1197 (dtype == DT_DIR) &&1198 !has_path_in_index &&1199 (directory_exists_in_index(path->buf, path->len) == index_nonexistent))1200 return path_none;12011202 exclude = is_excluded(dir, path->buf, &dtype);12031204 /*1205 * Excluded? If we don't explicitly want to show1206 * ignored files, ignore it1207 */1208 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))1209 return path_excluded;12101211 switch (dtype) {1212 default:1213 return path_none;1214 case DT_DIR:1215 strbuf_addch(path, '/');1216 return treat_directory(dir, path->buf, path->len, exclude,1217 simplify);1218 case DT_REG:1219 case DT_LNK:1220 return exclude ? path_excluded : path_untracked;1221 }1222}12231224static enum path_treatment treat_path(struct dir_struct *dir,1225 struct dirent *de,1226 struct strbuf *path,1227 int baselen,1228 const struct path_simplify *simplify)1229{1230 int dtype;12311232 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))1233 return path_none;1234 strbuf_setlen(path, baselen);1235 strbuf_addstr(path, de->d_name);1236 if (simplify_away(path->buf, path->len, simplify))1237 return path_none;12381239 dtype = DTYPE(de);1240 return treat_one_path(dir, path, simplify, dtype, de);1241}12421243/*1244 * Read a directory tree. We currently ignore anything but1245 * directories, regular files and symlinks. That's because git1246 * doesn't handle them at all yet. Maybe that will change some1247 * day.1248 *1249 * Also, we ignore the name ".git" (even if it is not a directory).1250 * That likely will not change.1251 *1252 * Returns the most significant path_treatment value encountered in the scan.1253 */1254static enum path_treatment read_directory_recursive(struct dir_struct *dir,1255 const char *base, int baselen,1256 int check_only,1257 const struct path_simplify *simplify)1258{1259 DIR *fdir;1260 enum path_treatment state, subdir_state, dir_state = path_none;1261 struct dirent *de;1262 struct strbuf path = STRBUF_INIT;12631264 strbuf_add(&path, base, baselen);12651266 fdir = opendir(path.len ? path.buf : ".");1267 if (!fdir)1268 goto out;12691270 while ((de = readdir(fdir)) != NULL) {1271 /* check how the file or directory should be treated */1272 state = treat_path(dir, de, &path, baselen, simplify);1273 if (state > dir_state)1274 dir_state = state;12751276 /* recurse into subdir if instructed by treat_path */1277 if (state == path_recurse) {1278 subdir_state = read_directory_recursive(dir, path.buf,1279 path.len, check_only, simplify);1280 if (subdir_state > dir_state)1281 dir_state = subdir_state;1282 }12831284 if (check_only) {1285 /* abort early if maximum state has been reached */1286 if (dir_state == path_untracked)1287 break;1288 /* skip the dir_add_* part */1289 continue;1290 }12911292 /* add the path to the appropriate result list */1293 switch (state) {1294 case path_excluded:1295 if (dir->flags & DIR_SHOW_IGNORED)1296 dir_add_name(dir, path.buf, path.len);1297 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||1298 ((dir->flags & DIR_COLLECT_IGNORED) &&1299 exclude_matches_pathspec(path.buf, path.len,1300 simplify)))1301 dir_add_ignored(dir, path.buf, path.len);1302 break;13031304 case path_untracked:1305 if (!(dir->flags & DIR_SHOW_IGNORED))1306 dir_add_name(dir, path.buf, path.len);1307 break;13081309 default:1310 break;1311 }1312 }1313 closedir(fdir);1314 out:1315 strbuf_release(&path);13161317 return dir_state;1318}13191320static int cmp_name(const void *p1, const void *p2)1321{1322 const struct dir_entry *e1 = *(const struct dir_entry **)p1;1323 const struct dir_entry *e2 = *(const struct dir_entry **)p2;13241325 return cache_name_compare(e1->name, e1->len,1326 e2->name, e2->len);1327}13281329static struct path_simplify *create_simplify(const char **pathspec)1330{1331 int nr, alloc = 0;1332 struct path_simplify *simplify = NULL;13331334 if (!pathspec)1335 return NULL;13361337 for (nr = 0 ; ; nr++) {1338 const char *match;1339 if (nr >= alloc) {1340 alloc = alloc_nr(alloc);1341 simplify = xrealloc(simplify, alloc * sizeof(*simplify));1342 }1343 match = *pathspec++;1344 if (!match)1345 break;1346 simplify[nr].path = match;1347 simplify[nr].len = simple_length(match);1348 }1349 simplify[nr].path = NULL;1350 simplify[nr].len = 0;1351 return simplify;1352}13531354static void free_simplify(struct path_simplify *simplify)1355{1356 free(simplify);1357}13581359static int treat_leading_path(struct dir_struct *dir,1360 const char *path, int len,1361 const struct path_simplify *simplify)1362{1363 struct strbuf sb = STRBUF_INIT;1364 int baselen, rc = 0;1365 const char *cp;1366 int old_flags = dir->flags;13671368 while (len && path[len - 1] == '/')1369 len--;1370 if (!len)1371 return 1;1372 baselen = 0;1373 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;1374 while (1) {1375 cp = path + baselen + !!baselen;1376 cp = memchr(cp, '/', path + len - cp);1377 if (!cp)1378 baselen = len;1379 else1380 baselen = cp - path;1381 strbuf_setlen(&sb, 0);1382 strbuf_add(&sb, path, baselen);1383 if (!is_directory(sb.buf))1384 break;1385 if (simplify_away(sb.buf, sb.len, simplify))1386 break;1387 if (treat_one_path(dir, &sb, simplify,1388 DT_DIR, NULL) == path_none)1389 break; /* do not recurse into it */1390 if (len <= baselen) {1391 rc = 1;1392 break; /* finished checking */1393 }1394 }1395 strbuf_release(&sb);1396 dir->flags = old_flags;1397 return rc;1398}13991400int read_directory(struct dir_struct *dir, const char *path, int len, const struct pathspec *pathspec)1401{1402 struct path_simplify *simplify;14031404 /*1405 * Check out create_simplify()1406 */1407 if (pathspec)1408 GUARD_PATHSPEC(pathspec,1409 PATHSPEC_FROMTOP |1410 PATHSPEC_MAXDEPTH |1411 PATHSPEC_LITERAL |1412 PATHSPEC_GLOB |1413 PATHSPEC_ICASE |1414 PATHSPEC_EXCLUDE);14151416 if (has_symlink_leading_path(path, len))1417 return dir->nr;14181419 /*1420 * exclude patterns are treated like positive ones in1421 * create_simplify. Usually exclude patterns should be a1422 * subset of positive ones, which has no impacts on1423 * create_simplify().1424 */1425 simplify = create_simplify(pathspec ? pathspec->_raw : NULL);1426 if (!len || treat_leading_path(dir, path, len, simplify))1427 read_directory_recursive(dir, path, len, 0, simplify);1428 free_simplify(simplify);1429 qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);1430 qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);1431 return dir->nr;1432}14331434int file_exists(const char *f)1435{1436 struct stat sb;1437 return lstat(f, &sb) == 0;1438}14391440/*1441 * Given two normalized paths (a trailing slash is ok), if subdir is1442 * outside dir, return -1. Otherwise return the offset in subdir that1443 * can be used as relative path to dir.1444 */1445int dir_inside_of(const char *subdir, const char *dir)1446{1447 int offset = 0;14481449 assert(dir && subdir && *dir && *subdir);14501451 while (*dir && *subdir && *dir == *subdir) {1452 dir++;1453 subdir++;1454 offset++;1455 }14561457 /* hel[p]/me vs hel[l]/yeah */1458 if (*dir && *subdir)1459 return -1;14601461 if (!*subdir)1462 return !*dir ? offset : -1; /* same dir */14631464 /* foo/[b]ar vs foo/[] */1465 if (is_dir_sep(dir[-1]))1466 return is_dir_sep(subdir[-1]) ? offset : -1;14671468 /* foo[/]bar vs foo[] */1469 return is_dir_sep(*subdir) ? offset + 1 : -1;1470}14711472int is_inside_dir(const char *dir)1473{1474 char cwd[PATH_MAX];1475 if (!dir)1476 return 0;1477 if (!getcwd(cwd, sizeof(cwd)))1478 die_errno("can't find the current directory");1479 return dir_inside_of(cwd, dir) >= 0;1480}14811482int is_empty_dir(const char *path)1483{1484 DIR *dir = opendir(path);1485 struct dirent *e;1486 int ret = 1;14871488 if (!dir)1489 return 0;14901491 while ((e = readdir(dir)) != NULL)1492 if (!is_dot_or_dotdot(e->d_name)) {1493 ret = 0;1494 break;1495 }14961497 closedir(dir);1498 return ret;1499}15001501static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)1502{1503 DIR *dir;1504 struct dirent *e;1505 int ret = 0, original_len = path->len, len, kept_down = 0;1506 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);1507 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);1508 unsigned char submodule_head[20];15091510 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&1511 !resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {1512 /* Do not descend and nuke a nested git work tree. */1513 if (kept_up)1514 *kept_up = 1;1515 return 0;1516 }15171518 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;1519 dir = opendir(path->buf);1520 if (!dir) {1521 if (errno == ENOENT)1522 return keep_toplevel ? -1 : 0;1523 else if (errno == EACCES && !keep_toplevel)1524 /*1525 * An empty dir could be removable even if it1526 * is unreadable:1527 */1528 return rmdir(path->buf);1529 else1530 return -1;1531 }1532 if (path->buf[original_len - 1] != '/')1533 strbuf_addch(path, '/');15341535 len = path->len;1536 while ((e = readdir(dir)) != NULL) {1537 struct stat st;1538 if (is_dot_or_dotdot(e->d_name))1539 continue;15401541 strbuf_setlen(path, len);1542 strbuf_addstr(path, e->d_name);1543 if (lstat(path->buf, &st)) {1544 if (errno == ENOENT)1545 /*1546 * file disappeared, which is what we1547 * wanted anyway1548 */1549 continue;1550 /* fall thru */1551 } else if (S_ISDIR(st.st_mode)) {1552 if (!remove_dir_recurse(path, flag, &kept_down))1553 continue; /* happy */1554 } else if (!only_empty &&1555 (!unlink(path->buf) || errno == ENOENT)) {1556 continue; /* happy, too */1557 }15581559 /* path too long, stat fails, or non-directory still exists */1560 ret = -1;1561 break;1562 }1563 closedir(dir);15641565 strbuf_setlen(path, original_len);1566 if (!ret && !keep_toplevel && !kept_down)1567 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;1568 else if (kept_up)1569 /*1570 * report the uplevel that it is not an error that we1571 * did not rmdir() our directory.1572 */1573 *kept_up = !ret;1574 return ret;1575}15761577int remove_dir_recursively(struct strbuf *path, int flag)1578{1579 return remove_dir_recurse(path, flag, NULL);1580}15811582void setup_standard_excludes(struct dir_struct *dir)1583{1584 const char *path;1585 char *xdg_path;15861587 dir->exclude_per_dir = ".gitignore";1588 path = git_path("info/exclude");1589 if (!excludes_file) {1590 home_config_paths(NULL, &xdg_path, "ignore");1591 excludes_file = xdg_path;1592 }1593 if (!access_or_warn(path, R_OK, 0))1594 add_excludes_from_file(dir, path);1595 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))1596 add_excludes_from_file(dir, excludes_file);1597}15981599int remove_path(const char *name)1600{1601 char *slash;16021603 if (unlink(name) && errno != ENOENT && errno != ENOTDIR)1604 return -1;16051606 slash = strrchr(name, '/');1607 if (slash) {1608 char *dirs = xstrdup(name);1609 slash = dirs + (slash - name);1610 do {1611 *slash = '\0';1612 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));1613 free(dirs);1614 }1615 return 0;1616}16171618/*1619 * Frees memory within dir which was allocated for exclude lists and1620 * the exclude_stack. Does not free dir itself.1621 */1622void clear_directory(struct dir_struct *dir)1623{1624 int i, j;1625 struct exclude_list_group *group;1626 struct exclude_list *el;1627 struct exclude_stack *stk;16281629 for (i = EXC_CMDL; i <= EXC_FILE; i++) {1630 group = &dir->exclude_list_group[i];1631 for (j = 0; j < group->nr; j++) {1632 el = &group->el[j];1633 if (i == EXC_DIRS)1634 free((char *)el->src);1635 clear_exclude_list(el);1636 }1637 free(group->el);1638 }16391640 stk = dir->exclude_stack;1641 while (stk) {1642 struct exclude_stack *prev = stk->prev;1643 free(stk);1644 stk = prev;1645 }1646}