rename field "raw" to "_raw" in struct pathspec
[git/git.git] / dir.c
CommitLineData
453ec4bd
LT
1/*
2 * This handles recursive filename detection with exclude
3 * files, index knowledge etc..
4 *
95a68344
AS
5 * See Documentation/technical/api-directory-listing.txt
6 *
453ec4bd
LT
7 * Copyright (C) Linus Torvalds, 2005-2006
8 * Junio Hamano, 2005-2006
9 */
453ec4bd
LT
10#include "cache.h"
11#include "dir.h"
09595258 12#include "refs.h"
237ec6e4 13#include "wildmatch.h"
64acde94 14#include "pathspec.h"
453ec4bd 15
9fc42d60
LT
16struct path_simplify {
17 int len;
18 const char *path;
19};
20
defd7c7b
KB
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,
09595258 36 int check_only, const struct path_simplify *simplify);
caa6b782 37static int get_dtype(struct dirent *de, const char *path, int len);
09595258 38
8cf2a84e
JJ
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
5d74762d
NTND
55inline int git_fnmatch(const char *pattern, const char *string,
56 int flags, int prefix)
57{
58 int fnm_flags = 0;
59 if (flags & GFNM_PATHNAME)
60 fnm_flags |= FNM_PATHNAME;
61 if (prefix > 0) {
62 if (strncmp(pattern, string, prefix))
63 return FNM_NOMATCH;
64 pattern += prefix;
65 string += prefix;
66 }
8c6abbcd
NTND
67 if (flags & GFNM_ONESTAR) {
68 int pattern_len = strlen(++pattern);
69 int string_len = strlen(string);
70 return string_len < pattern_len ||
71 strcmp(pattern,
72 string + string_len - pattern_len);
73 }
5d74762d
NTND
74 return fnmatch(pattern, string, fnm_flags);
75}
76
0b6e56df
JH
77static int fnmatch_icase_mem(const char *pattern, int patternlen,
78 const char *string, int stringlen,
79 int flags)
80{
81 int match_status;
82 struct strbuf pat_buf = STRBUF_INIT;
83 struct strbuf str_buf = STRBUF_INIT;
84 const char *use_pat = pattern;
85 const char *use_str = string;
86
87 if (pattern[patternlen]) {
88 strbuf_add(&pat_buf, pattern, patternlen);
89 use_pat = pat_buf.buf;
90 }
91 if (string[stringlen]) {
92 strbuf_add(&str_buf, string, stringlen);
93 use_str = str_buf.buf;
94 }
95
f30366b2
JH
96 if (ignore_case)
97 flags |= WM_CASEFOLD;
98 match_status = wildmatch(use_pat, use_str, flags, NULL);
0b6e56df
JH
99
100 strbuf_release(&pat_buf);
101 strbuf_release(&str_buf);
102
103 return match_status;
104}
105
827f4d6c 106static size_t common_prefix_len(const struct pathspec *pathspec)
3c6a370b 107{
827f4d6c 108 int n;
4a085b16 109 size_t max = 0;
3c6a370b 110
827f4d6c 111 GUARD_PATHSPEC(pathspec, PATHSPEC_FROMTOP | PATHSPEC_MAXDEPTH);
4a085b16 112
827f4d6c
NTND
113 for (n = 0; n < pathspec->nr; n++) {
114 size_t i = 0, len = 0;
115 while (i < pathspec->items[n].nowildcard_len &&
116 (n == 0 || i < max)) {
117 char c = pathspec->items[n].match[i];
118 if (c != pathspec->items[0].match[i])
4a085b16
JH
119 break;
120 if (c == '/')
121 len = i + 1;
827f4d6c 122 i++;
4a085b16 123 }
827f4d6c 124 if (n == 0 || len < max) {
4a085b16
JH
125 max = len;
126 if (!max)
127 break;
128 }
3c6a370b 129 }
4a085b16 130 return max;
3c6a370b
LT
131}
132
f950eb95
CB
133/*
134 * Returns a copy of the longest leading path common among all
135 * pathspecs.
136 */
827f4d6c 137char *common_prefix(const struct pathspec *pathspec)
f950eb95
CB
138{
139 unsigned long len = common_prefix_len(pathspec);
140
827f4d6c 141 return len ? xmemdupz(pathspec->items[0].match, len) : NULL;
f950eb95
CB
142}
143
7327d3d1 144int fill_directory(struct dir_struct *dir, const struct pathspec *pathspec)
1d8842d9 145{
4a085b16 146 size_t len;
1d8842d9
LT
147
148 /*
149 * Calculate common prefix for the pathspec, and
150 * use that to optimize the directory walk
151 */
827f4d6c 152 len = common_prefix_len(pathspec);
1d8842d9
LT
153
154 /* Read the directory and prune it */
b3920bbd 155 read_directory(dir, pathspec->nr ? pathspec->_raw[0] : "", len, pathspec);
dba2e203 156 return len;
1d8842d9
LT
157}
158
bc96cc87
NTND
159int within_depth(const char *name, int namelen,
160 int depth, int max_depth)
161{
162 const char *cp = name, *cpe = name + namelen;
163
164 while (cp < cpe) {
165 if (*cp++ != '/')
166 continue;
167 depth++;
168 if (depth > max_depth)
169 return 0;
170 }
171 return 1;
172}
173
61cf2820
NTND
174/*
175 * Does 'match' match the given name?
176 * A match is found if
177 *
178 * (1) the 'match' string is leading directory of 'name', or
179 * (2) the 'match' string is a wildcard and matches 'name', or
180 * (3) the 'match' string is exactly the same as 'name'.
181 *
182 * and the return value tells which case it was.
183 *
184 * It returns 0 when there is no match.
185 */
186static int match_pathspec_item(const struct pathspec_item *item, int prefix,
187 const char *name, int namelen)
188{
189 /* name/namelen has prefix cut off by caller */
190 const char *match = item->match + prefix;
191 int matchlen = item->len - prefix;
192
193 /* If the match was just the prefix, we matched */
194 if (!*match)
195 return MATCHED_RECURSIVELY;
196
197 if (matchlen <= namelen && !strncmp(match, name, matchlen)) {
198 if (matchlen == namelen)
199 return MATCHED_EXACTLY;
200
201 if (match[matchlen-1] == '/' || name[matchlen] == '/')
202 return MATCHED_RECURSIVELY;
203 }
204
5d74762d 205 if (item->nowildcard_len < item->len &&
8c6abbcd
NTND
206 !git_fnmatch(match, name,
207 item->flags & PATHSPEC_ONESTAR ? GFNM_ONESTAR : 0,
208 item->nowildcard_len - prefix))
61cf2820
NTND
209 return MATCHED_FNMATCH;
210
211 return 0;
212}
213
214/*
52ed1894
AS
215 * Given a name and a list of pathspecs, returns the nature of the
216 * closest (i.e. most specific) match of the name to any of the
217 * pathspecs.
218 *
219 * The caller typically calls this multiple times with the same
220 * pathspec and seen[] array but with different name/namelen
221 * (e.g. entries from the index) and is interested in seeing if and
222 * how each pathspec matches all the names it calls this function
223 * with. A mark is left in the seen[] array for each pathspec element
224 * indicating the closest type of match that element achieved, so if
225 * seen[n] remains zero after multiple invocations, that means the nth
226 * pathspec did not match any names, which could indicate that the
227 * user mistyped the nth pathspec.
61cf2820
NTND
228 */
229int match_pathspec_depth(const struct pathspec *ps,
230 const char *name, int namelen,
231 int prefix, char *seen)
232{
233 int i, retval = 0;
234
8f4f8f45
NTND
235 GUARD_PATHSPEC(ps, PATHSPEC_FROMTOP | PATHSPEC_MAXDEPTH);
236
61cf2820 237 if (!ps->nr) {
6330a171
NTND
238 if (!ps->recursive ||
239 !(ps->magic & PATHSPEC_MAXDEPTH) ||
240 ps->max_depth == -1)
61cf2820
NTND
241 return MATCHED_RECURSIVELY;
242
243 if (within_depth(name, namelen, 0, ps->max_depth))
244 return MATCHED_EXACTLY;
245 else
246 return 0;
247 }
248
249 name += prefix;
250 namelen -= prefix;
251
252 for (i = ps->nr - 1; i >= 0; i--) {
253 int how;
254 if (seen && seen[i] == MATCHED_EXACTLY)
255 continue;
256 how = match_pathspec_item(ps->items+i, prefix, name, namelen);
6330a171
NTND
257 if (ps->recursive &&
258 (ps->magic & PATHSPEC_MAXDEPTH) &&
259 ps->max_depth != -1 &&
61cf2820
NTND
260 how && how != MATCHED_FNMATCH) {
261 int len = ps->items[i].len;
262 if (name[len] == '/')
263 len++;
264 if (within_depth(name+len, namelen-len, 0, ps->max_depth))
265 how = MATCHED_EXACTLY;
266 else
267 how = 0;
268 }
269 if (how) {
270 if (retval < how)
271 retval = how;
272 if (seen && seen[i] < how)
273 seen[i] = how;
274 }
275 }
276 return retval;
277}
278
fcd631ed
NTND
279/*
280 * Return the length of the "simple" part of a path match limiter.
281 */
87323bda 282int simple_length(const char *match)
fcd631ed
NTND
283{
284 int len = -1;
285
286 for (;;) {
287 unsigned char c = *match++;
288 len++;
289 if (c == '\0' || is_glob_special(c))
290 return len;
291 }
292}
293
87323bda 294int no_wildcard(const char *string)
68492fc7 295{
fcd631ed 296 return string[simple_length(string)] == '\0';
68492fc7
LK
297}
298
82dce998
NTND
299void parse_exclude_pattern(const char **pattern,
300 int *patternlen,
301 int *flags,
302 int *nowildcardlen)
84460eec
NTND
303{
304 const char *p = *pattern;
305 size_t i, len;
306
307 *flags = 0;
308 if (*p == '!') {
309 *flags |= EXC_FLAG_NEGATIVE;
310 p++;
311 }
312 len = strlen(p);
313 if (len && p[len - 1] == '/') {
314 len--;
315 *flags |= EXC_FLAG_MUSTBEDIR;
316 }
317 for (i = 0; i < len; i++) {
318 if (p[i] == '/')
319 break;
320 }
321 if (i == len)
322 *flags |= EXC_FLAG_NODIR;
323 *nowildcardlen = simple_length(p);
324 /*
325 * we should have excluded the trailing slash from 'p' too,
326 * but that's one more allocation. Instead just make sure
327 * nowildcardlen does not exceed real patternlen
328 */
329 if (*nowildcardlen > len)
330 *nowildcardlen = len;
331 if (*p == '*' && no_wildcard(p + 1))
332 *flags |= EXC_FLAG_ENDSWITH;
333 *pattern = p;
334 *patternlen = len;
335}
336
453ec4bd 337void add_exclude(const char *string, const char *base,
c04318e4 338 int baselen, struct exclude_list *el, int srcpos)
453ec4bd 339{
d6b8fc30 340 struct exclude *x;
84460eec
NTND
341 int patternlen;
342 int flags;
343 int nowildcardlen;
453ec4bd 344
84460eec
NTND
345 parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);
346 if (flags & EXC_FLAG_MUSTBEDIR) {
d6b8fc30 347 char *s;
84460eec 348 x = xmalloc(sizeof(*x) + patternlen + 1);
4b25d091 349 s = (char *)(x+1);
84460eec
NTND
350 memcpy(s, string, patternlen);
351 s[patternlen] = '\0';
d6b8fc30 352 x->pattern = s;
d6b8fc30
JH
353 } else {
354 x = xmalloc(sizeof(*x));
355 x->pattern = string;
356 }
84460eec
NTND
357 x->patternlen = patternlen;
358 x->nowildcardlen = nowildcardlen;
453ec4bd
LT
359 x->base = base;
360 x->baselen = baselen;
d6b8fc30 361 x->flags = flags;
c04318e4 362 x->srcpos = srcpos;
840fc334
AS
363 ALLOC_GROW(el->excludes, el->nr + 1, el->alloc);
364 el->excludes[el->nr++] = x;
c04318e4 365 x->el = el;
453ec4bd
LT
366}
367
c28b3d6e
NTND
368static void *read_skip_worktree_file_from_index(const char *path, size_t *size)
369{
370 int pos, len;
371 unsigned long sz;
372 enum object_type type;
373 void *data;
374 struct index_state *istate = &the_index;
375
376 len = strlen(path);
377 pos = index_name_pos(istate, path, len);
378 if (pos < 0)
379 return NULL;
380 if (!ce_skip_worktree(istate->cache[pos]))
381 return NULL;
382 data = read_sha1_file(istate->cache[pos]->sha1, &type, &sz);
383 if (!data || type != OBJ_BLOB) {
384 free(data);
385 return NULL;
386 }
387 *size = xsize_t(sz);
388 return data;
389}
390
f6198812
AS
391/*
392 * Frees memory within el which was allocated for exclude patterns and
393 * the file buffer. Does not free el itself.
394 */
395void clear_exclude_list(struct exclude_list *el)
0fd0e241
NTND
396{
397 int i;
398
399 for (i = 0; i < el->nr; i++)
400 free(el->excludes[i]);
401 free(el->excludes);
c082df24 402 free(el->filebuf);
0fd0e241
NTND
403
404 el->nr = 0;
405 el->excludes = NULL;
c082df24 406 el->filebuf = NULL;
0fd0e241
NTND
407}
408
cb097534
NTND
409int add_excludes_from_file_to_list(const char *fname,
410 const char *base,
411 int baselen,
840fc334 412 struct exclude_list *el,
cb097534 413 int check_index)
453ec4bd 414{
c470701a 415 struct stat st;
c04318e4 416 int fd, i, lineno = 1;
9d14017a 417 size_t size = 0;
453ec4bd
LT
418 char *buf, *entry;
419
420 fd = open(fname, O_RDONLY);
c28b3d6e 421 if (fd < 0 || fstat(fd, &st) < 0) {
69660731 422 if (errno != ENOENT)
55b38a48 423 warn_on_inaccessible(fname);
c28b3d6e
NTND
424 if (0 <= fd)
425 close(fd);
426 if (!check_index ||
427 (buf = read_skip_worktree_file_from_index(fname, &size)) == NULL)
428 return -1;
45d76f17
NTND
429 if (size == 0) {
430 free(buf);
431 return 0;
432 }
433 if (buf[size-1] != '\n') {
434 buf = xrealloc(buf, size+1);
435 buf[size++] = '\n';
436 }
453ec4bd 437 }
c28b3d6e
NTND
438 else {
439 size = xsize_t(st.st_size);
440 if (size == 0) {
441 close(fd);
442 return 0;
443 }
45d76f17 444 buf = xmalloc(size+1);
c28b3d6e 445 if (read_in_full(fd, buf, size) != size) {
45d76f17 446 free(buf);
c28b3d6e
NTND
447 close(fd);
448 return -1;
449 }
45d76f17 450 buf[size++] = '\n';
c28b3d6e 451 close(fd);
6ba78238 452 }
453ec4bd 453
c082df24 454 el->filebuf = buf;
453ec4bd 455 entry = buf;
45d76f17
NTND
456 for (i = 0; i < size; i++) {
457 if (buf[i] == '\n') {
453ec4bd
LT
458 if (entry != buf + i && entry[0] != '#') {
459 buf[i - (i && buf[i-1] == '\r')] = 0;
c04318e4 460 add_exclude(entry, base, baselen, el, lineno);
453ec4bd 461 }
c04318e4 462 lineno++;
453ec4bd
LT
463 entry = buf + i + 1;
464 }
465 }
466 return 0;
453ec4bd
LT
467}
468
c04318e4
AS
469struct exclude_list *add_exclude_list(struct dir_struct *dir,
470 int group_type, const char *src)
c082df24
AS
471{
472 struct exclude_list *el;
473 struct exclude_list_group *group;
474
475 group = &dir->exclude_list_group[group_type];
476 ALLOC_GROW(group->el, group->nr + 1, group->alloc);
477 el = &group->el[group->nr++];
478 memset(el, 0, sizeof(*el));
c04318e4 479 el->src = src;
c082df24
AS
480 return el;
481}
482
483/*
484 * Used to set up core.excludesfile and .git/info/exclude lists.
485 */
453ec4bd
LT
486void add_excludes_from_file(struct dir_struct *dir, const char *fname)
487{
c082df24 488 struct exclude_list *el;
c04318e4 489 el = add_exclude_list(dir, EXC_FILE, fname);
c082df24 490 if (add_excludes_from_file_to_list(fname, "", 0, el, 0) < 0)
453ec4bd
LT
491 die("cannot use %s as an exclude file", fname);
492}
493
82dce998
NTND
494int match_basename(const char *basename, int basenamelen,
495 const char *pattern, int prefix, int patternlen,
496 int flags)
593cb880
NTND
497{
498 if (prefix == patternlen) {
0b6e56df
JH
499 if (patternlen == basenamelen &&
500 !strncmp_icase(pattern, basename, basenamelen))
593cb880
NTND
501 return 1;
502 } else if (flags & EXC_FLAG_ENDSWITH) {
0b6e56df 503 /* "*literal" matching against "fooliteral" */
593cb880 504 if (patternlen - 1 <= basenamelen &&
0b6e56df
JH
505 !strncmp_icase(pattern + 1,
506 basename + basenamelen - (patternlen - 1),
507 patternlen - 1))
593cb880
NTND
508 return 1;
509 } else {
0b6e56df
JH
510 if (fnmatch_icase_mem(pattern, patternlen,
511 basename, basenamelen,
512 0) == 0)
593cb880
NTND
513 return 1;
514 }
515 return 0;
516}
517
82dce998
NTND
518int match_pathname(const char *pathname, int pathlen,
519 const char *base, int baselen,
520 const char *pattern, int prefix, int patternlen,
521 int flags)
b5592632
NTND
522{
523 const char *name;
524 int namelen;
525
526 /*
527 * match with FNM_PATHNAME; the pattern has base implicitly
528 * in front of it.
529 */
530 if (*pattern == '/') {
531 pattern++;
982ac873 532 patternlen--;
b5592632
NTND
533 prefix--;
534 }
535
536 /*
537 * baselen does not count the trailing slash. base[] may or
538 * may not end with a trailing slash though.
539 */
540 if (pathlen < baselen + 1 ||
541 (baselen && pathname[baselen] != '/') ||
542 strncmp_icase(pathname, base, baselen))
543 return 0;
544
545 namelen = baselen ? pathlen - baselen - 1 : pathlen;
546 name = pathname + pathlen - namelen;
547
548 if (prefix) {
549 /*
550 * if the non-wildcard part is longer than the
551 * remaining pathname, surely it cannot match.
552 */
553 if (prefix > namelen)
554 return 0;
555
556 if (strncmp_icase(pattern, name, prefix))
557 return 0;
558 pattern += prefix;
ab3aebc1 559 patternlen -= prefix;
b5592632
NTND
560 name += prefix;
561 namelen -= prefix;
ab3aebc1
JK
562
563 /*
564 * If the whole pattern did not have a wildcard,
565 * then our prefix match is all we need; we
566 * do not need to call fnmatch at all.
567 */
568 if (!patternlen && !namelen)
569 return 1;
b5592632
NTND
570 }
571
ab3aebc1
JK
572 return fnmatch_icase_mem(pattern, patternlen,
573 name, namelen,
f30366b2 574 WM_PATHNAME) == 0;
b5592632
NTND
575}
576
578cd7c3
AS
577/*
578 * Scan the given exclude list in reverse to see whether pathname
579 * should be ignored. The first match (i.e. the last on the list), if
580 * any, determines the fate. Returns the exclude_list element which
581 * matched, or NULL for undecided.
453ec4bd 582 */
578cd7c3
AS
583static struct exclude *last_exclude_matching_from_list(const char *pathname,
584 int pathlen,
585 const char *basename,
586 int *dtype,
587 struct exclude_list *el)
453ec4bd
LT
588{
589 int i;
590
35a94d44 591 if (!el->nr)
578cd7c3 592 return NULL; /* undefined */
d6b8fc30 593
35a94d44
NTND
594 for (i = el->nr - 1; 0 <= i; i--) {
595 struct exclude *x = el->excludes[i];
b5592632 596 const char *exclude = x->pattern;
b5592632 597 int prefix = x->nowildcardlen;
35a94d44
NTND
598
599 if (x->flags & EXC_FLAG_MUSTBEDIR) {
600 if (*dtype == DT_UNKNOWN)
601 *dtype = get_dtype(NULL, pathname, pathlen);
602 if (*dtype != DT_DIR)
603 continue;
604 }
d6b8fc30 605
35a94d44 606 if (x->flags & EXC_FLAG_NODIR) {
593cb880
NTND
607 if (match_basename(basename,
608 pathlen - (basename - pathname),
609 exclude, prefix, x->patternlen,
610 x->flags))
578cd7c3 611 return x;
35a94d44
NTND
612 continue;
613 }
614
b5592632
NTND
615 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/');
616 if (match_pathname(pathname, pathlen,
617 x->base, x->baselen ? x->baselen - 1 : 0,
618 exclude, prefix, x->patternlen, x->flags))
578cd7c3 619 return x;
453ec4bd 620 }
578cd7c3
AS
621 return NULL; /* undecided */
622}
623
624/*
625 * Scan the list and let the last match determine the fate.
626 * Return 1 for exclude, 0 for include and -1 for undecided.
627 */
628int is_excluded_from_list(const char *pathname,
629 int pathlen, const char *basename, int *dtype,
630 struct exclude_list *el)
631{
632 struct exclude *exclude;
633 exclude = last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el);
634 if (exclude)
635 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
453ec4bd
LT
636 return -1; /* undecided */
637}
638
46aa2f95
KB
639static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,
640 const char *pathname, int pathlen, const char *basename,
641 int *dtype_p)
642{
643 int i, j;
644 struct exclude_list_group *group;
645 struct exclude *exclude;
646 for (i = EXC_CMDL; i <= EXC_FILE; i++) {
647 group = &dir->exclude_list_group[i];
648 for (j = group->nr - 1; j >= 0; j--) {
649 exclude = last_exclude_matching_from_list(
650 pathname, pathlen, basename, dtype_p,
651 &group->el[j]);
652 if (exclude)
653 return exclude;
654 }
655 }
656 return NULL;
657}
658
6cd5c582
KB
659/*
660 * Loads the per-directory exclude list for the substring of base
661 * which has a char length of baselen.
662 */
663static void prep_exclude(struct dir_struct *dir, const char *base, int baselen)
664{
665 struct exclude_list_group *group;
666 struct exclude_list *el;
667 struct exclude_stack *stk = NULL;
668 int current;
669
6cd5c582
KB
670 group = &dir->exclude_list_group[EXC_DIRS];
671
672 /* Pop the exclude lists from the EXCL_DIRS exclude_list_group
673 * which originate from directories not in the prefix of the
674 * path being checked. */
675 while ((stk = dir->exclude_stack) != NULL) {
676 if (stk->baselen <= baselen &&
677 !strncmp(dir->basebuf, base, stk->baselen))
678 break;
679 el = &group->el[dir->exclude_stack->exclude_ix];
680 dir->exclude_stack = stk->prev;
95c6f271 681 dir->exclude = NULL;
6cd5c582
KB
682 free((char *)el->src); /* see strdup() below */
683 clear_exclude_list(el);
684 free(stk);
685 group->nr--;
686 }
687
95c6f271
KB
688 /* Skip traversing into sub directories if the parent is excluded */
689 if (dir->exclude)
690 return;
691
6cd5c582
KB
692 /* Read from the parent directories and push them down. */
693 current = stk ? stk->baselen : -1;
694 while (current < baselen) {
695 struct exclude_stack *stk = xcalloc(1, sizeof(*stk));
696 const char *cp;
697
698 if (current < 0) {
699 cp = base;
700 current = 0;
701 }
702 else {
703 cp = strchr(base + current + 1, '/');
704 if (!cp)
705 die("oops in prep_exclude");
706 cp++;
707 }
708 stk->prev = dir->exclude_stack;
709 stk->baselen = cp - base;
95c6f271
KB
710 stk->exclude_ix = group->nr;
711 el = add_exclude_list(dir, EXC_DIRS, NULL);
6cd5c582
KB
712 memcpy(dir->basebuf + current, base + current,
713 stk->baselen - current);
95c6f271
KB
714
715 /* Abort if the directory is excluded */
716 if (stk->baselen) {
717 int dt = DT_DIR;
718 dir->basebuf[stk->baselen - 1] = 0;
719 dir->exclude = last_exclude_matching_from_lists(dir,
720 dir->basebuf, stk->baselen - 1,
721 dir->basebuf + current, &dt);
722 dir->basebuf[stk->baselen - 1] = '/';
c3c327de
KB
723 if (dir->exclude &&
724 dir->exclude->flags & EXC_FLAG_NEGATIVE)
725 dir->exclude = NULL;
95c6f271
KB
726 if (dir->exclude) {
727 dir->basebuf[stk->baselen] = 0;
728 dir->exclude_stack = stk;
729 return;
730 }
731 }
732
733 /* Try to read per-directory file unless path is too long */
734 if (dir->exclude_per_dir &&
735 stk->baselen + strlen(dir->exclude_per_dir) < PATH_MAX) {
736 strcpy(dir->basebuf + stk->baselen,
737 dir->exclude_per_dir);
738 /*
739 * dir->basebuf gets reused by the traversal, but we
740 * need fname to remain unchanged to ensure the src
741 * member of each struct exclude correctly
742 * back-references its source file. Other invocations
743 * of add_exclude_list provide stable strings, so we
744 * strdup() and free() here in the caller.
745 */
746 el->src = strdup(dir->basebuf);
747 add_excludes_from_file_to_list(dir->basebuf,
748 dir->basebuf, stk->baselen, el, 1);
749 }
6cd5c582
KB
750 dir->exclude_stack = stk;
751 current = stk->baselen;
752 }
753 dir->basebuf[baselen] = '\0';
754}
755
f4cd69a6
AS
756/*
757 * Loads the exclude lists for the directory containing pathname, then
758 * scans all exclude lists to determine whether pathname is excluded.
759 * Returns the exclude_list element which matched, or NULL for
760 * undecided.
761 */
b07bc8c8 762struct exclude *last_exclude_matching(struct dir_struct *dir,
f4cd69a6
AS
763 const char *pathname,
764 int *dtype_p)
453ec4bd
LT
765{
766 int pathlen = strlen(pathname);
68492fc7
LK
767 const char *basename = strrchr(pathname, '/');
768 basename = (basename) ? basename+1 : pathname;
453ec4bd 769
63d285c8 770 prep_exclude(dir, pathname, basename-pathname);
c082df24 771
95c6f271
KB
772 if (dir->exclude)
773 return dir->exclude;
774
46aa2f95
KB
775 return last_exclude_matching_from_lists(dir, pathname, pathlen,
776 basename, dtype_p);
f4cd69a6
AS
777}
778
779/*
780 * Loads the exclude lists for the directory containing pathname, then
781 * scans all exclude lists to determine whether pathname is excluded.
782 * Returns 1 if true, otherwise 0.
783 */
b07bc8c8 784int is_excluded(struct dir_struct *dir, const char *pathname, int *dtype_p)
f4cd69a6
AS
785{
786 struct exclude *exclude =
787 last_exclude_matching(dir, pathname, dtype_p);
788 if (exclude)
789 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
453ec4bd
LT
790 return 0;
791}
792
f3fa1838
JH
793static struct dir_entry *dir_entry_new(const char *pathname, int len)
794{
453ec4bd
LT
795 struct dir_entry *ent;
796
453ec4bd
LT
797 ent = xmalloc(sizeof(*ent) + len + 1);
798 ent->len = len;
799 memcpy(ent->name, pathname, len);
800 ent->name[len] = 0;
4d06f8ac 801 return ent;
453ec4bd
LT
802}
803
159b3212 804static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len)
6815e569 805{
5bd8e2d8 806 if (cache_name_exists(pathname, len, ignore_case))
6815e569
JK
807 return NULL;
808
25fd2f7a 809 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);
6815e569
JK
810 return dir->entries[dir->nr++] = dir_entry_new(pathname, len);
811}
812
108da0db 813struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len)
2abd31b0 814{
6e4f981f 815 if (!cache_name_is_other(pathname, len))
2abd31b0
JK
816 return NULL;
817
25fd2f7a 818 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);
2abd31b0
JK
819 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);
820}
821
09595258
LT
822enum exist_status {
823 index_nonexistent = 0,
824 index_directory,
4b05548f 825 index_gitdir
09595258
LT
826};
827
5102c617
JJ
828/*
829 * Do not use the alphabetically stored index to look up
830 * the directory name; instead, use the case insensitive
831 * name hash.
832 */
833static enum exist_status directory_exists_in_index_icase(const char *dirname, int len)
834{
835 struct cache_entry *ce = index_name_exists(&the_index, dirname, len + 1, ignore_case);
836 unsigned char endchar;
837
838 if (!ce)
839 return index_nonexistent;
840 endchar = ce->name[len];
841
842 /*
843 * The cache_entry structure returned will contain this dirname
844 * and possibly additional path components.
845 */
846 if (endchar == '/')
847 return index_directory;
848
849 /*
850 * If there are no additional path components, then this cache_entry
851 * represents a submodule. Submodules, despite being directories,
852 * are stored in the cache without a closing slash.
853 */
854 if (!endchar && S_ISGITLINK(ce->ce_mode))
855 return index_gitdir;
856
857 /* This should never be hit, but it exists just in case. */
858 return index_nonexistent;
859}
860
09595258
LT
861/*
862 * The index sorts alphabetically by entry name, which
863 * means that a gitlink sorts as '\0' at the end, while
864 * a directory (which is defined not as an entry, but as
865 * the files it contains) will sort with the '/' at the
866 * end.
867 */
868static enum exist_status directory_exists_in_index(const char *dirname, int len)
453ec4bd 869{
5102c617
JJ
870 int pos;
871
872 if (ignore_case)
873 return directory_exists_in_index_icase(dirname, len);
874
875 pos = cache_name_pos(dirname, len);
09595258
LT
876 if (pos < 0)
877 pos = -pos-1;
878 while (pos < active_nr) {
879 struct cache_entry *ce = active_cache[pos++];
880 unsigned char endchar;
881
882 if (strncmp(ce->name, dirname, len))
883 break;
884 endchar = ce->name[len];
885 if (endchar > '/')
886 break;
887 if (endchar == '/')
888 return index_directory;
7a51ed66 889 if (!endchar && S_ISGITLINK(ce->ce_mode))
09595258
LT
890 return index_gitdir;
891 }
892 return index_nonexistent;
893}
894
895/*
896 * When we find a directory when traversing the filesystem, we
897 * have three distinct cases:
898 *
899 * - ignore it
900 * - see it as a directory
901 * - recurse into it
902 *
903 * and which one we choose depends on a combination of existing
904 * git index contents and the flags passed into the directory
905 * traversal routine.
906 *
907 * Case 1: If we *already* have entries in the index under that
5bd8e2d8
KB
908 * directory name, we always recurse into the directory to see
909 * all the files.
09595258
LT
910 *
911 * Case 2: If we *already* have that directory name as a gitlink,
912 * we always continue to see it as a gitlink, regardless of whether
913 * there is an actual git directory there or not (it might not
914 * be checked out as a subproject!)
915 *
916 * Case 3: if we didn't have it in the index previously, we
917 * have a few sub-cases:
918 *
919 * (a) if "show_other_directories" is true, we show it as
920 * just a directory, unless "hide_empty_directories" is
defd7c7b
KB
921 * also true, in which case we need to check if it contains any
922 * untracked and / or ignored files.
09595258 923 * (b) if it looks like a git directory, and we don't have
302b9282 924 * 'no_gitlinks' set we treat it as a gitlink, and show it
09595258
LT
925 * as a directory.
926 * (c) otherwise, we recurse into it.
927 */
defd7c7b 928static enum path_treatment treat_directory(struct dir_struct *dir,
721ac4ed 929 const char *dirname, int len, int exclude,
09595258
LT
930 const struct path_simplify *simplify)
931{
932 /* The "len-1" is to strip the final '/' */
933 switch (directory_exists_in_index(dirname, len-1)) {
934 case index_directory:
defd7c7b 935 return path_recurse;
09595258
LT
936
937 case index_gitdir:
26c986e1 938 return path_none;
09595258
LT
939
940 case index_nonexistent:
7c4c97c0 941 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)
09595258 942 break;
7c4c97c0 943 if (!(dir->flags & DIR_NO_GITLINKS)) {
09595258
LT
944 unsigned char sha1[20];
945 if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)
defd7c7b 946 return path_untracked;
09595258 947 }
defd7c7b 948 return path_recurse;
09595258
LT
949 }
950
951 /* This is the "show_other_directories" case */
721ac4ed 952
184d2a8e 953 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))
defd7c7b
KB
954 return exclude ? path_excluded : path_untracked;
955
956 return read_directory_recursive(dir, dirname, len, 1, simplify);
453ec4bd
LT
957}
958
9fc42d60
LT
959/*
960 * This is an inexact early pruning of any recursive directory
961 * reading - if the path cannot possibly be in the pathspec,
962 * return true, and we'll skip it early.
963 */
964static int simplify_away(const char *path, int pathlen, const struct path_simplify *simplify)
965{
966 if (simplify) {
967 for (;;) {
968 const char *match = simplify->path;
969 int len = simplify->len;
970
971 if (!match)
972 break;
973 if (len > pathlen)
974 len = pathlen;
975 if (!memcmp(path, match, len))
976 return 0;
977 simplify++;
978 }
979 return 1;
980 }
981 return 0;
982}
983
29209cbe
JK
984/*
985 * This function tells us whether an excluded path matches a
986 * list of "interesting" pathspecs. That is, whether a path matched
987 * by any of the pathspecs could possibly be ignored by excluding
988 * the specified path. This can happen if:
989 *
990 * 1. the path is mentioned explicitly in the pathspec
991 *
992 * 2. the path is a directory prefix of some element in the
993 * pathspec
994 */
995static int exclude_matches_pathspec(const char *path, int len,
996 const struct path_simplify *simplify)
e96980ef
JK
997{
998 if (simplify) {
999 for (; simplify->path; simplify++) {
1000 if (len == simplify->len
1001 && !memcmp(path, simplify->path, len))
1002 return 1;
29209cbe
JK
1003 if (len < simplify->len
1004 && simplify->path[len] == '/'
1005 && !memcmp(path, simplify->path, len))
1006 return 1;
e96980ef
JK
1007 }
1008 }
1009 return 0;
1010}
1011
443e061a
LT
1012static int get_index_dtype(const char *path, int len)
1013{
1014 int pos;
1015 struct cache_entry *ce;
1016
1017 ce = cache_name_exists(path, len, 0);
1018 if (ce) {
1019 if (!ce_uptodate(ce))
1020 return DT_UNKNOWN;
1021 if (S_ISGITLINK(ce->ce_mode))
1022 return DT_DIR;
1023 /*
1024 * Nobody actually cares about the
1025 * difference between DT_LNK and DT_REG
1026 */
1027 return DT_REG;
1028 }
1029
1030 /* Try to look it up as a directory */
1031 pos = cache_name_pos(path, len);
1032 if (pos >= 0)
1033 return DT_UNKNOWN;
1034 pos = -pos-1;
1035 while (pos < active_nr) {
1036 ce = active_cache[pos++];
1037 if (strncmp(ce->name, path, len))
1038 break;
1039 if (ce->name[len] > '/')
1040 break;
1041 if (ce->name[len] < '/')
1042 continue;
1043 if (!ce_uptodate(ce))
1044 break; /* continue? */
1045 return DT_DIR;
1046 }
1047 return DT_UNKNOWN;
1048}
1049
caa6b782 1050static int get_dtype(struct dirent *de, const char *path, int len)
07134421 1051{
6831a88a 1052 int dtype = de ? DTYPE(de) : DT_UNKNOWN;
07134421
LT
1053 struct stat st;
1054
1055 if (dtype != DT_UNKNOWN)
1056 return dtype;
443e061a
LT
1057 dtype = get_index_dtype(path, len);
1058 if (dtype != DT_UNKNOWN)
1059 return dtype;
1060 if (lstat(path, &st))
07134421
LT
1061 return dtype;
1062 if (S_ISREG(st.st_mode))
1063 return DT_REG;
1064 if (S_ISDIR(st.st_mode))
1065 return DT_DIR;
1066 if (S_ISLNK(st.st_mode))
1067 return DT_LNK;
1068 return dtype;
1069}
1070
16e2cfa9 1071static enum path_treatment treat_one_path(struct dir_struct *dir,
49dc2cc2 1072 struct strbuf *path,
16e2cfa9
JH
1073 const struct path_simplify *simplify,
1074 int dtype, struct dirent *de)
53cc5356 1075{
8aaf8d77
KB
1076 int exclude;
1077 if (dtype == DT_UNKNOWN)
1078 dtype = get_dtype(de, path->buf, path->len);
1079
1080 /* Always exclude indexed files */
1081 if (dtype != DT_DIR &&
1082 cache_name_exists(path->buf, path->len, ignore_case))
defd7c7b 1083 return path_none;
8aaf8d77
KB
1084
1085 exclude = is_excluded(dir, path->buf, &dtype);
53cc5356
JH
1086
1087 /*
1088 * Excluded? If we don't explicitly want to show
1089 * ignored files, ignore it
1090 */
0aaf62b6 1091 if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))
defd7c7b 1092 return path_excluded;
53cc5356 1093
53cc5356
JH
1094 switch (dtype) {
1095 default:
defd7c7b 1096 return path_none;
53cc5356 1097 case DT_DIR:
49dc2cc2 1098 strbuf_addch(path, '/');
defd7c7b
KB
1099 return treat_directory(dir, path->buf, path->len, exclude,
1100 simplify);
53cc5356
JH
1101 case DT_REG:
1102 case DT_LNK:
defd7c7b 1103 return exclude ? path_excluded : path_untracked;
53cc5356 1104 }
53cc5356
JH
1105}
1106
16e2cfa9
JH
1107static enum path_treatment treat_path(struct dir_struct *dir,
1108 struct dirent *de,
49dc2cc2 1109 struct strbuf *path,
16e2cfa9 1110 int baselen,
49dc2cc2 1111 const struct path_simplify *simplify)
16e2cfa9
JH
1112{
1113 int dtype;
1114
1115 if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))
defd7c7b 1116 return path_none;
49dc2cc2
RS
1117 strbuf_setlen(path, baselen);
1118 strbuf_addstr(path, de->d_name);
1119 if (simplify_away(path->buf, path->len, simplify))
defd7c7b 1120 return path_none;
16e2cfa9
JH
1121
1122 dtype = DTYPE(de);
49dc2cc2 1123 return treat_one_path(dir, path, simplify, dtype, de);
16e2cfa9
JH
1124}
1125
453ec4bd
LT
1126/*
1127 * Read a directory tree. We currently ignore anything but
1128 * directories, regular files and symlinks. That's because git
1129 * doesn't handle them at all yet. Maybe that will change some
1130 * day.
1131 *
1132 * Also, we ignore the name ".git" (even if it is not a directory).
1133 * That likely will not change.
defd7c7b
KB
1134 *
1135 * Returns the most significant path_treatment value encountered in the scan.
453ec4bd 1136 */
defd7c7b 1137static enum path_treatment read_directory_recursive(struct dir_struct *dir,
53cc5356
JH
1138 const char *base, int baselen,
1139 int check_only,
1140 const struct path_simplify *simplify)
453ec4bd 1141{
1528d247 1142 DIR *fdir;
defd7c7b 1143 enum path_treatment state, subdir_state, dir_state = path_none;
02cb6753 1144 struct dirent *de;
bef36921 1145 struct strbuf path = STRBUF_INIT;
453ec4bd 1146
bef36921 1147 strbuf_add(&path, base, baselen);
02cb6753 1148
1528d247
RS
1149 fdir = opendir(path.len ? path.buf : ".");
1150 if (!fdir)
1151 goto out;
1152
02cb6753 1153 while ((de = readdir(fdir)) != NULL) {
defd7c7b
KB
1154 /* check how the file or directory should be treated */
1155 state = treat_path(dir, de, &path, baselen, simplify);
1156 if (state > dir_state)
1157 dir_state = state;
1158
1159 /* recurse into subdir if instructed by treat_path */
1160 if (state == path_recurse) {
1161 subdir_state = read_directory_recursive(dir, path.buf,
289ff559 1162 path.len, check_only, simplify);
defd7c7b
KB
1163 if (subdir_state > dir_state)
1164 dir_state = subdir_state;
1165 }
1166
1167 if (check_only) {
1168 /* abort early if maximum state has been reached */
1169 if (dir_state == path_untracked)
1170 break;
1171 /* skip the dir_add_* part */
02cb6753 1172 continue;
453ec4bd 1173 }
defd7c7b
KB
1174
1175 /* add the path to the appropriate result list */
1176 switch (state) {
1177 case path_excluded:
1178 if (dir->flags & DIR_SHOW_IGNORED)
1179 dir_add_name(dir, path.buf, path.len);
0aaf62b6
KB
1180 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||
1181 ((dir->flags & DIR_COLLECT_IGNORED) &&
1182 exclude_matches_pathspec(path.buf, path.len,
1183 simplify)))
1184 dir_add_ignored(dir, path.buf, path.len);
defd7c7b
KB
1185 break;
1186
1187 case path_untracked:
1188 if (!(dir->flags & DIR_SHOW_IGNORED))
1189 dir_add_name(dir, path.buf, path.len);
1528d247 1190 break;
defd7c7b
KB
1191
1192 default:
1193 break;
1194 }
453ec4bd 1195 }
02cb6753 1196 closedir(fdir);
1528d247 1197 out:
bef36921 1198 strbuf_release(&path);
453ec4bd 1199
defd7c7b 1200 return dir_state;
453ec4bd
LT
1201}
1202
1203static int cmp_name(const void *p1, const void *p2)
1204{
1205 const struct dir_entry *e1 = *(const struct dir_entry **)p1;
1206 const struct dir_entry *e2 = *(const struct dir_entry **)p2;
1207
1208 return cache_name_compare(e1->name, e1->len,
1209 e2->name, e2->len);
1210}
1211
9fc42d60
LT
1212static struct path_simplify *create_simplify(const char **pathspec)
1213{
1214 int nr, alloc = 0;
1215 struct path_simplify *simplify = NULL;
1216
1217 if (!pathspec)
1218 return NULL;
1219
1220 for (nr = 0 ; ; nr++) {
1221 const char *match;
1222 if (nr >= alloc) {
1223 alloc = alloc_nr(alloc);
1224 simplify = xrealloc(simplify, alloc * sizeof(*simplify));
1225 }
1226 match = *pathspec++;
1227 if (!match)
1228 break;
1229 simplify[nr].path = match;
1230 simplify[nr].len = simple_length(match);
1231 }
1232 simplify[nr].path = NULL;
1233 simplify[nr].len = 0;
1234 return simplify;
1235}
1236
1237static void free_simplify(struct path_simplify *simplify)
1238{
8e0f7003 1239 free(simplify);
9fc42d60
LT
1240}
1241
48ffef96
JH
1242static int treat_leading_path(struct dir_struct *dir,
1243 const char *path, int len,
1244 const struct path_simplify *simplify)
1245{
49dc2cc2
RS
1246 struct strbuf sb = STRBUF_INIT;
1247 int baselen, rc = 0;
48ffef96 1248 const char *cp;
be8a84c5 1249 int old_flags = dir->flags;
48ffef96
JH
1250
1251 while (len && path[len - 1] == '/')
1252 len--;
1253 if (!len)
1254 return 1;
1255 baselen = 0;
be8a84c5 1256 dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;
48ffef96
JH
1257 while (1) {
1258 cp = path + baselen + !!baselen;
1259 cp = memchr(cp, '/', path + len - cp);
1260 if (!cp)
1261 baselen = len;
1262 else
1263 baselen = cp - path;
49dc2cc2
RS
1264 strbuf_setlen(&sb, 0);
1265 strbuf_add(&sb, path, baselen);
1266 if (!is_directory(sb.buf))
1267 break;
1268 if (simplify_away(sb.buf, sb.len, simplify))
1269 break;
1270 if (treat_one_path(dir, &sb, simplify,
defd7c7b 1271 DT_DIR, NULL) == path_none)
49dc2cc2
RS
1272 break; /* do not recurse into it */
1273 if (len <= baselen) {
1274 rc = 1;
1275 break; /* finished checking */
1276 }
48ffef96 1277 }
49dc2cc2 1278 strbuf_release(&sb);
be8a84c5 1279 dir->flags = old_flags;
49dc2cc2 1280 return rc;
48ffef96
JH
1281}
1282
7327d3d1 1283int read_directory(struct dir_struct *dir, const char *path, int len, const struct pathspec *pathspec)
9fc42d60 1284{
725b0605 1285 struct path_simplify *simplify;
b4189aa8 1286
7327d3d1
NTND
1287 /*
1288 * Check out create_simplify()
1289 */
1290 if (pathspec)
1291 GUARD_PATHSPEC(pathspec, PATHSPEC_FROMTOP | PATHSPEC_MAXDEPTH);
1292
dba2e203 1293 if (has_symlink_leading_path(path, len))
725b0605
JH
1294 return dir->nr;
1295
b3920bbd 1296 simplify = create_simplify(pathspec ? pathspec->_raw : NULL);
48ffef96
JH
1297 if (!len || treat_leading_path(dir, path, len, simplify))
1298 read_directory_recursive(dir, path, len, 0, simplify);
9fc42d60 1299 free_simplify(simplify);
453ec4bd 1300 qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);
2abd31b0 1301 qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);
453ec4bd
LT
1302 return dir->nr;
1303}
c91f0d92 1304
686a4a06 1305int file_exists(const char *f)
c91f0d92 1306{
686a4a06 1307 struct stat sb;
a50f9fc5 1308 return lstat(f, &sb) == 0;
c91f0d92 1309}
e6636747
JS
1310
1311/*
9b125da4
NTND
1312 * Given two normalized paths (a trailing slash is ok), if subdir is
1313 * outside dir, return -1. Otherwise return the offset in subdir that
1314 * can be used as relative path to dir.
e6636747 1315 */
9b125da4 1316int dir_inside_of(const char *subdir, const char *dir)
e6636747 1317{
9b125da4 1318 int offset = 0;
e6636747 1319
9b125da4 1320 assert(dir && subdir && *dir && *subdir);
e6636747 1321
9b125da4 1322 while (*dir && *subdir && *dir == *subdir) {
e6636747 1323 dir++;
9b125da4
NTND
1324 subdir++;
1325 offset++;
490544b1 1326 }
9b125da4
NTND
1327
1328 /* hel[p]/me vs hel[l]/yeah */
1329 if (*dir && *subdir)
1330 return -1;
1331
1332 if (!*subdir)
1333 return !*dir ? offset : -1; /* same dir */
1334
1335 /* foo/[b]ar vs foo/[] */
1336 if (is_dir_sep(dir[-1]))
1337 return is_dir_sep(subdir[-1]) ? offset : -1;
1338
1339 /* foo[/]bar vs foo[] */
1340 return is_dir_sep(*subdir) ? offset + 1 : -1;
e6636747
JS
1341}
1342
1343int is_inside_dir(const char *dir)
1344{
b892913d
NTND
1345 char cwd[PATH_MAX];
1346 if (!dir)
1347 return 0;
1348 if (!getcwd(cwd, sizeof(cwd)))
1349 die_errno("can't find the current directory");
1350 return dir_inside_of(cwd, dir) >= 0;
e6636747 1351}
7155b727 1352
55892d23
AP
1353int is_empty_dir(const char *path)
1354{
1355 DIR *dir = opendir(path);
1356 struct dirent *e;
1357 int ret = 1;
1358
1359 if (!dir)
1360 return 0;
1361
1362 while ((e = readdir(dir)) != NULL)
1363 if (!is_dot_or_dotdot(e->d_name)) {
1364 ret = 0;
1365 break;
1366 }
1367
1368 closedir(dir);
1369 return ret;
1370}
1371
ae2f203e 1372static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)
7155b727 1373{
a0f4afbe 1374 DIR *dir;
7155b727 1375 struct dirent *e;
ae2f203e 1376 int ret = 0, original_len = path->len, len, kept_down = 0;
a0f4afbe 1377 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);
c844a803 1378 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);
a0f4afbe 1379 unsigned char submodule_head[20];
7155b727 1380
a0f4afbe 1381 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&
ae2f203e 1382 !resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {
a0f4afbe 1383 /* Do not descend and nuke a nested git work tree. */
ae2f203e
JH
1384 if (kept_up)
1385 *kept_up = 1;
a0f4afbe 1386 return 0;
ae2f203e 1387 }
a0f4afbe 1388
ae2f203e 1389 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;
a0f4afbe 1390 dir = opendir(path->buf);
c844a803 1391 if (!dir) {
ae2f203e 1392 /* an empty dir could be removed even if it is unreadble */
c844a803
JH
1393 if (!keep_toplevel)
1394 return rmdir(path->buf);
1395 else
1396 return -1;
1397 }
7155b727
JS
1398 if (path->buf[original_len - 1] != '/')
1399 strbuf_addch(path, '/');
1400
1401 len = path->len;
1402 while ((e = readdir(dir)) != NULL) {
1403 struct stat st;
8ca12c0d
AP
1404 if (is_dot_or_dotdot(e->d_name))
1405 continue;
7155b727
JS
1406
1407 strbuf_setlen(path, len);
1408 strbuf_addstr(path, e->d_name);
1409 if (lstat(path->buf, &st))
1410 ; /* fall thru */
1411 else if (S_ISDIR(st.st_mode)) {
ae2f203e 1412 if (!remove_dir_recurse(path, flag, &kept_down))
7155b727
JS
1413 continue; /* happy */
1414 } else if (!only_empty && !unlink(path->buf))
1415 continue; /* happy, too */
1416
1417 /* path too long, stat fails, or non-directory still exists */
1418 ret = -1;
1419 break;
1420 }
1421 closedir(dir);
1422
1423 strbuf_setlen(path, original_len);
ae2f203e 1424 if (!ret && !keep_toplevel && !kept_down)
7155b727 1425 ret = rmdir(path->buf);
ae2f203e
JH
1426 else if (kept_up)
1427 /*
1428 * report the uplevel that it is not an error that we
1429 * did not rmdir() our directory.
1430 */
1431 *kept_up = !ret;
7155b727
JS
1432 return ret;
1433}
039bc64e 1434
ae2f203e
JH
1435int remove_dir_recursively(struct strbuf *path, int flag)
1436{
1437 return remove_dir_recurse(path, flag, NULL);
1438}
1439
039bc64e
JH
1440void setup_standard_excludes(struct dir_struct *dir)
1441{
1442 const char *path;
dc79687e 1443 char *xdg_path;
039bc64e
JH
1444
1445 dir->exclude_per_dir = ".gitignore";
1446 path = git_path("info/exclude");
dc79687e
HKNN
1447 if (!excludes_file) {
1448 home_config_paths(NULL, &xdg_path, "ignore");
1449 excludes_file = xdg_path;
1450 }
4698c8fe 1451 if (!access_or_warn(path, R_OK, 0))
039bc64e 1452 add_excludes_from_file(dir, path);
4698c8fe 1453 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))
039bc64e
JH
1454 add_excludes_from_file(dir, excludes_file);
1455}
4a92d1bf
AR
1456
1457int remove_path(const char *name)
1458{
1459 char *slash;
1460
9a6728d4 1461 if (unlink(name) && errno != ENOENT && errno != ENOTDIR)
4a92d1bf
AR
1462 return -1;
1463
1464 slash = strrchr(name, '/');
1465 if (slash) {
1466 char *dirs = xstrdup(name);
1467 slash = dirs + (slash - name);
1468 do {
1469 *slash = '\0';
3fc0d131 1470 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));
4a92d1bf
AR
1471 free(dirs);
1472 }
1473 return 0;
1474}
1475
823ab40f
JK
1476int limit_pathspec_to_literal(void)
1477{
1478 static int flag = -1;
1479 if (flag < 0)
1480 flag = git_env_bool(GIT_LITERAL_PATHSPECS_ENVIRONMENT, 0);
1481 return flag;
1482}
a39b15b4 1483
270be816
AS
1484/*
1485 * Frees memory within dir which was allocated for exclude lists and
1486 * the exclude_stack. Does not free dir itself.
1487 */
1488void clear_directory(struct dir_struct *dir)
1489{
1490 int i, j;
1491 struct exclude_list_group *group;
1492 struct exclude_list *el;
1493 struct exclude_stack *stk;
1494
1495 for (i = EXC_CMDL; i <= EXC_FILE; i++) {
1496 group = &dir->exclude_list_group[i];
1497 for (j = 0; j < group->nr; j++) {
1498 el = &group->el[j];
1499 if (i == EXC_DIRS)
1500 free((char *)el->src);
1501 clear_exclude_list(el);
1502 }
1503 free(group->el);
1504 }
1505
1506 stk = dir->exclude_stack;
1507 while (stk) {
1508 struct exclude_stack *prev = stk->prev;
1509 free(stk);
1510 stk = prev;
1511 }
1512}