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