]> git.ipfire.org Git - thirdparty/git.git/blame - dir.c
Git 2.31.1
[thirdparty/git.git] / dir.c
CommitLineData
453ec4bd
LT
1/*
2 * This handles recursive filename detection with exclude
3 * files, index knowledge etc..
4 *
5 * Copyright (C) Linus Torvalds, 2005-2006
6 * Junio Hamano, 2005-2006
7 */
453ec4bd 8#include "cache.h"
b2141fc1 9#include "config.h"
453ec4bd 10#include "dir.h"
cbd53a21 11#include "object-store.h"
b0db7046 12#include "attr.h"
09595258 13#include "refs.h"
237ec6e4 14#include "wildmatch.h"
64acde94 15#include "pathspec.h"
dde843e7 16#include "utf8.h"
83c094ad
NTND
17#include "varint.h"
18#include "ewah/ewok.h"
883e248b 19#include "fsmonitor.h"
da62f786 20#include "submodule-config.h"
453ec4bd 21
defd7c7b
KB
22/*
23 * Tells read_directory_recursive how a file or directory should be treated.
24 * Values are ordered by significance, e.g. if a directory contains both
25 * excluded and untracked files, it is listed as untracked because
26 * path_untracked > path_excluded.
27 */
28enum path_treatment {
29 path_none = 0,
30 path_recurse,
31 path_excluded,
32 path_untracked
33};
34
cf7c6148
NTND
35/*
36 * Support data structure for our opendir/readdir/closedir wrappers
37 */
38struct cached_dir {
39 DIR *fdir;
40 struct untracked_cache_dir *untracked;
91a2288b
NTND
41 int nr_files;
42 int nr_dirs;
43
ad6f2157
JK
44 const char *d_name;
45 int d_type;
91a2288b
NTND
46 const char *file;
47 struct untracked_cache_dir *ucd;
cf7c6148
NTND
48};
49
defd7c7b 50static enum path_treatment read_directory_recursive(struct dir_struct *dir,
0ef8e169
BW
51 struct index_state *istate, const char *path, int len,
52 struct untracked_cache_dir *untracked,
5aaa7fd3 53 int check_only, int stop_at_first_file, const struct pathspec *pathspec);
ad6f2157
JK
54static int resolve_dtype(int dtype, struct index_state *istate,
55 const char *path, int len);
09595258 56
eceba532
EN
57void dir_init(struct dir_struct *dir)
58{
59 memset(dir, 0, sizeof(*dir));
60}
61
e0556a92
PC
62int count_slashes(const char *s)
63{
64 int cnt = 0;
65 while (*s)
66 if (*s++ == '/')
67 cnt++;
68 return cnt;
69}
70
ba0897e6 71int fspathcmp(const char *a, const char *b)
8cf2a84e
JJ
72{
73 return ignore_case ? strcasecmp(a, b) : strcmp(a, b);
74}
75
ba0897e6 76int fspathncmp(const char *a, const char *b, size_t count)
8cf2a84e
JJ
77{
78 return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count);
79}
80
1f26ce61
CB
81int git_fnmatch(const struct pathspec_item *item,
82 const char *pattern, const char *string,
83 int prefix)
5d74762d 84{
5d74762d 85 if (prefix > 0) {
93d93537 86 if (ps_strncmp(item, pattern, string, prefix))
eb07894f 87 return WM_NOMATCH;
5d74762d
NTND
88 pattern += prefix;
89 string += prefix;
90 }
bd30c2e4 91 if (item->flags & PATHSPEC_ONESTAR) {
8c6abbcd
NTND
92 int pattern_len = strlen(++pattern);
93 int string_len = strlen(string);
94 return string_len < pattern_len ||
93d93537
NTND
95 ps_strcmp(item, pattern,
96 string + string_len - pattern_len);
8c6abbcd 97 }
bd30c2e4 98 if (item->magic & PATHSPEC_GLOB)
93d93537
NTND
99 return wildmatch(pattern, string,
100 WM_PATHNAME |
55d34269 101 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0));
bd30c2e4
NTND
102 else
103 /* wildmatch has not learned no FNM_PATHNAME mode yet */
eb07894f 104 return wildmatch(pattern, string,
55d34269 105 item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0);
5d74762d
NTND
106}
107
0b6e56df
JH
108static int fnmatch_icase_mem(const char *pattern, int patternlen,
109 const char *string, int stringlen,
110 int flags)
111{
112 int match_status;
113 struct strbuf pat_buf = STRBUF_INIT;
114 struct strbuf str_buf = STRBUF_INIT;
115 const char *use_pat = pattern;
116 const char *use_str = string;
117
118 if (pattern[patternlen]) {
119 strbuf_add(&pat_buf, pattern, patternlen);
120 use_pat = pat_buf.buf;
121 }
122 if (string[stringlen]) {
123 strbuf_add(&str_buf, string, stringlen);
124 use_str = str_buf.buf;
125 }
126
f30366b2
JH
127 if (ignore_case)
128 flags |= WM_CASEFOLD;
55d34269 129 match_status = wildmatch(use_pat, use_str, flags);
0b6e56df
JH
130
131 strbuf_release(&pat_buf);
132 strbuf_release(&str_buf);
133
134 return match_status;
135}
136
827f4d6c 137static size_t common_prefix_len(const struct pathspec *pathspec)
3c6a370b 138{
827f4d6c 139 int n;
4a085b16 140 size_t max = 0;
3c6a370b 141
93d93537
NTND
142 /*
143 * ":(icase)path" is treated as a pathspec full of
144 * wildcard. In other words, only prefix is considered common
145 * prefix. If the pathspec is abc/foo abc/bar, running in
bbbb6b0b 146 * subdir xyz, the common prefix is still xyz, not xyz/abc as
93d93537
NTND
147 * in non-:(icase).
148 */
5c6933d2
NTND
149 GUARD_PATHSPEC(pathspec,
150 PATHSPEC_FROMTOP |
151 PATHSPEC_MAXDEPTH |
bd30c2e4 152 PATHSPEC_LITERAL |
93d93537 153 PATHSPEC_GLOB |
ef79b1f8 154 PATHSPEC_ICASE |
b0db7046
BW
155 PATHSPEC_EXCLUDE |
156 PATHSPEC_ATTR);
4a085b16 157
827f4d6c 158 for (n = 0; n < pathspec->nr; n++) {
93d93537 159 size_t i = 0, len = 0, item_len;
ef79b1f8
NTND
160 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE)
161 continue;
93d93537
NTND
162 if (pathspec->items[n].magic & PATHSPEC_ICASE)
163 item_len = pathspec->items[n].prefix;
164 else
165 item_len = pathspec->items[n].nowildcard_len;
166 while (i < item_len && (n == 0 || i < max)) {
827f4d6c
NTND
167 char c = pathspec->items[n].match[i];
168 if (c != pathspec->items[0].match[i])
4a085b16
JH
169 break;
170 if (c == '/')
171 len = i + 1;
827f4d6c 172 i++;
4a085b16 173 }
827f4d6c 174 if (n == 0 || len < max) {
4a085b16
JH
175 max = len;
176 if (!max)
177 break;
178 }
3c6a370b 179 }
4a085b16 180 return max;
3c6a370b
LT
181}
182
f950eb95
CB
183/*
184 * Returns a copy of the longest leading path common among all
185 * pathspecs.
186 */
827f4d6c 187char *common_prefix(const struct pathspec *pathspec)
f950eb95
CB
188{
189 unsigned long len = common_prefix_len(pathspec);
190
827f4d6c 191 return len ? xmemdupz(pathspec->items[0].match, len) : NULL;
f950eb95
CB
192}
193
0d32c183
BW
194int fill_directory(struct dir_struct *dir,
195 struct index_state *istate,
196 const struct pathspec *pathspec)
1d8842d9 197{
bec5ab89 198 const char *prefix;
966de302 199 size_t prefix_len;
1d8842d9 200
351ea1c3
EN
201 unsigned exclusive_flags = DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO;
202 if ((dir->flags & exclusive_flags) == exclusive_flags)
203 BUG("DIR_SHOW_IGNORED and DIR_SHOW_IGNORED_TOO are exclusive");
204
1d8842d9
LT
205 /*
206 * Calculate common prefix for the pathspec, and
207 * use that to optimize the directory walk
208 */
bec5ab89
RS
209 prefix_len = common_prefix_len(pathspec);
210 prefix = prefix_len ? pathspec->items[0].match : "";
1d8842d9
LT
211
212 /* Read the directory and prune it */
0d32c183 213 read_directory(dir, istate, prefix, prefix_len, pathspec);
966de302 214
966de302 215 return prefix_len;
1d8842d9
LT
216}
217
bc96cc87
NTND
218int within_depth(const char *name, int namelen,
219 int depth, int max_depth)
220{
221 const char *cp = name, *cpe = name + namelen;
222
223 while (cp < cpe) {
224 if (*cp++ != '/')
225 continue;
226 depth++;
227 if (depth > max_depth)
228 return 0;
229 }
230 return 1;
231}
232
578d81d0
JH
233/*
234 * Read the contents of the blob with the given OID into a buffer.
235 * Append a trailing LF to the end if the last line doesn't have one.
236 *
237 * Returns:
238 * -1 when the OID is invalid or unknown or does not refer to a blob.
239 * 0 when the blob is empty.
240 * 1 along with { data, size } of the (possibly augmented) buffer
241 * when successful.
242 *
4b33e602 243 * Optionally updates the given oid_stat with the given OID (when valid).
578d81d0 244 */
4b33e602
PO
245static int do_read_blob(const struct object_id *oid, struct oid_stat *oid_stat,
246 size_t *size_out, char **data_out)
578d81d0
JH
247{
248 enum object_type type;
249 unsigned long sz;
250 char *data;
251
252 *size_out = 0;
253 *data_out = NULL;
254
b4f5aca4 255 data = read_object_file(oid, &type, &sz);
578d81d0
JH
256 if (!data || type != OBJ_BLOB) {
257 free(data);
258 return -1;
259 }
260
4b33e602
PO
261 if (oid_stat) {
262 memset(&oid_stat->stat, 0, sizeof(oid_stat->stat));
263 oidcpy(&oid_stat->oid, oid);
578d81d0
JH
264 }
265
266 if (sz == 0) {
267 free(data);
268 return 0;
269 }
270
271 if (data[sz - 1] != '\n') {
272 data = xrealloc(data, st_add(sz, 1));
273 data[sz++] = '\n';
274 }
275
276 *size_out = xsize_t(sz);
277 *data_out = data;
278
279 return 1;
280}
281
75a6315f
BW
282#define DO_MATCH_EXCLUDE (1<<0)
283#define DO_MATCH_DIRECTORY (1<<1)
a3d89d8f 284#define DO_MATCH_LEADING_PATHSPEC (1<<2)
42b0874a 285
61cf2820 286/*
29b577b9 287 * Does the given pathspec match the given name? A match is found if
61cf2820 288 *
29b577b9
EN
289 * (1) the pathspec string is leading directory of 'name' ("RECURSIVELY"), or
290 * (2) the pathspec string has a leading part matching 'name' ("LEADING"), or
291 * (3) the pathspec string is a wildcard and matches 'name' ("WILDCARD"), or
292 * (4) the pathspec string is exactly the same as 'name' ("EXACT").
61cf2820 293 *
29b577b9 294 * Return value tells which case it was (1-4), or 0 when there is no match.
61cf2820 295 *
29b577b9
EN
296 * It may be instructive to look at a small table of concrete examples
297 * to understand the differences between 1, 2, and 4:
298 *
299 * Pathspecs
300 * | a/b | a/b/ | a/b/c
301 * ------+-----------+-----------+------------
302 * a/b | EXACT | EXACT[1] | LEADING[2]
303 * Names a/b/ | RECURSIVE | EXACT | LEADING[2]
304 * a/b/c | RECURSIVE | RECURSIVE | EXACT
305 *
306 * [1] Only if DO_MATCH_DIRECTORY is passed; otherwise, this is NOT a match.
307 * [2] Only if DO_MATCH_LEADING_PATHSPEC is passed; otherwise, not a match.
61cf2820 308 */
6d2df284
NTND
309static int match_pathspec_item(const struct index_state *istate,
310 const struct pathspec_item *item, int prefix,
42b0874a 311 const char *name, int namelen, unsigned flags)
61cf2820
NTND
312{
313 /* name/namelen has prefix cut off by caller */
314 const char *match = item->match + prefix;
315 int matchlen = item->len - prefix;
316
93d93537
NTND
317 /*
318 * The normal call pattern is:
319 * 1. prefix = common_prefix_len(ps);
320 * 2. prune something, or fill_directory
854b0959 321 * 3. match_pathspec()
93d93537
NTND
322 *
323 * 'prefix' at #1 may be shorter than the command's prefix and
324 * it's ok for #2 to match extra files. Those extras will be
325 * trimmed at #3.
326 *
327 * Suppose the pathspec is 'foo' and '../bar' running from
328 * subdir 'xyz'. The common prefix at #1 will be empty, thanks
329 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The
330 * user does not want XYZ/foo, only the "foo" part should be
331 * case-insensitive. We need to filter out XYZ/foo here. In
332 * other words, we do not trust the caller on comparing the
333 * prefix part when :(icase) is involved. We do exact
334 * comparison ourselves.
335 *
336 * Normally the caller (common_prefix_len() in fact) does
337 * _exact_ matching on name[-prefix+1..-1] and we do not need
338 * to check that part. Be defensive and check it anyway, in
339 * case common_prefix_len is changed, or a new caller is
340 * introduced that does not use common_prefix_len.
341 *
342 * If the penalty turns out too high when prefix is really
343 * long, maybe change it to
344 * strncmp(match, name, item->prefix - prefix)
345 */
346 if (item->prefix && (item->magic & PATHSPEC_ICASE) &&
347 strncmp(item->match, name - prefix, item->prefix))
348 return 0;
349
22af33be
NTND
350 if (item->attr_match_nr &&
351 !match_pathspec_attrs(istate, name, namelen, item))
b0db7046
BW
352 return 0;
353
61cf2820
NTND
354 /* If the match was just the prefix, we matched */
355 if (!*match)
356 return MATCHED_RECURSIVELY;
357
93d93537 358 if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) {
61cf2820
NTND
359 if (matchlen == namelen)
360 return MATCHED_EXACTLY;
361
362 if (match[matchlen-1] == '/' || name[matchlen] == '/')
363 return MATCHED_RECURSIVELY;
68690fdd
NTND
364 } else if ((flags & DO_MATCH_DIRECTORY) &&
365 match[matchlen - 1] == '/' &&
366 namelen == matchlen - 1 &&
367 !ps_strncmp(item, match, name, namelen))
368 return MATCHED_EXACTLY;
61cf2820 369
5d74762d 370 if (item->nowildcard_len < item->len &&
bd30c2e4 371 !git_fnmatch(item, match, name,
8c6abbcd 372 item->nowildcard_len - prefix))
61cf2820
NTND
373 return MATCHED_FNMATCH;
374
29b577b9 375 /* Perform checks to see if "name" is a leading string of the pathspec */
f1f061e1
EN
376 if ( (flags & DO_MATCH_LEADING_PATHSPEC) &&
377 !(flags & DO_MATCH_EXCLUDE)) {
75a6315f 378 /* name is a literal prefix of the pathspec */
a5e916c7 379 int offset = name[namelen-1] == '/' ? 1 : 0;
75a6315f 380 if ((namelen < matchlen) &&
a5e916c7 381 (match[namelen-offset] == '/') &&
75a6315f 382 !ps_strncmp(item, match, name, namelen))
89a1f4aa 383 return MATCHED_RECURSIVELY_LEADING_PATHSPEC;
75a6315f 384
2f5d3847 385 /* name doesn't match up to the first wild character */
75a6315f
BW
386 if (item->nowildcard_len < item->len &&
387 ps_strncmp(item, match, name,
388 item->nowildcard_len - prefix))
389 return 0;
390
072a2310
EN
391 /*
392 * name has no wildcard, and it didn't match as a leading
393 * pathspec so return.
394 */
395 if (item->nowildcard_len == item->len)
396 return 0;
397
75a6315f
BW
398 /*
399 * Here is where we would perform a wildmatch to check if
400 * "name" can be matched as a directory (or a prefix) against
401 * the pathspec. Since wildmatch doesn't have this capability
402 * at the present we have to punt and say that it is a match,
403 * potentially returning a false positive
404 * The submodules themselves will be able to perform more
405 * accurate matching to determine if the pathspec matches.
406 */
89a1f4aa 407 return MATCHED_RECURSIVELY_LEADING_PATHSPEC;
75a6315f
BW
408 }
409
61cf2820
NTND
410 return 0;
411}
412
413/*
f1f061e1
EN
414 * do_match_pathspec() is meant to ONLY be called by
415 * match_pathspec_with_flags(); calling it directly risks pathspecs
416 * like ':!unwanted_path' being ignored.
417 *
52ed1894
AS
418 * Given a name and a list of pathspecs, returns the nature of the
419 * closest (i.e. most specific) match of the name to any of the
420 * pathspecs.
421 *
422 * The caller typically calls this multiple times with the same
423 * pathspec and seen[] array but with different name/namelen
424 * (e.g. entries from the index) and is interested in seeing if and
425 * how each pathspec matches all the names it calls this function
426 * with. A mark is left in the seen[] array for each pathspec element
427 * indicating the closest type of match that element achieved, so if
428 * seen[n] remains zero after multiple invocations, that means the nth
429 * pathspec did not match any names, which could indicate that the
430 * user mistyped the nth pathspec.
61cf2820 431 */
6d2df284
NTND
432static int do_match_pathspec(const struct index_state *istate,
433 const struct pathspec *ps,
854b0959
NTND
434 const char *name, int namelen,
435 int prefix, char *seen,
42b0874a 436 unsigned flags)
61cf2820 437{
42b0874a 438 int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE;
61cf2820 439
5c6933d2
NTND
440 GUARD_PATHSPEC(ps,
441 PATHSPEC_FROMTOP |
442 PATHSPEC_MAXDEPTH |
bd30c2e4 443 PATHSPEC_LITERAL |
93d93537 444 PATHSPEC_GLOB |
ef79b1f8 445 PATHSPEC_ICASE |
b0db7046
BW
446 PATHSPEC_EXCLUDE |
447 PATHSPEC_ATTR);
8f4f8f45 448
61cf2820 449 if (!ps->nr) {
6330a171
NTND
450 if (!ps->recursive ||
451 !(ps->magic & PATHSPEC_MAXDEPTH) ||
452 ps->max_depth == -1)
61cf2820
NTND
453 return MATCHED_RECURSIVELY;
454
455 if (within_depth(name, namelen, 0, ps->max_depth))
456 return MATCHED_EXACTLY;
457 else
458 return 0;
459 }
460
461 name += prefix;
462 namelen -= prefix;
463
464 for (i = ps->nr - 1; i >= 0; i--) {
465 int how;
ef79b1f8
NTND
466
467 if ((!exclude && ps->items[i].magic & PATHSPEC_EXCLUDE) ||
468 ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE)))
469 continue;
470
61cf2820
NTND
471 if (seen && seen[i] == MATCHED_EXACTLY)
472 continue;
ef79b1f8
NTND
473 /*
474 * Make exclude patterns optional and never report
475 * "pathspec ':(exclude)foo' matches no files"
476 */
477 if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE)
478 seen[i] = MATCHED_FNMATCH;
6d2df284 479 how = match_pathspec_item(istate, ps->items+i, prefix, name,
42b0874a 480 namelen, flags);
6330a171
NTND
481 if (ps->recursive &&
482 (ps->magic & PATHSPEC_MAXDEPTH) &&
483 ps->max_depth != -1 &&
61cf2820
NTND
484 how && how != MATCHED_FNMATCH) {
485 int len = ps->items[i].len;
486 if (name[len] == '/')
487 len++;
488 if (within_depth(name+len, namelen-len, 0, ps->max_depth))
489 how = MATCHED_EXACTLY;
490 else
491 how = 0;
492 }
493 if (how) {
494 if (retval < how)
495 retval = how;
496 if (seen && seen[i] < how)
497 seen[i] = how;
498 }
499 }
500 return retval;
501}
502
f1f061e1
EN
503static int match_pathspec_with_flags(const struct index_state *istate,
504 const struct pathspec *ps,
505 const char *name, int namelen,
506 int prefix, char *seen, unsigned flags)
ef79b1f8
NTND
507{
508 int positive, negative;
6d2df284 509 positive = do_match_pathspec(istate, ps, name, namelen,
42b0874a 510 prefix, seen, flags);
ef79b1f8
NTND
511 if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive)
512 return positive;
6d2df284 513 negative = do_match_pathspec(istate, ps, name, namelen,
42b0874a
NTND
514 prefix, seen,
515 flags | DO_MATCH_EXCLUDE);
ef79b1f8
NTND
516 return negative ? 0 : positive;
517}
518
f1f061e1
EN
519int match_pathspec(const struct index_state *istate,
520 const struct pathspec *ps,
521 const char *name, int namelen,
522 int prefix, char *seen, int is_dir)
523{
524 unsigned flags = is_dir ? DO_MATCH_DIRECTORY : 0;
525 return match_pathspec_with_flags(istate, ps, name, namelen,
526 prefix, seen, flags);
527}
528
75a6315f
BW
529/**
530 * Check if a submodule is a superset of the pathspec
531 */
6d2df284
NTND
532int submodule_path_match(const struct index_state *istate,
533 const struct pathspec *ps,
75a6315f
BW
534 const char *submodule_name,
535 char *seen)
536{
f1f061e1
EN
537 int matched = match_pathspec_with_flags(istate, ps, submodule_name,
538 strlen(submodule_name),
539 0, seen,
540 DO_MATCH_DIRECTORY |
541 DO_MATCH_LEADING_PATHSPEC);
75a6315f
BW
542 return matched;
543}
544
777c55a6 545int report_path_error(const char *ps_matched,
c5c33504 546 const struct pathspec *pathspec)
777c55a6
JH
547{
548 /*
549 * Make sure all pathspec matched; otherwise it is an error.
550 */
777c55a6
JH
551 int num, errors = 0;
552 for (num = 0; num < pathspec->nr; num++) {
553 int other, found_dup;
554
555 if (ps_matched[num])
556 continue;
557 /*
558 * The caller might have fed identical pathspec
559 * twice. Do not barf on such a mistake.
560 * FIXME: parse_pathspec should have eliminated
561 * duplicate pathspec.
562 */
563 for (found_dup = other = 0;
564 !found_dup && other < pathspec->nr;
565 other++) {
566 if (other == num || !ps_matched[other])
567 continue;
568 if (!strcmp(pathspec->items[other].original,
569 pathspec->items[num].original))
570 /*
571 * Ok, we have a match already.
572 */
573 found_dup = 1;
574 }
575 if (found_dup)
576 continue;
577
a80897c1 578 error(_("pathspec '%s' did not match any file(s) known to git"),
777c55a6
JH
579 pathspec->items[num].original);
580 errors++;
581 }
777c55a6
JH
582 return errors;
583}
584
fcd631ed
NTND
585/*
586 * Return the length of the "simple" part of a path match limiter.
587 */
87323bda 588int simple_length(const char *match)
fcd631ed
NTND
589{
590 int len = -1;
591
592 for (;;) {
593 unsigned char c = *match++;
594 len++;
595 if (c == '\0' || is_glob_special(c))
596 return len;
597 }
598}
599
87323bda 600int no_wildcard(const char *string)
68492fc7 601{
fcd631ed 602 return string[simple_length(string)] == '\0';
68492fc7
LK
603}
604
65edd96a 605void parse_path_pattern(const char **pattern,
82dce998 606 int *patternlen,
f8708998 607 unsigned *flags,
82dce998 608 int *nowildcardlen)
84460eec
NTND
609{
610 const char *p = *pattern;
611 size_t i, len;
612
613 *flags = 0;
614 if (*p == '!') {
4ff89ee5 615 *flags |= PATTERN_FLAG_NEGATIVE;
84460eec
NTND
616 p++;
617 }
618 len = strlen(p);
619 if (len && p[len - 1] == '/') {
620 len--;
4ff89ee5 621 *flags |= PATTERN_FLAG_MUSTBEDIR;
84460eec
NTND
622 }
623 for (i = 0; i < len; i++) {
624 if (p[i] == '/')
625 break;
626 }
627 if (i == len)
4ff89ee5 628 *flags |= PATTERN_FLAG_NODIR;
84460eec
NTND
629 *nowildcardlen = simple_length(p);
630 /*
631 * we should have excluded the trailing slash from 'p' too,
632 * but that's one more allocation. Instead just make sure
633 * nowildcardlen does not exceed real patternlen
634 */
635 if (*nowildcardlen > len)
636 *nowildcardlen = len;
637 if (*p == '*' && no_wildcard(p + 1))
4ff89ee5 638 *flags |= PATTERN_FLAG_ENDSWITH;
84460eec
NTND
639 *pattern = p;
640 *patternlen = len;
641}
642
af09ce24
DS
643int pl_hashmap_cmp(const void *unused_cmp_data,
644 const struct hashmap_entry *a,
645 const struct hashmap_entry *b,
646 const void *key)
96cc8ab5
DS
647{
648 const struct pattern_entry *ee1 =
649 container_of(a, struct pattern_entry, ent);
650 const struct pattern_entry *ee2 =
651 container_of(b, struct pattern_entry, ent);
652
653 size_t min_len = ee1->patternlen <= ee2->patternlen
654 ? ee1->patternlen
655 : ee2->patternlen;
656
190a65f9
DS
657 if (ignore_case)
658 return strncasecmp(ee1->pattern, ee2->pattern, min_len);
96cc8ab5
DS
659 return strncmp(ee1->pattern, ee2->pattern, min_len);
660}
661
4f52c2ce
DS
662static char *dup_and_filter_pattern(const char *pattern)
663{
664 char *set, *read;
665 size_t count = 0;
666 char *result = xstrdup(pattern);
667
668 set = result;
669 read = result;
670
671 while (*read) {
672 /* skip escape characters (once) */
673 if (*read == '\\')
674 read++;
675
676 *set = *read;
677
678 set++;
679 read++;
680 count++;
681 }
682 *set = 0;
683
684 if (count > 2 &&
685 *(set - 1) == '*' &&
686 *(set - 2) == '/')
687 *(set - 2) = 0;
688
689 return result;
690}
691
96cc8ab5
DS
692static void add_pattern_to_hashsets(struct pattern_list *pl, struct path_pattern *given)
693{
694 struct pattern_entry *translated;
695 char *truncated;
696 char *data = NULL;
9abc60f8 697 const char *prev, *cur, *next;
96cc8ab5
DS
698
699 if (!pl->use_cone_patterns)
700 return;
701
702 if (given->flags & PATTERN_FLAG_NEGATIVE &&
703 given->flags & PATTERN_FLAG_MUSTBEDIR &&
704 !strcmp(given->pattern, "/*")) {
705 pl->full_cone = 0;
706 return;
707 }
708
709 if (!given->flags && !strcmp(given->pattern, "/*")) {
710 pl->full_cone = 1;
711 return;
712 }
713
6c11c6a1 714 if (given->patternlen < 2 ||
9abc60f8 715 *given->pattern == '*' ||
9e6d3e64 716 strstr(given->pattern, "**")) {
41de0c6f
DS
717 /* Not a cone pattern. */
718 warning(_("unrecognized pattern: '%s'"), given->pattern);
719 goto clear_hashmaps;
720 }
721
9abc60f8
DS
722 prev = given->pattern;
723 cur = given->pattern + 1;
724 next = given->pattern + 2;
725
726 while (*cur) {
727 /* Watch for glob characters '*', '\', '[', '?' */
728 if (!is_glob_special(*cur))
729 goto increment;
730
731 /* But only if *prev != '\\' */
732 if (*prev == '\\')
733 goto increment;
734
735 /* But allow the initial '\' */
736 if (*cur == '\\' &&
737 is_glob_special(*next))
738 goto increment;
739
740 /* But a trailing '/' then '*' is fine */
741 if (*prev == '/' &&
742 *cur == '*' &&
743 *next == 0)
744 goto increment;
745
746 /* Not a cone pattern. */
747 warning(_("unrecognized pattern: '%s'"), given->pattern);
748 goto clear_hashmaps;
749
750 increment:
751 prev++;
752 cur++;
753 next++;
754 }
755
96cc8ab5
DS
756 if (given->patternlen > 2 &&
757 !strcmp(given->pattern + given->patternlen - 2, "/*")) {
758 if (!(given->flags & PATTERN_FLAG_NEGATIVE)) {
759 /* Not a cone pattern. */
96cc8ab5
DS
760 warning(_("unrecognized pattern: '%s'"), given->pattern);
761 goto clear_hashmaps;
762 }
763
4f52c2ce 764 truncated = dup_and_filter_pattern(given->pattern);
96cc8ab5
DS
765
766 translated = xmalloc(sizeof(struct pattern_entry));
767 translated->pattern = truncated;
768 translated->patternlen = given->patternlen - 2;
769 hashmap_entry_init(&translated->ent,
190a65f9
DS
770 ignore_case ?
771 strihash(translated->pattern) :
772 strhash(translated->pattern));
96cc8ab5
DS
773
774 if (!hashmap_get_entry(&pl->recursive_hashmap,
775 translated, ent, NULL)) {
776 /* We did not see the "parent" included */
777 warning(_("unrecognized negative pattern: '%s'"),
778 given->pattern);
779 free(truncated);
780 free(translated);
781 goto clear_hashmaps;
782 }
783
784 hashmap_add(&pl->parent_hashmap, &translated->ent);
785 hashmap_remove(&pl->recursive_hashmap, &translated->ent, &data);
786 free(data);
787 return;
788 }
789
790 if (given->flags & PATTERN_FLAG_NEGATIVE) {
791 warning(_("unrecognized negative pattern: '%s'"),
792 given->pattern);
793 goto clear_hashmaps;
794 }
795
796 translated = xmalloc(sizeof(struct pattern_entry));
797
4f52c2ce 798 translated->pattern = dup_and_filter_pattern(given->pattern);
96cc8ab5
DS
799 translated->patternlen = given->patternlen;
800 hashmap_entry_init(&translated->ent,
190a65f9
DS
801 ignore_case ?
802 strihash(translated->pattern) :
803 strhash(translated->pattern));
96cc8ab5
DS
804
805 hashmap_add(&pl->recursive_hashmap, &translated->ent);
806
807 if (hashmap_get_entry(&pl->parent_hashmap, translated, ent, NULL)) {
808 /* we already included this at the parent level */
809 warning(_("your sparse-checkout file may have issues: pattern '%s' is repeated"),
810 given->pattern);
811 hashmap_remove(&pl->parent_hashmap, &translated->ent, &data);
812 free(data);
813 free(translated);
814 }
815
816 return;
817
818clear_hashmaps:
819 warning(_("disabling cone pattern matching"));
6da1a258
EN
820 hashmap_clear_and_free(&pl->parent_hashmap, struct pattern_entry, ent);
821 hashmap_clear_and_free(&pl->recursive_hashmap, struct pattern_entry, ent);
96cc8ab5
DS
822 pl->use_cone_patterns = 0;
823}
824
825static int hashmap_contains_path(struct hashmap *map,
826 struct strbuf *pattern)
827{
828 struct pattern_entry p;
829
830 /* Check straight mapping */
831 p.pattern = pattern->buf;
832 p.patternlen = pattern->len;
190a65f9
DS
833 hashmap_entry_init(&p.ent,
834 ignore_case ?
835 strihash(p.pattern) :
836 strhash(p.pattern));
96cc8ab5
DS
837 return !!hashmap_get_entry(map, &p, ent, NULL);
838}
839
840int hashmap_contains_parent(struct hashmap *map,
841 const char *path,
842 struct strbuf *buffer)
843{
844 char *slash_pos;
845
846 strbuf_setlen(buffer, 0);
847
848 if (path[0] != '/')
849 strbuf_addch(buffer, '/');
850
851 strbuf_addstr(buffer, path);
852
853 slash_pos = strrchr(buffer->buf, '/');
854
855 while (slash_pos > buffer->buf) {
856 strbuf_setlen(buffer, slash_pos - buffer->buf);
857
858 if (hashmap_contains_path(map, buffer))
859 return 1;
860
861 slash_pos = strrchr(buffer->buf, '/');
862 }
863
864 return 0;
865}
866
65edd96a 867void add_pattern(const char *string, const char *base,
caa3d554 868 int baselen, struct pattern_list *pl, int srcpos)
453ec4bd 869{
ab8db613 870 struct path_pattern *pattern;
84460eec 871 int patternlen;
f8708998 872 unsigned flags;
84460eec 873 int nowildcardlen;
453ec4bd 874
65edd96a 875 parse_path_pattern(&string, &patternlen, &flags, &nowildcardlen);
4ff89ee5 876 if (flags & PATTERN_FLAG_MUSTBEDIR) {
ab8db613 877 FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen);
d6b8fc30 878 } else {
ab8db613
DS
879 pattern = xmalloc(sizeof(*pattern));
880 pattern->pattern = string;
d6b8fc30 881 }
ab8db613
DS
882 pattern->patternlen = patternlen;
883 pattern->nowildcardlen = nowildcardlen;
884 pattern->base = base;
885 pattern->baselen = baselen;
886 pattern->flags = flags;
887 pattern->srcpos = srcpos;
caa3d554
DS
888 ALLOC_GROW(pl->patterns, pl->nr + 1, pl->alloc);
889 pl->patterns[pl->nr++] = pattern;
890 pattern->pl = pl;
96cc8ab5
DS
891
892 add_pattern_to_hashsets(pl, pattern);
453ec4bd
LT
893}
894
578d81d0
JH
895static int read_skip_worktree_file_from_index(const struct index_state *istate,
896 const char *path,
4b33e602
PO
897 size_t *size_out, char **data_out,
898 struct oid_stat *oid_stat)
c28b3d6e
NTND
899{
900 int pos, len;
c28b3d6e
NTND
901
902 len = strlen(path);
6f52b741 903 pos = index_name_pos(istate, path, len);
c28b3d6e 904 if (pos < 0)
578d81d0 905 return -1;
6f52b741 906 if (!ce_skip_worktree(istate->cache[pos]))
578d81d0
JH
907 return -1;
908
4b33e602 909 return do_read_blob(&istate->cache[pos]->oid, oid_stat, size_out, data_out);
c28b3d6e
NTND
910}
911
f6198812 912/*
caa3d554
DS
913 * Frees memory within pl which was allocated for exclude patterns and
914 * the file buffer. Does not free pl itself.
f6198812 915 */
65edd96a 916void clear_pattern_list(struct pattern_list *pl)
0fd0e241
NTND
917{
918 int i;
919
caa3d554
DS
920 for (i = 0; i < pl->nr; i++)
921 free(pl->patterns[i]);
922 free(pl->patterns);
923 free(pl->filebuf);
6da1a258
EN
924 hashmap_clear_and_free(&pl->recursive_hashmap, struct pattern_entry, ent);
925 hashmap_clear_and_free(&pl->parent_hashmap, struct pattern_entry, ent);
0fd0e241 926
caa3d554 927 memset(pl, 0, sizeof(*pl));
0fd0e241
NTND
928}
929
7e2e4b37 930static void trim_trailing_spaces(char *buf)
16402b99 931{
e61a6c1d
PB
932 char *p, *last_space = NULL;
933
934 for (p = buf; *p; p++)
935 switch (*p) {
936 case ' ':
937 if (!last_space)
938 last_space = p;
939 break;
940 case '\\':
941 p++;
942 if (!*p)
943 return;
944 /* fallthrough */
945 default:
946 last_space = NULL;
947 }
948
949 if (last_space)
950 *last_space = '\0';
16402b99
NTND
951}
952
0dcb8d7f
NTND
953/*
954 * Given a subdirectory name and "dir" of the current directory,
955 * search the subdir in "dir" and return it, or create a new one if it
956 * does not exist in "dir".
957 *
958 * If "name" has the trailing slash, it'll be excluded in the search.
959 */
960static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc,
961 struct untracked_cache_dir *dir,
962 const char *name, int len)
963{
964 int first, last;
965 struct untracked_cache_dir *d;
966 if (!dir)
967 return NULL;
968 if (len && name[len - 1] == '/')
969 len--;
970 first = 0;
971 last = dir->dirs_nr;
972 while (last > first) {
568a05c5 973 int cmp, next = first + ((last - first) >> 1);
0dcb8d7f
NTND
974 d = dir->dirs[next];
975 cmp = strncmp(name, d->name, len);
976 if (!cmp && strlen(d->name) > len)
977 cmp = -1;
978 if (!cmp)
979 return d;
980 if (cmp < 0) {
981 last = next;
982 continue;
983 }
984 first = next+1;
985 }
986
987 uc->dir_created++;
96ffc06f 988 FLEX_ALLOC_MEM(d, name, name, len);
0dcb8d7f
NTND
989
990 ALLOC_GROW(dir->dirs, dir->dirs_nr + 1, dir->dirs_alloc);
f919ffeb
SG
991 MOVE_ARRAY(dir->dirs + first + 1, dir->dirs + first,
992 dir->dirs_nr - first);
0dcb8d7f
NTND
993 dir->dirs_nr++;
994 dir->dirs[first] = d;
995 return d;
996}
997
ccad261f
NTND
998static void do_invalidate_gitignore(struct untracked_cache_dir *dir)
999{
1000 int i;
1001 dir->valid = 0;
1002 dir->untracked_nr = 0;
1003 for (i = 0; i < dir->dirs_nr; i++)
1004 do_invalidate_gitignore(dir->dirs[i]);
1005}
1006
1007static void invalidate_gitignore(struct untracked_cache *uc,
1008 struct untracked_cache_dir *dir)
1009{
1010 uc->gitignore_invalidated++;
1011 do_invalidate_gitignore(dir);
1012}
1013
91a2288b
NTND
1014static void invalidate_directory(struct untracked_cache *uc,
1015 struct untracked_cache_dir *dir)
1016{
26cb0182 1017 int i;
b6403131
NTND
1018
1019 /*
1020 * Invalidation increment here is just roughly correct. If
1021 * untracked_nr or any of dirs[].recurse is non-zero, we
1022 * should increment dir_invalidated too. But that's more
1023 * expensive to do.
1024 */
1025 if (dir->valid)
1026 uc->dir_invalidated++;
1027
91a2288b
NTND
1028 dir->valid = 0;
1029 dir->untracked_nr = 0;
26cb0182
NTND
1030 for (i = 0; i < dir->dirs_nr; i++)
1031 dir->dirs[i]->recurse = 0;
91a2288b
NTND
1032}
1033
65edd96a 1034static int add_patterns_from_buffer(char *buf, size_t size,
578d81d0 1035 const char *base, int baselen,
caa3d554 1036 struct pattern_list *pl);
578d81d0 1037
55fe6f51
NTND
1038/*
1039 * Given a file with name "fname", read it (either from disk, or from
473e3930 1040 * an index if 'istate' is non-null), parse it and store the
caa3d554 1041 * exclude rules in "pl".
55fe6f51 1042 *
e5cf6d3d 1043 * If "oid_stat" is not NULL, compute oid of the exclude file and fill
65edd96a 1044 * stat data from disk (only valid if add_patterns returns zero). If
e5cf6d3d 1045 * oid_stat.valid is non-zero, "oid_stat" must contain good value as input.
55fe6f51 1046 */
65edd96a 1047static int add_patterns(const char *fname, const char *base, int baselen,
caa3d554 1048 struct pattern_list *pl, struct index_state *istate,
4b33e602 1049 struct oid_stat *oid_stat)
453ec4bd 1050{
c470701a 1051 struct stat st;
578d81d0
JH
1052 int r;
1053 int fd;
9d14017a 1054 size_t size = 0;
578d81d0 1055 char *buf;
453ec4bd
LT
1056
1057 fd = open(fname, O_RDONLY);
c28b3d6e 1058 if (fd < 0 || fstat(fd, &st) < 0) {
11dc1fcb
NTND
1059 if (fd < 0)
1060 warn_on_fopen_errors(fname);
1061 else
c28b3d6e 1062 close(fd);
578d81d0 1063 if (!istate)
c28b3d6e 1064 return -1;
578d81d0
JH
1065 r = read_skip_worktree_file_from_index(istate, fname,
1066 &size, &buf,
4b33e602 1067 oid_stat);
578d81d0
JH
1068 if (r != 1)
1069 return r;
d961baa8 1070 } else {
c28b3d6e
NTND
1071 size = xsize_t(st.st_size);
1072 if (size == 0) {
4b33e602
PO
1073 if (oid_stat) {
1074 fill_stat_data(&oid_stat->stat, &st);
ba2df751 1075 oidcpy(&oid_stat->oid, the_hash_algo->empty_blob);
4b33e602 1076 oid_stat->valid = 1;
55fe6f51 1077 }
c28b3d6e
NTND
1078 close(fd);
1079 return 0;
1080 }
3733e694 1081 buf = xmallocz(size);
c28b3d6e 1082 if (read_in_full(fd, buf, size) != size) {
45d76f17 1083 free(buf);
c28b3d6e
NTND
1084 close(fd);
1085 return -1;
1086 }
45d76f17 1087 buf[size++] = '\n';
c28b3d6e 1088 close(fd);
4b33e602 1089 if (oid_stat) {
55fe6f51 1090 int pos;
4b33e602
PO
1091 if (oid_stat->valid &&
1092 !match_stat_data_racy(istate, &oid_stat->stat, &st))
e5cf6d3d 1093 ; /* no content change, oid_stat->oid still good */
473e3930
BW
1094 else if (istate &&
1095 (pos = index_name_pos(istate, fname, strlen(fname))) >= 0 &&
1096 !ce_stage(istate->cache[pos]) &&
1097 ce_uptodate(istate->cache[pos]) &&
82b474e0 1098 !would_convert_to_git(istate, fname))
4b33e602
PO
1099 oidcpy(&oid_stat->oid,
1100 &istate->cache[pos]->oid);
55fe6f51 1101 else
2dcde20e
MT
1102 hash_object_file(the_hash_algo, buf, size,
1103 "blob", &oid_stat->oid);
4b33e602
PO
1104 fill_stat_data(&oid_stat->stat, &st);
1105 oid_stat->valid = 1;
55fe6f51 1106 }
6ba78238 1107 }
453ec4bd 1108
65edd96a 1109 add_patterns_from_buffer(buf, size, base, baselen, pl);
578d81d0
JH
1110 return 0;
1111}
1112
65edd96a 1113static int add_patterns_from_buffer(char *buf, size_t size,
578d81d0 1114 const char *base, int baselen,
caa3d554 1115 struct pattern_list *pl)
578d81d0
JH
1116{
1117 int i, lineno = 1;
1118 char *entry;
1119
96cc8ab5
DS
1120 hashmap_init(&pl->recursive_hashmap, pl_hashmap_cmp, NULL, 0);
1121 hashmap_init(&pl->parent_hashmap, pl_hashmap_cmp, NULL, 0);
1122
caa3d554 1123 pl->filebuf = buf;
245e1c19 1124
dde843e7 1125 if (skip_utf8_bom(&buf, size))
caa3d554 1126 size -= buf - pl->filebuf;
dde843e7 1127
453ec4bd 1128 entry = buf;
245e1c19 1129
45d76f17
NTND
1130 for (i = 0; i < size; i++) {
1131 if (buf[i] == '\n') {
453ec4bd
LT
1132 if (entry != buf + i && entry[0] != '#') {
1133 buf[i - (i && buf[i-1] == '\r')] = 0;
7e2e4b37 1134 trim_trailing_spaces(entry);
65edd96a 1135 add_pattern(entry, base, baselen, pl, lineno);
453ec4bd 1136 }
c04318e4 1137 lineno++;
453ec4bd
LT
1138 entry = buf + i + 1;
1139 }
1140 }
1141 return 0;
453ec4bd
LT
1142}
1143
65edd96a 1144int add_patterns_from_file_to_list(const char *fname, const char *base,
caa3d554 1145 int baselen, struct pattern_list *pl,
473e3930 1146 struct index_state *istate)
55fe6f51 1147{
65edd96a 1148 return add_patterns(fname, base, baselen, pl, istate, NULL);
55fe6f51
NTND
1149}
1150
65edd96a 1151int add_patterns_from_blob_to_list(
578d81d0
JH
1152 struct object_id *oid,
1153 const char *base, int baselen,
caa3d554 1154 struct pattern_list *pl)
578d81d0
JH
1155{
1156 char *buf;
1157 size_t size;
1158 int r;
1159
1160 r = do_read_blob(oid, NULL, &size, &buf);
1161 if (r != 1)
1162 return r;
1163
65edd96a 1164 add_patterns_from_buffer(buf, size, base, baselen, pl);
578d81d0
JH
1165 return 0;
1166}
1167
65edd96a 1168struct pattern_list *add_pattern_list(struct dir_struct *dir,
c04318e4 1169 int group_type, const char *src)
c082df24 1170{
caa3d554 1171 struct pattern_list *pl;
c082df24
AS
1172 struct exclude_list_group *group;
1173
1174 group = &dir->exclude_list_group[group_type];
caa3d554
DS
1175 ALLOC_GROW(group->pl, group->nr + 1, group->alloc);
1176 pl = &group->pl[group->nr++];
1177 memset(pl, 0, sizeof(*pl));
1178 pl->src = src;
1179 return pl;
c082df24
AS
1180}
1181
1182/*
1183 * Used to set up core.excludesfile and .git/info/exclude lists.
1184 */
65edd96a 1185static void add_patterns_from_file_1(struct dir_struct *dir, const char *fname,
4b33e602 1186 struct oid_stat *oid_stat)
453ec4bd 1187{
caa3d554 1188 struct pattern_list *pl;
ccad261f
NTND
1189 /*
1190 * catch setup_standard_excludes() that's called before
1191 * dir->untracked is assigned. That function behaves
1192 * differently when dir->untracked is non-NULL.
1193 */
1194 if (!dir->untracked)
1195 dir->unmanaged_exclude_files++;
65edd96a
DS
1196 pl = add_pattern_list(dir, EXC_FILE, fname);
1197 if (add_patterns(fname, "", 0, pl, NULL, oid_stat) < 0)
a80897c1 1198 die(_("cannot use %s as an exclude file"), fname);
453ec4bd
LT
1199}
1200
65edd96a 1201void add_patterns_from_file(struct dir_struct *dir, const char *fname)
0dcb8d7f 1202{
ccad261f 1203 dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */
65edd96a 1204 add_patterns_from_file_1(dir, fname, NULL);
0dcb8d7f
NTND
1205}
1206
82dce998
NTND
1207int match_basename(const char *basename, int basenamelen,
1208 const char *pattern, int prefix, int patternlen,
f8708998 1209 unsigned flags)
593cb880
NTND
1210{
1211 if (prefix == patternlen) {
0b6e56df 1212 if (patternlen == basenamelen &&
ba0897e6 1213 !fspathncmp(pattern, basename, basenamelen))
593cb880 1214 return 1;
4ff89ee5 1215 } else if (flags & PATTERN_FLAG_ENDSWITH) {
0b6e56df 1216 /* "*literal" matching against "fooliteral" */
593cb880 1217 if (patternlen - 1 <= basenamelen &&
ba0897e6 1218 !fspathncmp(pattern + 1,
0b6e56df
JH
1219 basename + basenamelen - (patternlen - 1),
1220 patternlen - 1))
593cb880
NTND
1221 return 1;
1222 } else {
0b6e56df
JH
1223 if (fnmatch_icase_mem(pattern, patternlen,
1224 basename, basenamelen,
1225 0) == 0)
593cb880
NTND
1226 return 1;
1227 }
1228 return 0;
1229}
1230
82dce998
NTND
1231int match_pathname(const char *pathname, int pathlen,
1232 const char *base, int baselen,
1233 const char *pattern, int prefix, int patternlen,
f8708998 1234 unsigned flags)
b5592632
NTND
1235{
1236 const char *name;
1237 int namelen;
1238
1239 /*
1240 * match with FNM_PATHNAME; the pattern has base implicitly
1241 * in front of it.
1242 */
1243 if (*pattern == '/') {
1244 pattern++;
982ac873 1245 patternlen--;
b5592632
NTND
1246 prefix--;
1247 }
1248
1249 /*
1250 * baselen does not count the trailing slash. base[] may or
1251 * may not end with a trailing slash though.
1252 */
1253 if (pathlen < baselen + 1 ||
1254 (baselen && pathname[baselen] != '/') ||
ba0897e6 1255 fspathncmp(pathname, base, baselen))
b5592632
NTND
1256 return 0;
1257
1258 namelen = baselen ? pathlen - baselen - 1 : pathlen;
1259 name = pathname + pathlen - namelen;
1260
1261 if (prefix) {
1262 /*
1263 * if the non-wildcard part is longer than the
1264 * remaining pathname, surely it cannot match.
1265 */
1266 if (prefix > namelen)
1267 return 0;
1268
ba0897e6 1269 if (fspathncmp(pattern, name, prefix))
b5592632
NTND
1270 return 0;
1271 pattern += prefix;
ab3aebc1 1272 patternlen -= prefix;
b5592632
NTND
1273 name += prefix;
1274 namelen -= prefix;
ab3aebc1
JK
1275
1276 /*
1277 * If the whole pattern did not have a wildcard,
1278 * then our prefix match is all we need; we
1279 * do not need to call fnmatch at all.
1280 */
5cee3493 1281 if (!patternlen && !namelen)
ab3aebc1 1282 return 1;
b5592632
NTND
1283 }
1284
ab3aebc1
JK
1285 return fnmatch_icase_mem(pattern, patternlen,
1286 name, namelen,
f30366b2 1287 WM_PATHNAME) == 0;
b5592632
NTND
1288}
1289
578cd7c3
AS
1290/*
1291 * Scan the given exclude list in reverse to see whether pathname
1292 * should be ignored. The first match (i.e. the last on the list), if
1293 * any, determines the fate. Returns the exclude_list element which
1294 * matched, or NULL for undecided.
453ec4bd 1295 */
65edd96a 1296static struct path_pattern *last_matching_pattern_from_list(const char *pathname,
578cd7c3
AS
1297 int pathlen,
1298 const char *basename,
1299 int *dtype,
caa3d554 1300 struct pattern_list *pl,
2b70e88d 1301 struct index_state *istate)
453ec4bd 1302{
ab8db613 1303 struct path_pattern *res = NULL; /* undecided */
5cee3493 1304 int i;
453ec4bd 1305
caa3d554 1306 if (!pl->nr)
578cd7c3 1307 return NULL; /* undefined */
d6b8fc30 1308
caa3d554
DS
1309 for (i = pl->nr - 1; 0 <= i; i--) {
1310 struct path_pattern *pattern = pl->patterns[i];
ab8db613
DS
1311 const char *exclude = pattern->pattern;
1312 int prefix = pattern->nowildcardlen;
35a94d44 1313
4ff89ee5 1314 if (pattern->flags & PATTERN_FLAG_MUSTBEDIR) {
ad6f2157 1315 *dtype = resolve_dtype(*dtype, istate, pathname, pathlen);
35a94d44
NTND
1316 if (*dtype != DT_DIR)
1317 continue;
1318 }
d6b8fc30 1319
4ff89ee5 1320 if (pattern->flags & PATTERN_FLAG_NODIR) {
593cb880
NTND
1321 if (match_basename(basename,
1322 pathlen - (basename - pathname),
ab8db613
DS
1323 exclude, prefix, pattern->patternlen,
1324 pattern->flags)) {
1325 res = pattern;
e6efecc4
NTND
1326 break;
1327 }
35a94d44
NTND
1328 continue;
1329 }
1330
ab8db613
DS
1331 assert(pattern->baselen == 0 ||
1332 pattern->base[pattern->baselen - 1] == '/');
b5592632 1333 if (match_pathname(pathname, pathlen,
ab8db613
DS
1334 pattern->base,
1335 pattern->baselen ? pattern->baselen - 1 : 0,
1336 exclude, prefix, pattern->patternlen,
1337 pattern->flags)) {
1338 res = pattern;
e6efecc4
NTND
1339 break;
1340 }
453ec4bd 1341 }
ab8db613 1342 return res;
578cd7c3
AS
1343}
1344
1345/*
468ce99b
DS
1346 * Scan the list of patterns to determine if the ordered list
1347 * of patterns matches on 'pathname'.
1348 *
1349 * Return 1 for a match, 0 for not matched and -1 for undecided.
578cd7c3 1350 */
468ce99b
DS
1351enum pattern_match_result path_matches_pattern_list(
1352 const char *pathname, int pathlen,
1353 const char *basename, int *dtype,
1354 struct pattern_list *pl,
1355 struct index_state *istate)
578cd7c3 1356{
ab8db613 1357 struct path_pattern *pattern;
96cc8ab5
DS
1358 struct strbuf parent_pathname = STRBUF_INIT;
1359 int result = NOT_MATCHED;
1360 const char *slash_pos;
1361
1362 if (!pl->use_cone_patterns) {
1363 pattern = last_matching_pattern_from_list(pathname, pathlen, basename,
1364 dtype, pl, istate);
1365 if (pattern) {
1366 if (pattern->flags & PATTERN_FLAG_NEGATIVE)
1367 return NOT_MATCHED;
1368 else
1369 return MATCHED;
1370 }
1371
1372 return UNDECIDED;
1373 }
1374
1375 if (pl->full_cone)
1376 return MATCHED;
1377
1378 strbuf_addch(&parent_pathname, '/');
1379 strbuf_add(&parent_pathname, pathname, pathlen);
1380
1381 if (hashmap_contains_path(&pl->recursive_hashmap,
1382 &parent_pathname)) {
eb42feca 1383 result = MATCHED_RECURSIVE;
96cc8ab5 1384 goto done;
468ce99b
DS
1385 }
1386
96cc8ab5
DS
1387 slash_pos = strrchr(parent_pathname.buf, '/');
1388
1389 if (slash_pos == parent_pathname.buf) {
1390 /* include every file in root */
1391 result = MATCHED;
1392 goto done;
1393 }
1394
1395 strbuf_setlen(&parent_pathname, slash_pos - parent_pathname.buf);
1396
1397 if (hashmap_contains_path(&pl->parent_hashmap, &parent_pathname)) {
1398 result = MATCHED;
1399 goto done;
1400 }
1401
1402 if (hashmap_contains_parent(&pl->recursive_hashmap,
1403 pathname,
1404 &parent_pathname))
eb42feca 1405 result = MATCHED_RECURSIVE;
96cc8ab5
DS
1406
1407done:
1408 strbuf_release(&parent_pathname);
1409 return result;
453ec4bd
LT
1410}
1411
65edd96a 1412static struct path_pattern *last_matching_pattern_from_lists(
ab8db613
DS
1413 struct dir_struct *dir, struct index_state *istate,
1414 const char *pathname, int pathlen,
1415 const char *basename, int *dtype_p)
46aa2f95
KB
1416{
1417 int i, j;
1418 struct exclude_list_group *group;
ab8db613 1419 struct path_pattern *pattern;
46aa2f95
KB
1420 for (i = EXC_CMDL; i <= EXC_FILE; i++) {
1421 group = &dir->exclude_list_group[i];
1422 for (j = group->nr - 1; j >= 0; j--) {
65edd96a 1423 pattern = last_matching_pattern_from_list(
46aa2f95 1424 pathname, pathlen, basename, dtype_p,
caa3d554 1425 &group->pl[j], istate);
ab8db613
DS
1426 if (pattern)
1427 return pattern;
46aa2f95
KB
1428 }
1429 }
1430 return NULL;
1431}
1432
6cd5c582
KB
1433/*
1434 * Loads the per-directory exclude list for the substring of base
1435 * which has a char length of baselen.
1436 */
e799ed40
BW
1437static void prep_exclude(struct dir_struct *dir,
1438 struct index_state *istate,
1439 const char *base, int baselen)
6cd5c582
KB
1440{
1441 struct exclude_list_group *group;
caa3d554 1442 struct pattern_list *pl;
6cd5c582 1443 struct exclude_stack *stk = NULL;
0dcb8d7f 1444 struct untracked_cache_dir *untracked;
6cd5c582
KB
1445 int current;
1446
6cd5c582
KB
1447 group = &dir->exclude_list_group[EXC_DIRS];
1448
d961baa8
NTND
1449 /*
1450 * Pop the exclude lists from the EXCL_DIRS exclude_list_group
6cd5c582 1451 * which originate from directories not in the prefix of the
d961baa8
NTND
1452 * path being checked.
1453 */
6cd5c582
KB
1454 while ((stk = dir->exclude_stack) != NULL) {
1455 if (stk->baselen <= baselen &&
aceb9429 1456 !strncmp(dir->basebuf.buf, base, stk->baselen))
6cd5c582 1457 break;
caa3d554 1458 pl = &group->pl[dir->exclude_stack->exclude_ix];
6cd5c582 1459 dir->exclude_stack = stk->prev;
ab8db613 1460 dir->pattern = NULL;
caa3d554 1461 free((char *)pl->src); /* see strbuf_detach() below */
65edd96a 1462 clear_pattern_list(pl);
6cd5c582
KB
1463 free(stk);
1464 group->nr--;
1465 }
1466
95c6f271 1467 /* Skip traversing into sub directories if the parent is excluded */
ab8db613 1468 if (dir->pattern)
95c6f271
KB
1469 return;
1470
aceb9429
NTND
1471 /*
1472 * Lazy initialization. All call sites currently just
1473 * memset(dir, 0, sizeof(*dir)) before use. Changing all of
1474 * them seems lots of work for little benefit.
1475 */
1476 if (!dir->basebuf.buf)
1477 strbuf_init(&dir->basebuf, PATH_MAX);
1478
6cd5c582
KB
1479 /* Read from the parent directories and push them down. */
1480 current = stk ? stk->baselen : -1;
aceb9429 1481 strbuf_setlen(&dir->basebuf, current < 0 ? 0 : current);
0dcb8d7f
NTND
1482 if (dir->untracked)
1483 untracked = stk ? stk->ucd : dir->untracked->root;
1484 else
1485 untracked = NULL;
1486
6cd5c582 1487 while (current < baselen) {
6cd5c582 1488 const char *cp;
4b33e602 1489 struct oid_stat oid_stat;
6cd5c582 1490
ca56dadb 1491 CALLOC_ARRAY(stk, 1);
6cd5c582
KB
1492 if (current < 0) {
1493 cp = base;
1494 current = 0;
d961baa8 1495 } else {
6cd5c582
KB
1496 cp = strchr(base + current + 1, '/');
1497 if (!cp)
1498 die("oops in prep_exclude");
1499 cp++;
0dcb8d7f
NTND
1500 untracked =
1501 lookup_untracked(dir->untracked, untracked,
1502 base + current,
1503 cp - base - current);
6cd5c582
KB
1504 }
1505 stk->prev = dir->exclude_stack;
1506 stk->baselen = cp - base;
95c6f271 1507 stk->exclude_ix = group->nr;
0dcb8d7f 1508 stk->ucd = untracked;
65edd96a 1509 pl = add_pattern_list(dir, EXC_DIRS, NULL);
aceb9429
NTND
1510 strbuf_add(&dir->basebuf, base + current, stk->baselen - current);
1511 assert(stk->baselen == dir->basebuf.len);
95c6f271
KB
1512
1513 /* Abort if the directory is excluded */
1514 if (stk->baselen) {
1515 int dt = DT_DIR;
aceb9429 1516 dir->basebuf.buf[stk->baselen - 1] = 0;
65edd96a 1517 dir->pattern = last_matching_pattern_from_lists(dir,
e799ed40 1518 istate,
aceb9429
NTND
1519 dir->basebuf.buf, stk->baselen - 1,
1520 dir->basebuf.buf + current, &dt);
1521 dir->basebuf.buf[stk->baselen - 1] = '/';
ab8db613 1522 if (dir->pattern &&
4ff89ee5 1523 dir->pattern->flags & PATTERN_FLAG_NEGATIVE)
ab8db613
DS
1524 dir->pattern = NULL;
1525 if (dir->pattern) {
95c6f271
KB
1526 dir->exclude_stack = stk;
1527 return;
1528 }
1529 }
1530
aceb9429 1531 /* Try to read per-directory file */
4b33e602
PO
1532 oidclr(&oid_stat.oid);
1533 oid_stat.valid = 0;
27b099ae
NTND
1534 if (dir->exclude_per_dir &&
1535 /*
1536 * If we know that no files have been added in
1537 * this directory (i.e. valid_cached_dir() has
1538 * been executed and set untracked->valid) ..
1539 */
1540 (!untracked || !untracked->valid ||
1541 /*
1542 * .. and .gitignore does not exist before
70c369cd 1543 * (i.e. null exclude_oid). Then we can skip
7687252f
DT
1544 * loading .gitignore, which would result in
1545 * ENOENT anyway.
27b099ae 1546 */
70c369cd 1547 !is_null_oid(&untracked->exclude_oid))) {
95c6f271
KB
1548 /*
1549 * dir->basebuf gets reused by the traversal, but we
1550 * need fname to remain unchanged to ensure the src
ab8db613 1551 * member of each struct path_pattern correctly
95c6f271 1552 * back-references its source file. Other invocations
65edd96a 1553 * of add_pattern_list provide stable strings, so we
aceb9429 1554 * strbuf_detach() and free() here in the caller.
95c6f271 1555 */
aceb9429
NTND
1556 struct strbuf sb = STRBUF_INIT;
1557 strbuf_addbuf(&sb, &dir->basebuf);
1558 strbuf_addstr(&sb, dir->exclude_per_dir);
caa3d554 1559 pl->src = strbuf_detach(&sb, NULL);
65edd96a 1560 add_patterns(pl->src, pl->src, stk->baselen, pl, istate,
4b33e602 1561 untracked ? &oid_stat : NULL);
0dcb8d7f 1562 }
5ebf79ad
NTND
1563 /*
1564 * NEEDSWORK: when untracked cache is enabled, prep_exclude()
1565 * will first be called in valid_cached_dir() then maybe many
65edd96a
DS
1566 * times more in last_matching_pattern(). When the cache is
1567 * used, last_matching_pattern() will not be called and
5ebf79ad
NTND
1568 * reading .gitignore content will be a waste.
1569 *
1570 * So when it's called by valid_cached_dir() and we can get
1571 * .gitignore SHA-1 from the index (i.e. .gitignore is not
1572 * modified on work tree), we could delay reading the
1573 * .gitignore content until we absolutely need it in
65edd96a 1574 * last_matching_pattern(). Be careful about ignore rule
5ebf79ad
NTND
1575 * order, though, if you do that.
1576 */
1577 if (untracked &&
9001dc2a 1578 !oideq(&oid_stat.oid, &untracked->exclude_oid)) {
5ebf79ad 1579 invalidate_gitignore(dir->untracked, untracked);
70c369cd 1580 oidcpy(&untracked->exclude_oid, &oid_stat.oid);
95c6f271 1581 }
6cd5c582
KB
1582 dir->exclude_stack = stk;
1583 current = stk->baselen;
1584 }
aceb9429 1585 strbuf_setlen(&dir->basebuf, baselen);
6cd5c582
KB
1586}
1587
f4cd69a6
AS
1588/*
1589 * Loads the exclude lists for the directory containing pathname, then
1590 * scans all exclude lists to determine whether pathname is excluded.
1591 * Returns the exclude_list element which matched, or NULL for
1592 * undecided.
1593 */
65edd96a 1594struct path_pattern *last_matching_pattern(struct dir_struct *dir,
a0bba65b
BW
1595 struct index_state *istate,
1596 const char *pathname,
1597 int *dtype_p)
453ec4bd
LT
1598{
1599 int pathlen = strlen(pathname);
68492fc7
LK
1600 const char *basename = strrchr(pathname, '/');
1601 basename = (basename) ? basename+1 : pathname;
453ec4bd 1602
a0bba65b 1603 prep_exclude(dir, istate, pathname, basename-pathname);
c082df24 1604
ab8db613
DS
1605 if (dir->pattern)
1606 return dir->pattern;
95c6f271 1607
65edd96a 1608 return last_matching_pattern_from_lists(dir, istate, pathname, pathlen,
46aa2f95 1609 basename, dtype_p);
f4cd69a6
AS
1610}
1611
1612/*
1613 * Loads the exclude lists for the directory containing pathname, then
1614 * scans all exclude lists to determine whether pathname is excluded.
1615 * Returns 1 if true, otherwise 0.
1616 */
a0bba65b
BW
1617int is_excluded(struct dir_struct *dir, struct index_state *istate,
1618 const char *pathname, int *dtype_p)
f4cd69a6 1619{
ab8db613 1620 struct path_pattern *pattern =
65edd96a 1621 last_matching_pattern(dir, istate, pathname, dtype_p);
ab8db613 1622 if (pattern)
4ff89ee5 1623 return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;
453ec4bd
LT
1624 return 0;
1625}
1626
f3fa1838
JH
1627static struct dir_entry *dir_entry_new(const char *pathname, int len)
1628{
453ec4bd
LT
1629 struct dir_entry *ent;
1630
96ffc06f 1631 FLEX_ALLOC_MEM(ent, name, pathname, len);
453ec4bd 1632 ent->len = len;
4d06f8ac 1633 return ent;
453ec4bd
LT
1634}
1635
9e58beca
BW
1636static struct dir_entry *dir_add_name(struct dir_struct *dir,
1637 struct index_state *istate,
1638 const char *pathname, int len)
6815e569 1639{
9e58beca 1640 if (index_file_exists(istate, pathname, len, ignore_case))
6815e569
JK
1641 return NULL;
1642
25fd2f7a 1643 ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);
6815e569
JK
1644 return dir->entries[dir->nr++] = dir_entry_new(pathname, len);
1645}
1646
9e58beca
BW
1647struct dir_entry *dir_add_ignored(struct dir_struct *dir,
1648 struct index_state *istate,
1649 const char *pathname, int len)
2abd31b0 1650{
9e58beca 1651 if (!index_name_is_other(istate, pathname, len))
2abd31b0
JK
1652 return NULL;
1653
25fd2f7a 1654 ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);
2abd31b0
JK
1655 return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);
1656}
1657
09595258
LT
1658enum exist_status {
1659 index_nonexistent = 0,
1660 index_directory,
4b05548f 1661 index_gitdir
09595258
LT
1662};
1663
5102c617 1664/*
71261027 1665 * Do not use the alphabetically sorted index to look up
5102c617 1666 * the directory name; instead, use the case insensitive
ebbd7439 1667 * directory hash.
5102c617 1668 */
ae520e36
BW
1669static enum exist_status directory_exists_in_index_icase(struct index_state *istate,
1670 const char *dirname, int len)
5102c617 1671{
41284eb0 1672 struct cache_entry *ce;
5102c617 1673
ae520e36 1674 if (index_dir_exists(istate, dirname, len))
5102c617
JJ
1675 return index_directory;
1676
ae520e36 1677 ce = index_file_exists(istate, dirname, len, ignore_case);
41284eb0 1678 if (ce && S_ISGITLINK(ce->ce_mode))
5102c617
JJ
1679 return index_gitdir;
1680
5102c617
JJ
1681 return index_nonexistent;
1682}
1683
09595258
LT
1684/*
1685 * The index sorts alphabetically by entry name, which
1686 * means that a gitlink sorts as '\0' at the end, while
1687 * a directory (which is defined not as an entry, but as
1688 * the files it contains) will sort with the '/' at the
1689 * end.
1690 */
ae520e36
BW
1691static enum exist_status directory_exists_in_index(struct index_state *istate,
1692 const char *dirname, int len)
453ec4bd 1693{
5102c617
JJ
1694 int pos;
1695
1696 if (ignore_case)
ae520e36 1697 return directory_exists_in_index_icase(istate, dirname, len);
5102c617 1698
ae520e36 1699 pos = index_name_pos(istate, dirname, len);
09595258
LT
1700 if (pos < 0)
1701 pos = -pos-1;
ae520e36
BW
1702 while (pos < istate->cache_nr) {
1703 const struct cache_entry *ce = istate->cache[pos++];
09595258
LT
1704 unsigned char endchar;
1705
1706 if (strncmp(ce->name, dirname, len))
1707 break;
1708 endchar = ce->name[len];
1709 if (endchar > '/')
1710 break;
1711 if (endchar == '/')
1712 return index_directory;
7a51ed66 1713 if (!endchar && S_ISGITLINK(ce->ce_mode))
09595258
LT
1714 return index_gitdir;
1715 }
1716 return index_nonexistent;
1717}
1718
1719/*
1720 * When we find a directory when traversing the filesystem, we
1721 * have three distinct cases:
1722 *
1723 * - ignore it
1724 * - see it as a directory
1725 * - recurse into it
1726 *
1727 * and which one we choose depends on a combination of existing
1728 * git index contents and the flags passed into the directory
1729 * traversal routine.
1730 *
1731 * Case 1: If we *already* have entries in the index under that
5bd8e2d8
KB
1732 * directory name, we always recurse into the directory to see
1733 * all the files.
09595258
LT
1734 *
1735 * Case 2: If we *already* have that directory name as a gitlink,
1736 * we always continue to see it as a gitlink, regardless of whether
1737 * there is an actual git directory there or not (it might not
1738 * be checked out as a subproject!)
1739 *
1740 * Case 3: if we didn't have it in the index previously, we
1741 * have a few sub-cases:
1742 *
1743 * (a) if "show_other_directories" is true, we show it as
1744 * just a directory, unless "hide_empty_directories" is
defd7c7b
KB
1745 * also true, in which case we need to check if it contains any
1746 * untracked and / or ignored files.
09595258 1747 * (b) if it looks like a git directory, and we don't have
302b9282 1748 * 'no_gitlinks' set we treat it as a gitlink, and show it
09595258
LT
1749 * as a directory.
1750 * (c) otherwise, we recurse into it.
1751 */
defd7c7b 1752static enum path_treatment treat_directory(struct dir_struct *dir,
0ef8e169 1753 struct index_state *istate,
0dcb8d7f 1754 struct untracked_cache_dir *untracked,
2df179d3 1755 const char *dirname, int len, int baselen, int excluded,
e1b8c7bd 1756 const struct pathspec *pathspec)
09595258 1757{
8d92fb29
EN
1758 /*
1759 * WARNING: From this function, you can return path_recurse or you
1760 * can call read_directory_recursive() (or neither), but
1761 * you CAN'T DO BOTH.
1762 */
1763 enum path_treatment state;
7f45ab2d 1764 int matches_how = 0;
16846444
EN
1765 int nested_repo = 0, check_only, stop_early;
1766 int old_ignored_nr, old_untracked_nr;
09595258 1767 /* The "len-1" is to strip the final '/' */
0bbd0e8b 1768 enum exist_status status = directory_exists_in_index(istate, dirname, len-1);
09595258 1769
0bbd0e8b
DS
1770 if (status == index_directory)
1771 return path_recurse;
1772 if (status == index_gitdir)
26c986e1 1773 return path_none;
0bbd0e8b
DS
1774 if (status != index_nonexistent)
1775 BUG("Unhandled value for directory_exists_in_index: %d\n", status);
09595258 1776
7f45ab2d
EN
1777 /*
1778 * We don't want to descend into paths that don't match the necessary
1779 * patterns. Clearly, if we don't have a pathspec, then we can't check
1780 * for matching patterns. Also, if (excluded) then we know we matched
1781 * the exclusion patterns so as an optimization we can skip checking
1782 * for matching patterns.
1783 */
1784 if (pathspec && !excluded) {
f1f061e1
EN
1785 matches_how = match_pathspec_with_flags(istate, pathspec,
1786 dirname, len,
1787 0 /* prefix */,
1788 NULL /* seen */,
1789 DO_MATCH_LEADING_PATHSPEC);
7f45ab2d
EN
1790 if (!matches_how)
1791 return path_none;
1792 }
09487f2c 1793
7f45ab2d 1794
0bbd0e8b
DS
1795 if ((dir->flags & DIR_SKIP_NESTED_GIT) ||
1796 !(dir->flags & DIR_NO_GITLINKS)) {
1797 struct strbuf sb = STRBUF_INIT;
1798 strbuf_addstr(&sb, dirname);
1799 nested_repo = is_nonbare_repository_dir(&sb);
1800 strbuf_release(&sb);
1801 }
ab282aa5
EN
1802 if (nested_repo) {
1803 if ((dir->flags & DIR_SKIP_NESTED_GIT) ||
1804 (matches_how == MATCHED_RECURSIVELY_LEADING_PATHSPEC))
1805 return path_none;
1806 return excluded ? path_excluded : path_untracked;
1807 }
09595258 1808
0bbd0e8b 1809 if (!(dir->flags & DIR_SHOW_OTHER_DIRECTORIES)) {
2df179d3
EN
1810 if (excluded &&
1811 (dir->flags & DIR_SHOW_IGNORED_TOO) &&
1812 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING)) {
eec0f7f2
JM
1813
1814 /*
1815 * This is an excluded directory and we are
1816 * showing ignored paths that match an exclude
1817 * pattern. (e.g. show directory as ignored
1818 * only if it matches an exclude pattern).
1819 * This path will either be 'path_excluded`
1820 * (if we are showing empty directories or if
1821 * the directory is not empty), or will be
1822 * 'path_none' (empty directory, and we are
1823 * not showing empty directories).
1824 */
1825 if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))
1826 return path_excluded;
1827
1828 if (read_directory_recursive(dir, istate, dirname, len,
1829 untracked, 1, 1, pathspec) == path_excluded)
1830 return path_excluded;
1831
1832 return path_none;
1833 }
defd7c7b 1834 return path_recurse;
09595258
LT
1835 }
1836
1837 /* This is the "show_other_directories" case */
721ac4ed 1838
8d92fb29
EN
1839 /*
1840 * If we have a pathspec which could match something _below_ this
1841 * directory (e.g. when checking 'subdir/' having a pathspec like
1842 * 'subdir/some/deep/path/file' or 'subdir/widget-*.c'), then we
1843 * need to recurse.
1844 */
7f45ab2d
EN
1845 if (matches_how == MATCHED_RECURSIVELY_LEADING_PATHSPEC)
1846 return path_recurse;
8d92fb29
EN
1847
1848 /*
1849 * Other than the path_recurse case immediately above, we only need
1850 * to recurse into untracked/ignored directories if either of the
1851 * following bits is set:
1852 * - DIR_SHOW_IGNORED_TOO (because then we need to determine if
e6c0be92 1853 * there are ignored entries below)
8d92fb29
EN
1854 * - DIR_HIDE_EMPTY_DIRECTORIES (because we have to determine if
1855 * the directory is empty)
1856 */
1857 if (!(dir->flags & (DIR_SHOW_IGNORED_TOO | DIR_HIDE_EMPTY_DIRECTORIES)))
2df179d3 1858 return excluded ? path_excluded : path_untracked;
defd7c7b 1859
8d92fb29
EN
1860 /*
1861 * ...and even if DIR_SHOW_IGNORED_TOO is set, we can still avoid
1862 * recursing into ignored directories if the path is excluded and
1863 * DIR_SHOW_IGNORED_TOO_MODE_MATCHING is also set.
1864 */
1865 if (excluded &&
1866 (dir->flags & DIR_SHOW_IGNORED_TOO) &&
1867 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING))
1868 return path_excluded;
1869
1870 /*
e6c0be92
EN
1871 * Even if we don't want to know all the paths under an untracked or
1872 * ignored directory, we may still need to go into the directory to
1873 * determine if it is empty (because with DIR_HIDE_EMPTY_DIRECTORIES,
1874 * an empty directory should be path_none instead of path_excluded or
1875 * path_untracked).
8d92fb29
EN
1876 */
1877 check_only = ((dir->flags & DIR_HIDE_EMPTY_DIRECTORIES) &&
1878 !(dir->flags & DIR_SHOW_IGNORED_TOO));
1879
1880 /*
1881 * However, there's another optimization possible as a subset of
1882 * check_only, based on the cases we have to consider:
1883 * A) Directory matches no exclude patterns:
1884 * * Directory is empty => path_none
1885 * * Directory has an untracked file under it => path_untracked
1886 * * Directory has only ignored files under it => path_excluded
1887 * B) Directory matches an exclude pattern:
1888 * * Directory is empty => path_none
1889 * * Directory has an untracked file under it => path_excluded
1890 * * Directory has only ignored files under it => path_excluded
1891 * In case A, we can exit as soon as we've found an untracked
1892 * file but otherwise have to walk all files. In case B, though,
1893 * we can stop at the first file we find under the directory.
1894 */
1895 stop_early = check_only && excluded;
1896
1897 /*
1898 * If /every/ file within an untracked directory is ignored, then
1899 * we want to treat the directory as ignored (for e.g. status
1900 * --porcelain), without listing the individual ignored files
1901 * underneath. To do so, we'll save the current ignored_nr, and
1902 * pop all the ones added after it if it turns out the entire
16846444
EN
1903 * directory is ignored. Also, when DIR_SHOW_IGNORED_TOO and
1904 * !DIR_KEEP_UNTRACKED_CONTENTS then we don't want to show
1905 * untracked paths so will need to pop all those off the last
1906 * after we traverse.
8d92fb29
EN
1907 */
1908 old_ignored_nr = dir->ignored_nr;
16846444 1909 old_untracked_nr = dir->nr;
8d92fb29
EN
1910
1911 /* Actually recurse into dirname now, we'll fixup the state later. */
2e5910f2
DT
1912 untracked = lookup_untracked(dir->untracked, untracked,
1913 dirname + baselen, len - baselen);
8d92fb29
EN
1914 state = read_directory_recursive(dir, istate, dirname, len, untracked,
1915 check_only, stop_early, pathspec);
1916
1917 /* There are a variety of reasons we may need to fixup the state... */
1918 if (state == path_excluded) {
1919 /* state == path_excluded implies all paths under
1920 * dirname were ignored...
1921 *
1922 * if running e.g. `git status --porcelain --ignored=matching`,
1923 * then we want to see the subpaths that are ignored.
1924 *
1925 * if running e.g. just `git status --porcelain`, then
1926 * we just want the directory itself to be listed as ignored
1927 * and not the individual paths underneath.
1928 */
1929 int want_ignored_subpaths =
1930 ((dir->flags & DIR_SHOW_IGNORED_TOO) &&
1931 (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING));
1932
1933 if (want_ignored_subpaths) {
1934 /*
1935 * with --ignored=matching, we want the subpaths
1936 * INSTEAD of the directory itself.
1937 */
1938 state = path_none;
1939 } else {
1940 int i;
1941 for (i = old_ignored_nr + 1; i<dir->ignored_nr; ++i)
1942 FREE_AND_NULL(dir->ignored[i]);
1943 dir->ignored_nr = old_ignored_nr;
1944 }
1945 }
5aaa7fd3
JM
1946
1947 /*
16846444
EN
1948 * We may need to ignore some of the untracked paths we found while
1949 * traversing subdirectories.
5aaa7fd3 1950 */
16846444
EN
1951 if ((dir->flags & DIR_SHOW_IGNORED_TOO) &&
1952 !(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {
1953 int i;
1954 for (i = old_untracked_nr + 1; i<dir->nr; ++i)
1955 FREE_AND_NULL(dir->entries[i]);
1956 dir->nr = old_untracked_nr;
1957 }
1958
5aaa7fd3 1959 /*
8d92fb29
EN
1960 * If there is nothing under the current directory and we are not
1961 * hiding empty directories, then we need to report on the
1962 * untracked or ignored status of the directory itself.
5aaa7fd3 1963 */
8d92fb29
EN
1964 if (state == path_none && !(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))
1965 state = excluded ? path_excluded : path_untracked;
1966
8d92fb29 1967 return state;
453ec4bd
LT
1968}
1969
9fc42d60
LT
1970/*
1971 * This is an inexact early pruning of any recursive directory
1972 * reading - if the path cannot possibly be in the pathspec,
1973 * return true, and we'll skip it early.
1974 */
e1b8c7bd
BW
1975static int simplify_away(const char *path, int pathlen,
1976 const struct pathspec *pathspec)
9fc42d60 1977{
e1b8c7bd 1978 int i;
9fc42d60 1979
e1b8c7bd
BW
1980 if (!pathspec || !pathspec->nr)
1981 return 0;
1982
1983 GUARD_PATHSPEC(pathspec,
1984 PATHSPEC_FROMTOP |
1985 PATHSPEC_MAXDEPTH |
1986 PATHSPEC_LITERAL |
1987 PATHSPEC_GLOB |
1988 PATHSPEC_ICASE |
b0db7046
BW
1989 PATHSPEC_EXCLUDE |
1990 PATHSPEC_ATTR);
e1b8c7bd
BW
1991
1992 for (i = 0; i < pathspec->nr; i++) {
1993 const struct pathspec_item *item = &pathspec->items[i];
1994 int len = item->nowildcard_len;
1995
1996 if (len > pathlen)
1997 len = pathlen;
1998 if (!ps_strncmp(item, item->match, path, len))
1999 return 0;
9fc42d60 2000 }
e1b8c7bd
BW
2001
2002 return 1;
9fc42d60
LT
2003}
2004
29209cbe
JK
2005/*
2006 * This function tells us whether an excluded path matches a
2007 * list of "interesting" pathspecs. That is, whether a path matched
2008 * by any of the pathspecs could possibly be ignored by excluding
2009 * the specified path. This can happen if:
2010 *
2011 * 1. the path is mentioned explicitly in the pathspec
2012 *
2013 * 2. the path is a directory prefix of some element in the
2014 * pathspec
2015 */
e1b8c7bd
BW
2016static int exclude_matches_pathspec(const char *path, int pathlen,
2017 const struct pathspec *pathspec)
2018{
2019 int i;
2020
2021 if (!pathspec || !pathspec->nr)
2022 return 0;
2023
2024 GUARD_PATHSPEC(pathspec,
2025 PATHSPEC_FROMTOP |
2026 PATHSPEC_MAXDEPTH |
2027 PATHSPEC_LITERAL |
2028 PATHSPEC_GLOB |
2029 PATHSPEC_ICASE |
2030 PATHSPEC_EXCLUDE);
2031
2032 for (i = 0; i < pathspec->nr; i++) {
2033 const struct pathspec_item *item = &pathspec->items[i];
2034 int len = item->nowildcard_len;
2035
2036 if (len == pathlen &&
2037 !ps_strncmp(item, item->match, path, pathlen))
2038 return 1;
2039 if (len > pathlen &&
2040 item->match[pathlen] == '/' &&
2041 !ps_strncmp(item, item->match, path, pathlen))
2042 return 1;
e96980ef
JK
2043 }
2044 return 0;
2045}
2046
98f2a687
BW
2047static int get_index_dtype(struct index_state *istate,
2048 const char *path, int len)
443e061a
LT
2049{
2050 int pos;
9c5e6c80 2051 const struct cache_entry *ce;
443e061a 2052
98f2a687 2053 ce = index_file_exists(istate, path, len, 0);
443e061a
LT
2054 if (ce) {
2055 if (!ce_uptodate(ce))
2056 return DT_UNKNOWN;
2057 if (S_ISGITLINK(ce->ce_mode))
2058 return DT_DIR;
2059 /*
2060 * Nobody actually cares about the
2061 * difference between DT_LNK and DT_REG
2062 */
2063 return DT_REG;
2064 }
2065
2066 /* Try to look it up as a directory */
98f2a687 2067 pos = index_name_pos(istate, path, len);
443e061a
LT
2068 if (pos >= 0)
2069 return DT_UNKNOWN;
2070 pos = -pos-1;
98f2a687
BW
2071 while (pos < istate->cache_nr) {
2072 ce = istate->cache[pos++];
443e061a
LT
2073 if (strncmp(ce->name, path, len))
2074 break;
2075 if (ce->name[len] > '/')
2076 break;
2077 if (ce->name[len] < '/')
2078 continue;
2079 if (!ce_uptodate(ce))
2080 break; /* continue? */
2081 return DT_DIR;
2082 }
2083 return DT_UNKNOWN;
2084}
2085
ad6f2157
JK
2086static int resolve_dtype(int dtype, struct index_state *istate,
2087 const char *path, int len)
07134421 2088{
07134421
LT
2089 struct stat st;
2090
2091 if (dtype != DT_UNKNOWN)
2092 return dtype;
98f2a687 2093 dtype = get_index_dtype(istate, path, len);
443e061a
LT
2094 if (dtype != DT_UNKNOWN)
2095 return dtype;
2096 if (lstat(path, &st))
07134421
LT
2097 return dtype;
2098 if (S_ISREG(st.st_mode))
2099 return DT_REG;
2100 if (S_ISDIR(st.st_mode))
2101 return DT_DIR;
2102 if (S_ISLNK(st.st_mode))
2103 return DT_LNK;
2104 return dtype;
2105}
2106
91a2288b 2107static enum path_treatment treat_path_fast(struct dir_struct *dir,
91a2288b 2108 struct cached_dir *cdir,
0ef8e169 2109 struct index_state *istate,
91a2288b
NTND
2110 struct strbuf *path,
2111 int baselen,
e1b8c7bd 2112 const struct pathspec *pathspec)
91a2288b 2113{
8d92fb29
EN
2114 /*
2115 * WARNING: From this function, you can return path_recurse or you
2116 * can call read_directory_recursive() (or neither), but
2117 * you CAN'T DO BOTH.
2118 */
91a2288b
NTND
2119 strbuf_setlen(path, baselen);
2120 if (!cdir->ucd) {
2121 strbuf_addstr(path, cdir->file);
2122 return path_untracked;
2123 }
2124 strbuf_addstr(path, cdir->ucd->name);
2125 /* treat_one_path() does this before it calls treat_directory() */
00b6c178 2126 strbuf_complete(path, '/');
91a2288b
NTND
2127 if (cdir->ucd->check_only)
2128 /*
2129 * check_only is set as a result of treat_directory() getting
2130 * to its bottom. Verify again the same set of directories
2131 * with check_only set.
2132 */
0ef8e169 2133 return read_directory_recursive(dir, istate, path->buf, path->len,
5aaa7fd3 2134 cdir->ucd, 1, 0, pathspec);
91a2288b
NTND
2135 /*
2136 * We get path_recurse in the first run when
2137 * directory_exists_in_index() returns index_nonexistent. We
2138 * are sure that new changes in the index does not impact the
2139 * outcome. Return now.
2140 */
2141 return path_recurse;
2142}
2143
16e2cfa9 2144static enum path_treatment treat_path(struct dir_struct *dir,
0dcb8d7f 2145 struct untracked_cache_dir *untracked,
cf7c6148 2146 struct cached_dir *cdir,
0ef8e169 2147 struct index_state *istate,
49dc2cc2 2148 struct strbuf *path,
16e2cfa9 2149 int baselen,
e1b8c7bd 2150 const struct pathspec *pathspec)
16e2cfa9 2151{
2df179d3 2152 int has_path_in_index, dtype, excluded;
2eac2a4c 2153
ad6f2157 2154 if (!cdir->d_name)
842385b8 2155 return treat_path_fast(dir, cdir, istate, path,
e1b8c7bd 2156 baselen, pathspec);
ad6f2157 2157 if (is_dot_or_dotdot(cdir->d_name) || !fspathcmp(cdir->d_name, ".git"))
defd7c7b 2158 return path_none;
49dc2cc2 2159 strbuf_setlen(path, baselen);
ad6f2157 2160 strbuf_addstr(path, cdir->d_name);
e1b8c7bd 2161 if (simplify_away(path->buf, path->len, pathspec))
defd7c7b 2162 return path_none;
16e2cfa9 2163
cd129eed 2164 dtype = resolve_dtype(cdir->d_type, istate, path->buf, path->len);
8aaf8d77
KB
2165
2166 /* Always exclude indexed files */
cd129eed
EN
2167 has_path_in_index = !!index_file_exists(istate, path->buf, path->len,
2168 ignore_case);
2eac2a4c 2169 if (dtype != DT_DIR && has_path_in_index)
defd7c7b 2170 return path_none;
8aaf8d77 2171
2eac2a4c
JH
2172 /*
2173 * When we are looking at a directory P in the working tree,
2174 * there are three cases:
2175 *
2176 * (1) P exists in the index. Everything inside the directory P in
2177 * the working tree needs to go when P is checked out from the
2178 * index.
2179 *
2180 * (2) P does not exist in the index, but there is P/Q in the index.
2181 * We know P will stay a directory when we check out the contents
2182 * of the index, but we do not know yet if there is a directory
2183 * P/Q in the working tree to be killed, so we need to recurse.
2184 *
2185 * (3) P does not exist in the index, and there is no P/Q in the index
2186 * to require P to be a directory, either. Only in this case, we
2187 * know that everything inside P will not be killed without
2188 * recursing.
2189 */
2190 if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&
2191 (dtype == DT_DIR) &&
de372b1b 2192 !has_path_in_index &&
0ef8e169 2193 (directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))
de372b1b 2194 return path_none;
8aaf8d77 2195
2df179d3 2196 excluded = is_excluded(dir, istate, path->buf, &dtype);
53cc5356
JH
2197
2198 /*
2199 * Excluded? If we don't explicitly want to show
2200 * ignored files, ignore it
2201 */
2df179d3 2202 if (excluded && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))
defd7c7b 2203 return path_excluded;
53cc5356 2204
53cc5356
JH
2205 switch (dtype) {
2206 default:
defd7c7b 2207 return path_none;
53cc5356 2208 case DT_DIR:
07966ed1 2209 /*
8d92fb29
EN
2210 * WARNING: Do not ignore/amend the return value from
2211 * treat_directory(), and especially do not change it to return
2212 * path_recurse as that can cause exponential slowdown.
2213 * Instead, modify treat_directory() to return the right value.
07966ed1 2214 */
8d92fb29
EN
2215 strbuf_addch(path, '/');
2216 return treat_directory(dir, istate, untracked,
2217 path->buf, path->len,
2218 baselen, excluded, pathspec);
53cc5356
JH
2219 case DT_REG:
2220 case DT_LNK:
95c11ecc 2221 if (pathspec &&
f1f061e1
EN
2222 !match_pathspec(istate, pathspec, path->buf, path->len,
2223 0 /* prefix */, NULL /* seen */,
2224 0 /* is_dir */))
95c11ecc 2225 return path_none;
cada7308
2226 if (excluded)
2227 return path_excluded;
95c11ecc 2228 return path_untracked;
53cc5356 2229 }
0dcb8d7f
NTND
2230}
2231
2232static void add_untracked(struct untracked_cache_dir *dir, const char *name)
2233{
2234 if (!dir)
2235 return;
2236 ALLOC_GROW(dir->untracked, dir->untracked_nr + 1,
2237 dir->untracked_alloc);
2238 dir->untracked[dir->untracked_nr++] = xstrdup(name);
16e2cfa9
JH
2239}
2240
91a2288b
NTND
2241static int valid_cached_dir(struct dir_struct *dir,
2242 struct untracked_cache_dir *untracked,
207a06ce 2243 struct index_state *istate,
91a2288b
NTND
2244 struct strbuf *path,
2245 int check_only)
2246{
2247 struct stat st;
2248
2249 if (!untracked)
2250 return 0;
2251
883e248b
BP
2252 /*
2253 * With fsmonitor, we can trust the untracked cache's valid field.
2254 */
2255 refresh_fsmonitor(istate);
2256 if (!(dir->untracked->use_fsmonitor && untracked->valid)) {
2523c4be 2257 if (lstat(path->len ? path->buf : ".", &st)) {
883e248b
BP
2258 memset(&untracked->stat_data, 0, sizeof(untracked->stat_data));
2259 return 0;
2260 }
2261 if (!untracked->valid ||
2262 match_stat_data_racy(istate, &untracked->stat_data, &st)) {
883e248b
BP
2263 fill_stat_data(&untracked->stat_data, &st);
2264 return 0;
2265 }
91a2288b
NTND
2266 }
2267
b6403131 2268 if (untracked->check_only != !!check_only)
91a2288b 2269 return 0;
91a2288b
NTND
2270
2271 /*
2272 * prep_exclude will be called eventually on this directory,
65edd96a 2273 * but it's called much later in last_matching_pattern(). We
91a2288b
NTND
2274 * need it now to determine the validity of the cache for this
2275 * path. The next calls will be nearly no-op, the way
2276 * prep_exclude() is designed.
2277 */
2278 if (path->len && path->buf[path->len - 1] != '/') {
2279 strbuf_addch(path, '/');
207a06ce 2280 prep_exclude(dir, istate, path->buf, path->len);
91a2288b
NTND
2281 strbuf_setlen(path, path->len - 1);
2282 } else
207a06ce 2283 prep_exclude(dir, istate, path->buf, path->len);
91a2288b
NTND
2284
2285 /* hopefully prep_exclude() haven't invalidated this entry... */
2286 return untracked->valid;
2287}
2288
cf7c6148
NTND
2289static int open_cached_dir(struct cached_dir *cdir,
2290 struct dir_struct *dir,
2291 struct untracked_cache_dir *untracked,
207a06ce 2292 struct index_state *istate,
cf7c6148
NTND
2293 struct strbuf *path,
2294 int check_only)
2295{
b6731550
NTND
2296 const char *c_path;
2297
cf7c6148
NTND
2298 memset(cdir, 0, sizeof(*cdir));
2299 cdir->untracked = untracked;
207a06ce 2300 if (valid_cached_dir(dir, untracked, istate, path, check_only))
91a2288b 2301 return 0;
b6731550
NTND
2302 c_path = path->len ? path->buf : ".";
2303 cdir->fdir = opendir(c_path);
2304 if (!cdir->fdir)
2305 warning_errno(_("could not open directory '%s'"), c_path);
b6403131
NTND
2306 if (dir->untracked) {
2307 invalidate_directory(dir->untracked, untracked);
91a2288b 2308 dir->untracked->dir_opened++;
b6403131 2309 }
cf7c6148
NTND
2310 if (!cdir->fdir)
2311 return -1;
2312 return 0;
2313}
2314
2315static int read_cached_dir(struct cached_dir *cdir)
2316{
ad6f2157
JK
2317 struct dirent *de;
2318
cf7c6148 2319 if (cdir->fdir) {
ad6f2157
JK
2320 de = readdir(cdir->fdir);
2321 if (!de) {
2322 cdir->d_name = NULL;
2323 cdir->d_type = DT_UNKNOWN;
cf7c6148 2324 return -1;
ad6f2157
JK
2325 }
2326 cdir->d_name = de->d_name;
2327 cdir->d_type = DTYPE(de);
cf7c6148
NTND
2328 return 0;
2329 }
91a2288b
NTND
2330 while (cdir->nr_dirs < cdir->untracked->dirs_nr) {
2331 struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];
26cb0182
NTND
2332 if (!d->recurse) {
2333 cdir->nr_dirs++;
2334 continue;
2335 }
91a2288b
NTND
2336 cdir->ucd = d;
2337 cdir->nr_dirs++;
2338 return 0;
2339 }
2340 cdir->ucd = NULL;
2341 if (cdir->nr_files < cdir->untracked->untracked_nr) {
2342 struct untracked_cache_dir *d = cdir->untracked;
2343 cdir->file = d->untracked[cdir->nr_files++];
2344 return 0;
2345 }
cf7c6148
NTND
2346 return -1;
2347}
2348
2349static void close_cached_dir(struct cached_dir *cdir)
2350{
2351 if (cdir->fdir)
2352 closedir(cdir->fdir);
91a2288b
NTND
2353 /*
2354 * We have gone through this directory and found no untracked
2355 * entries. Mark it valid.
2356 */
26cb0182 2357 if (cdir->untracked) {
91a2288b 2358 cdir->untracked->valid = 1;
26cb0182
NTND
2359 cdir->untracked->recurse = 1;
2360 }
16e2cfa9
JH
2361}
2362
c5c4eddd
EN
2363static void add_path_to_appropriate_result_list(struct dir_struct *dir,
2364 struct untracked_cache_dir *untracked,
2365 struct cached_dir *cdir,
2366 struct index_state *istate,
2367 struct strbuf *path,
2368 int baselen,
2369 const struct pathspec *pathspec,
2370 enum path_treatment state)
2371{
2372 /* add the path to the appropriate result list */
2373 switch (state) {
2374 case path_excluded:
2375 if (dir->flags & DIR_SHOW_IGNORED)
2376 dir_add_name(dir, istate, path->buf, path->len);
2377 else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||
2378 ((dir->flags & DIR_COLLECT_IGNORED) &&
2379 exclude_matches_pathspec(path->buf, path->len,
2380 pathspec)))
2381 dir_add_ignored(dir, istate, path->buf, path->len);
2382 break;
2383
2384 case path_untracked:
2385 if (dir->flags & DIR_SHOW_IGNORED)
2386 break;
2387 dir_add_name(dir, istate, path->buf, path->len);
2388 if (cdir->fdir)
2389 add_untracked(untracked, path->buf + baselen);
2390 break;
2391
2392 default:
2393 break;
2394 }
2395}
2396
453ec4bd
LT
2397/*
2398 * Read a directory tree. We currently ignore anything but
2399 * directories, regular files and symlinks. That's because git
2400 * doesn't handle them at all yet. Maybe that will change some
2401 * day.
2402 *
2403 * Also, we ignore the name ".git" (even if it is not a directory).
2404 * That likely will not change.
defd7c7b 2405 *
5aaa7fd3
JM
2406 * If 'stop_at_first_file' is specified, 'path_excluded' is returned
2407 * to signal that a file was found. This is the least significant value that
2408 * indicates that a file was encountered that does not depend on the order of
446f46d8 2409 * whether an untracked or excluded path was encountered first.
5aaa7fd3 2410 *
defd7c7b 2411 * Returns the most significant path_treatment value encountered in the scan.
5aaa7fd3
JM
2412 * If 'stop_at_first_file' is specified, `path_excluded` is the most
2413 * significant path_treatment value that will be returned.
453ec4bd 2414 */
5aaa7fd3 2415
defd7c7b 2416static enum path_treatment read_directory_recursive(struct dir_struct *dir,
0ef8e169
BW
2417 struct index_state *istate, const char *base, int baselen,
2418 struct untracked_cache_dir *untracked, int check_only,
5aaa7fd3 2419 int stop_at_first_file, const struct pathspec *pathspec)
453ec4bd 2420{
777b4203 2421 /*
8d92fb29
EN
2422 * WARNING: Do NOT recurse unless path_recurse is returned from
2423 * treat_path(). Recursing on any other return value
2424 * can result in exponential slowdown.
777b4203 2425 */
cf7c6148 2426 struct cached_dir cdir;
defd7c7b 2427 enum path_treatment state, subdir_state, dir_state = path_none;
bef36921 2428 struct strbuf path = STRBUF_INIT;
453ec4bd 2429
bef36921 2430 strbuf_add(&path, base, baselen);
02cb6753 2431
0ef8e169 2432 if (open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))
1528d247
RS
2433 goto out;
2434
0dcb8d7f
NTND
2435 if (untracked)
2436 untracked->check_only = !!check_only;
2437
cf7c6148 2438 while (!read_cached_dir(&cdir)) {
defd7c7b 2439 /* check how the file or directory should be treated */
0ef8e169 2440 state = treat_path(dir, untracked, &cdir, istate, &path,
e1b8c7bd 2441 baselen, pathspec);
0dcb8d7f 2442
defd7c7b
KB
2443 if (state > dir_state)
2444 dir_state = state;
2445
2446 /* recurse into subdir if instructed by treat_path */
8d92fb29 2447 if (state == path_recurse) {
0dcb8d7f
NTND
2448 struct untracked_cache_dir *ud;
2449 ud = lookup_untracked(dir->untracked, untracked,
2450 path.buf + baselen,
2451 path.len - baselen);
2452 subdir_state =
0ef8e169 2453 read_directory_recursive(dir, istate, path.buf,
e1b8c7bd 2454 path.len, ud,
5aaa7fd3 2455 check_only, stop_at_first_file, pathspec);
defd7c7b
KB
2456 if (subdir_state > dir_state)
2457 dir_state = subdir_state;
404ebced 2458
69f272b9
EN
2459 if (pathspec &&
2460 !match_pathspec(istate, pathspec, path.buf, path.len,
404ebced
EN
2461 0 /* prefix */, NULL,
2462 0 /* do NOT special case dirs */))
2463 state = path_none;
defd7c7b
KB
2464 }
2465
2466 if (check_only) {
5aaa7fd3
JM
2467 if (stop_at_first_file) {
2468 /*
2469 * If stopping at first file, then
2470 * signal that a file was found by
2471 * returning `path_excluded`. This is
2472 * to return a consistent value
2473 * regardless of whether an ignored or
2474 * excluded file happened to be
2475 * encountered 1st.
2476 *
2477 * In current usage, the
2478 * `stop_at_first_file` is passed when
2479 * an ancestor directory has matched
2480 * an exclude pattern, so any found
2481 * files will be excluded.
2482 */
2483 if (dir_state >= path_excluded) {
2484 dir_state = path_excluded;
2485 break;
2486 }
2487 }
2488
defd7c7b 2489 /* abort early if maximum state has been reached */
0dcb8d7f 2490 if (dir_state == path_untracked) {
91a2288b 2491 if (cdir.fdir)
0dcb8d7f 2492 add_untracked(untracked, path.buf + baselen);
defd7c7b 2493 break;
0dcb8d7f 2494 }
0126d141 2495 /* skip the add_path_to_appropriate_result_list() */
02cb6753 2496 continue;
453ec4bd 2497 }
defd7c7b 2498
c5c4eddd
EN
2499 add_path_to_appropriate_result_list(dir, untracked, &cdir,
2500 istate, &path, baselen,
2501 pathspec, state);
453ec4bd 2502 }
cf7c6148 2503 close_cached_dir(&cdir);
1528d247 2504 out:
bef36921 2505 strbuf_release(&path);
453ec4bd 2506
defd7c7b 2507 return dir_state;
453ec4bd
LT
2508}
2509
bbf504a9 2510int cmp_dir_entry(const void *p1, const void *p2)
453ec4bd
LT
2511{
2512 const struct dir_entry *e1 = *(const struct dir_entry **)p1;
2513 const struct dir_entry *e2 = *(const struct dir_entry **)p2;
2514
ccdd4a0f 2515 return name_compare(e1->name, e1->len, e2->name, e2->len);
453ec4bd
LT
2516}
2517
fb898888 2518/* check if *out lexically strictly contains *in */
bbf504a9 2519int check_dir_entry_contains(const struct dir_entry *out, const struct dir_entry *in)
fb898888
SL
2520{
2521 return (out->len < in->len) &&
2522 (out->name[out->len - 1] == '/') &&
2523 !memcmp(out->name, in->name, out->len);
2524}
2525
48ffef96 2526static int treat_leading_path(struct dir_struct *dir,
0ef8e169 2527 struct index_state *istate,
48ffef96 2528 const char *path, int len,
e1b8c7bd 2529 const struct pathspec *pathspec)
48ffef96 2530{
49dc2cc2 2531 struct strbuf sb = STRBUF_INIT;
ad6f2157 2532 struct strbuf subdir = STRBUF_INIT;
b9670c1f 2533 int prevlen, baselen;
48ffef96 2534 const char *cp;
b9670c1f 2535 struct cached_dir cdir;
b9670c1f
EN
2536 enum path_treatment state = path_none;
2537
2538 /*
2539 * For each directory component of path, we are going to check whether
2540 * that path is relevant given the pathspec. For example, if path is
2541 * foo/bar/baz/
2542 * then we will ask treat_path() whether we should go into foo, then
2543 * whether we should go into bar, then whether baz is relevant.
2544 * Checking each is important because e.g. if path is
2545 * .git/info/
2546 * then we need to check .git to know we shouldn't traverse it.
2547 * If the return from treat_path() is:
2548 * * path_none, for any path, we return false.
2549 * * path_recurse, for all path components, we return true
2550 * * <anything else> for some intermediate component, we make sure
2551 * to add that path to the relevant list but return false
2552 * signifying that we shouldn't recurse into it.
2553 */
48ffef96
JH
2554
2555 while (len && path[len - 1] == '/')
2556 len--;
2557 if (!len)
2558 return 1;
b9670c1f 2559
b9670c1f 2560 memset(&cdir, 0, sizeof(cdir));
ad6f2157 2561 cdir.d_type = DT_DIR;
48ffef96 2562 baselen = 0;
b9670c1f 2563 prevlen = 0;
48ffef96 2564 while (1) {
b9670c1f
EN
2565 prevlen = baselen + !!baselen;
2566 cp = path + prevlen;
48ffef96
JH
2567 cp = memchr(cp, '/', path + len - cp);
2568 if (!cp)
2569 baselen = len;
2570 else
2571 baselen = cp - path;
b9670c1f 2572 strbuf_reset(&sb);
49dc2cc2
RS
2573 strbuf_add(&sb, path, baselen);
2574 if (!is_directory(sb.buf))
2575 break;
b9670c1f
EN
2576 strbuf_reset(&sb);
2577 strbuf_add(&sb, path, prevlen);
ad6f2157
JK
2578 strbuf_reset(&subdir);
2579 strbuf_add(&subdir, path+prevlen, baselen-prevlen);
2580 cdir.d_name = subdir.buf;
8d92fb29 2581 state = treat_path(dir, NULL, &cdir, istate, &sb, prevlen, pathspec);
777b4203 2582
b9670c1f 2583 if (state != path_recurse)
49dc2cc2 2584 break; /* do not recurse into it */
b9670c1f 2585 if (len <= baselen)
49dc2cc2 2586 break; /* finished checking */
48ffef96 2587 }
b9670c1f
EN
2588 add_path_to_appropriate_result_list(dir, NULL, &cdir, istate,
2589 &sb, baselen, pathspec,
2590 state);
2591
ad6f2157 2592 strbuf_release(&subdir);
49dc2cc2 2593 strbuf_release(&sb);
b9670c1f 2594 return state == path_recurse;
48ffef96
JH
2595}
2596
1e8fef60
NTND
2597static const char *get_ident_string(void)
2598{
2599 static struct strbuf sb = STRBUF_INIT;
2600 struct utsname uts;
2601
2602 if (sb.len)
2603 return sb.buf;
100e4337 2604 if (uname(&uts) < 0)
1e8fef60 2605 die_errno(_("failed to get kernel name and information"));
0e0f7618
CC
2606 strbuf_addf(&sb, "Location %s, system %s", get_git_work_tree(),
2607 uts.sysname);
1e8fef60
NTND
2608 return sb.buf;
2609}
2610
2611static int ident_in_untracked(const struct untracked_cache *uc)
2612{
0e0f7618
CC
2613 /*
2614 * Previous git versions may have saved many NUL separated
2615 * strings in the "ident" field, but it is insane to manage
2616 * many locations, so just take care of the first one.
2617 */
1e8fef60 2618
0e0f7618 2619 return !strcmp(uc->ident.buf, get_ident_string());
1e8fef60
NTND
2620}
2621
0e0f7618 2622static void set_untracked_ident(struct untracked_cache *uc)
1e8fef60 2623{
0e0f7618 2624 strbuf_reset(&uc->ident);
1e8fef60 2625 strbuf_addstr(&uc->ident, get_ident_string());
0e0f7618
CC
2626
2627 /*
2628 * This strbuf used to contain a list of NUL separated
2629 * strings, so save NUL too for backward compatibility.
2630 */
1e8fef60
NTND
2631 strbuf_addch(&uc->ident, 0);
2632}
2633
4a4ca479
CC
2634static void new_untracked_cache(struct index_state *istate)
2635{
2636 struct untracked_cache *uc = xcalloc(1, sizeof(*uc));
2637 strbuf_init(&uc->ident, 100);
2638 uc->exclude_per_dir = ".gitignore";
2639 /* should be the same flags used by git-status */
2640 uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;
0e0f7618 2641 set_untracked_ident(uc);
4a4ca479 2642 istate->untracked = uc;
0e0f7618 2643 istate->cache_changed |= UNTRACKED_CHANGED;
4a4ca479
CC
2644}
2645
2646void add_untracked_cache(struct index_state *istate)
2647{
2648 if (!istate->untracked) {
2649 new_untracked_cache(istate);
0e0f7618
CC
2650 } else {
2651 if (!ident_in_untracked(istate->untracked)) {
2652 free_untracked_cache(istate->untracked);
2653 new_untracked_cache(istate);
2654 }
2655 }
4a4ca479
CC
2656}
2657
07b29bfd
CC
2658void remove_untracked_cache(struct index_state *istate)
2659{
2660 if (istate->untracked) {
2661 free_untracked_cache(istate->untracked);
2662 istate->untracked = NULL;
2663 istate->cache_changed |= UNTRACKED_CHANGED;
2664 }
2665}
2666
ccad261f
NTND
2667static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,
2668 int base_len,
2669 const struct pathspec *pathspec)
2670{
2671 struct untracked_cache_dir *root;
026336cb 2672 static int untracked_cache_disabled = -1;
ccad261f 2673
026336cb
JH
2674 if (!dir->untracked)
2675 return NULL;
2676 if (untracked_cache_disabled < 0)
2677 untracked_cache_disabled = git_env_bool("GIT_DISABLE_UNTRACKED_CACHE", 0);
2678 if (untracked_cache_disabled)
ccad261f
NTND
2679 return NULL;
2680
2681 /*
2682 * We only support $GIT_DIR/info/exclude and core.excludesfile
2683 * as the global ignore rule files. Any other additions
2684 * (e.g. from command line) invalidate the cache. This
2685 * condition also catches running setup_standard_excludes()
2686 * before setting dir->untracked!
2687 */
2688 if (dir->unmanaged_exclude_files)
2689 return NULL;
2690
2691 /*
2692 * Optimize for the main use case only: whole-tree git
2693 * status. More work involved in treat_leading_path() if we
2694 * use cache on just a subset of the worktree. pathspec
2695 * support could make the matter even worse.
2696 */
2697 if (base_len || (pathspec && pathspec->nr))
2698 return NULL;
2699
2700 /* Different set of flags may produce different results */
2701 if (dir->flags != dir->untracked->dir_flags ||
2702 /*
2703 * See treat_directory(), case index_nonexistent. Without
2704 * this flag, we may need to also cache .git file content
2705 * for the resolve_gitlink_ref() call, which we don't.
2706 */
2707 !(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||
2708 /* We don't support collecting ignore files */
2709 (dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |
2710 DIR_COLLECT_IGNORED)))
2711 return NULL;
2712
2713 /*
2714 * If we use .gitignore in the cache and now you change it to
2715 * .gitexclude, everything will go wrong.
2716 */
2717 if (dir->exclude_per_dir != dir->untracked->exclude_per_dir &&
2718 strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))
2719 return NULL;
2720
2721 /*
2722 * EXC_CMDL is not considered in the cache. If people set it,
2723 * skip the cache.
2724 */
2725 if (dir->exclude_list_group[EXC_CMDL].nr)
2726 return NULL;
2727
1e8fef60 2728 if (!ident_in_untracked(dir->untracked)) {
1a07e59c 2729 warning(_("untracked cache is disabled on this system or location"));
1e8fef60
NTND
2730 return NULL;
2731 }
2732
6347d649
JH
2733 if (!dir->untracked->root)
2734 FLEX_ALLOC_STR(dir->untracked->root, name, "");
ccad261f
NTND
2735
2736 /* Validate $GIT_DIR/info/exclude and core.excludesfile */
2737 root = dir->untracked->root;
9001dc2a 2738 if (!oideq(&dir->ss_info_exclude.oid,
4b33e602 2739 &dir->untracked->ss_info_exclude.oid)) {
ccad261f
NTND
2740 invalidate_gitignore(dir->untracked, root);
2741 dir->untracked->ss_info_exclude = dir->ss_info_exclude;
2742 }
9001dc2a 2743 if (!oideq(&dir->ss_excludes_file.oid,
4b33e602 2744 &dir->untracked->ss_excludes_file.oid)) {
ccad261f
NTND
2745 invalidate_gitignore(dir->untracked, root);
2746 dir->untracked->ss_excludes_file = dir->ss_excludes_file;
2747 }
26cb0182
NTND
2748
2749 /* Make sure this directory is not dropped out at saving phase */
2750 root->recurse = 1;
ccad261f
NTND
2751 return root;
2752}
2753
2c1eb104
BW
2754int read_directory(struct dir_struct *dir, struct index_state *istate,
2755 const char *path, int len, const struct pathspec *pathspec)
9fc42d60 2756{
ccad261f 2757 struct untracked_cache_dir *untracked;
b4189aa8 2758
c46c406a
NTND
2759 trace_performance_enter();
2760
2761 if (has_symlink_leading_path(path, len)) {
2762 trace_performance_leave("read directory %.*s", len, path);
725b0605 2763 return dir->nr;
c46c406a 2764 }
725b0605 2765
ccad261f
NTND
2766 untracked = validate_untracked_cache(dir, len, pathspec);
2767 if (!untracked)
2768 /*
2769 * make sure untracked cache code path is disabled,
2770 * e.g. prep_exclude()
2771 */
2772 dir->untracked = NULL;
2c1eb104 2773 if (!len || treat_leading_path(dir, istate, path, len, pathspec))
5aaa7fd3 2774 read_directory_recursive(dir, istate, path, len, untracked, 0, 0, pathspec);
bbf504a9
SL
2775 QSORT(dir->entries, dir->nr, cmp_dir_entry);
2776 QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);
fb898888 2777
c46c406a 2778 trace_performance_leave("read directory %.*s", len, path);
c9ccb5d3 2779 if (dir->untracked) {
026336cb 2780 static int force_untracked_cache = -1;
c9ccb5d3 2781 static struct trace_key trace_untracked_stats = TRACE_KEY_INIT(UNTRACKED_STATS);
026336cb
JH
2782
2783 if (force_untracked_cache < 0)
2784 force_untracked_cache =
2785 git_env_bool("GIT_FORCE_UNTRACKED_CACHE", 0);
c9ccb5d3
NTND
2786 trace_printf_key(&trace_untracked_stats,
2787 "node creation: %u\n"
2788 "gitignore invalidation: %u\n"
2789 "directory invalidation: %u\n"
2790 "opendir: %u\n",
2791 dir->untracked->dir_created,
2792 dir->untracked->gitignore_invalidated,
2793 dir->untracked->dir_invalidated,
2794 dir->untracked->dir_opened);
026336cb 2795 if (force_untracked_cache &&
fc9ecbeb 2796 dir->untracked == istate->untracked &&
1bbb3dba
NTND
2797 (dir->untracked->dir_opened ||
2798 dir->untracked->gitignore_invalidated ||
2799 dir->untracked->dir_invalidated))
2c1eb104
BW
2800 istate->cache_changed |= UNTRACKED_CHANGED;
2801 if (dir->untracked != istate->untracked) {
6a83d902 2802 FREE_AND_NULL(dir->untracked);
1bbb3dba 2803 }
c9ccb5d3 2804 }
453ec4bd
LT
2805 return dir->nr;
2806}
c91f0d92 2807
686a4a06 2808int file_exists(const char *f)
c91f0d92 2809{
686a4a06 2810 struct stat sb;
a50f9fc5 2811 return lstat(f, &sb) == 0;
c91f0d92 2812}
e6636747 2813
0488481e
NTND
2814int repo_file_exists(struct repository *repo, const char *path)
2815{
2816 if (repo != the_repository)
2817 BUG("do not know how to check file existence in arbitrary repo");
2818
2819 return file_exists(path);
2820}
2821
63ec5e1f
JS
2822static int cmp_icase(char a, char b)
2823{
2824 if (a == b)
2825 return 0;
2826 if (ignore_case)
2827 return toupper(a) - toupper(b);
2828 return a - b;
2829}
2830
e6636747 2831/*
9b125da4
NTND
2832 * Given two normalized paths (a trailing slash is ok), if subdir is
2833 * outside dir, return -1. Otherwise return the offset in subdir that
2834 * can be used as relative path to dir.
e6636747 2835 */
9b125da4 2836int dir_inside_of(const char *subdir, const char *dir)
e6636747 2837{
9b125da4 2838 int offset = 0;
e6636747 2839
9b125da4 2840 assert(dir && subdir && *dir && *subdir);
e6636747 2841
63ec5e1f 2842 while (*dir && *subdir && !cmp_icase(*dir, *subdir)) {
e6636747 2843 dir++;
9b125da4
NTND
2844 subdir++;
2845 offset++;
490544b1 2846 }
9b125da4
NTND
2847
2848 /* hel[p]/me vs hel[l]/yeah */
2849 if (*dir && *subdir)
2850 return -1;
2851
2852 if (!*subdir)
2853 return !*dir ? offset : -1; /* same dir */
2854
2855 /* foo/[b]ar vs foo/[] */
2856 if (is_dir_sep(dir[-1]))
2857 return is_dir_sep(subdir[-1]) ? offset : -1;
2858
2859 /* foo[/]bar vs foo[] */
2860 return is_dir_sep(*subdir) ? offset + 1 : -1;
e6636747
JS
2861}
2862
2863int is_inside_dir(const char *dir)
2864{
56b9f6e7
RS
2865 char *cwd;
2866 int rc;
2867
b892913d
NTND
2868 if (!dir)
2869 return 0;
56b9f6e7
RS
2870
2871 cwd = xgetcwd();
2872 rc = (dir_inside_of(cwd, dir) >= 0);
2873 free(cwd);
2874 return rc;
e6636747 2875}
7155b727 2876
55892d23
AP
2877int is_empty_dir(const char *path)
2878{
2879 DIR *dir = opendir(path);
2880 struct dirent *e;
2881 int ret = 1;
2882
2883 if (!dir)
2884 return 0;
2885
2886 while ((e = readdir(dir)) != NULL)
2887 if (!is_dot_or_dotdot(e->d_name)) {
2888 ret = 0;
2889 break;
2890 }
2891
2892 closedir(dir);
2893 return ret;
2894}
2895
ae2f203e 2896static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)
7155b727 2897{
a0f4afbe 2898 DIR *dir;
7155b727 2899 struct dirent *e;
ae2f203e 2900 int ret = 0, original_len = path->len, len, kept_down = 0;
a0f4afbe 2901 int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);
c844a803 2902 int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);
1053fe82 2903 struct object_id submodule_head;
7155b727 2904
a0f4afbe 2905 if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&
a98e6101 2906 !resolve_gitlink_ref(path->buf, "HEAD", &submodule_head)) {
a0f4afbe 2907 /* Do not descend and nuke a nested git work tree. */
ae2f203e
JH
2908 if (kept_up)
2909 *kept_up = 1;
a0f4afbe 2910 return 0;
ae2f203e 2911 }
a0f4afbe 2912
ae2f203e 2913 flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;
a0f4afbe 2914 dir = opendir(path->buf);
c844a803 2915 if (!dir) {
863808cd
MH
2916 if (errno == ENOENT)
2917 return keep_toplevel ? -1 : 0;
2918 else if (errno == EACCES && !keep_toplevel)
ecb2c282
MH
2919 /*
2920 * An empty dir could be removable even if it
2921 * is unreadable:
2922 */
c844a803
JH
2923 return rmdir(path->buf);
2924 else
2925 return -1;
2926 }
00b6c178 2927 strbuf_complete(path, '/');
7155b727
JS
2928
2929 len = path->len;
2930 while ((e = readdir(dir)) != NULL) {
2931 struct stat st;
8ca12c0d
AP
2932 if (is_dot_or_dotdot(e->d_name))
2933 continue;
7155b727
JS
2934
2935 strbuf_setlen(path, len);
2936 strbuf_addstr(path, e->d_name);
863808cd
MH
2937 if (lstat(path->buf, &st)) {
2938 if (errno == ENOENT)
2939 /*
2940 * file disappeared, which is what we
2941 * wanted anyway
2942 */
2943 continue;
15beaaa3 2944 /* fall through */
863808cd 2945 } else if (S_ISDIR(st.st_mode)) {
ae2f203e 2946 if (!remove_dir_recurse(path, flag, &kept_down))
7155b727 2947 continue; /* happy */
863808cd
MH
2948 } else if (!only_empty &&
2949 (!unlink(path->buf) || errno == ENOENT)) {
7155b727 2950 continue; /* happy, too */
863808cd 2951 }
7155b727
JS
2952
2953 /* path too long, stat fails, or non-directory still exists */
2954 ret = -1;
2955 break;
2956 }
2957 closedir(dir);
2958
2959 strbuf_setlen(path, original_len);
ae2f203e 2960 if (!ret && !keep_toplevel && !kept_down)
863808cd 2961 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;
ae2f203e
JH
2962 else if (kept_up)
2963 /*
2964 * report the uplevel that it is not an error that we
2965 * did not rmdir() our directory.
2966 */
2967 *kept_up = !ret;
7155b727
JS
2968 return ret;
2969}
039bc64e 2970
ae2f203e
JH
2971int remove_dir_recursively(struct strbuf *path, int flag)
2972{
2973 return remove_dir_recurse(path, flag, NULL);
2974}
2975
f932729c
JK
2976static GIT_PATH_FUNC(git_path_info_exclude, "info/exclude")
2977
039bc64e
JH
2978void setup_standard_excludes(struct dir_struct *dir)
2979{
039bc64e 2980 dir->exclude_per_dir = ".gitignore";
099d2d86 2981
51d18631 2982 /* core.excludesfile defaulting to $XDG_CONFIG_HOME/git/ignore */
2845ce7f
PT
2983 if (!excludes_file)
2984 excludes_file = xdg_config_home("ignore");
4698c8fe 2985 if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))
65edd96a 2986 add_patterns_from_file_1(dir, excludes_file,
38ccaf93 2987 dir->untracked ? &dir->ss_excludes_file : NULL);
099d2d86
JH
2988
2989 /* per repository user preference */
f0056f64
JK
2990 if (startup_info->have_repository) {
2991 const char *path = git_path_info_exclude();
2992 if (!access_or_warn(path, R_OK, 0))
65edd96a 2993 add_patterns_from_file_1(dir, path,
f0056f64
JK
2994 dir->untracked ? &dir->ss_info_exclude : NULL);
2995 }
039bc64e 2996}
4a92d1bf 2997
dd23022a
DS
2998char *get_sparse_checkout_filename(void)
2999{
3000 return git_pathdup("info/sparse-checkout");
3001}
3002
3003int get_sparse_checkout_patterns(struct pattern_list *pl)
3004{
3005 int res;
3006 char *sparse_filename = get_sparse_checkout_filename();
3007
3008 pl->use_cone_patterns = core_sparse_checkout_cone;
3009 res = add_patterns_from_file_to_list(sparse_filename, "", 0, pl, NULL);
3010
3011 free(sparse_filename);
3012 return res;
3013}
3014
4a92d1bf
AR
3015int remove_path(const char *name)
3016{
3017 char *slash;
3018
c7054209 3019 if (unlink(name) && !is_missing_file_error(errno))
4a92d1bf
AR
3020 return -1;
3021
3022 slash = strrchr(name, '/');
3023 if (slash) {
3024 char *dirs = xstrdup(name);
3025 slash = dirs + (slash - name);
3026 do {
3027 *slash = '\0';
3fc0d131 3028 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));
4a92d1bf
AR
3029 free(dirs);
3030 }
3031 return 0;
3032}
3033
270be816 3034/*
dad4f23c
EN
3035 * Frees memory within dir which was allocated, and resets fields for further
3036 * use. Does not free dir itself.
270be816 3037 */
eceba532 3038void dir_clear(struct dir_struct *dir)
270be816
AS
3039{
3040 int i, j;
3041 struct exclude_list_group *group;
caa3d554 3042 struct pattern_list *pl;
270be816
AS
3043 struct exclude_stack *stk;
3044
3045 for (i = EXC_CMDL; i <= EXC_FILE; i++) {
3046 group = &dir->exclude_list_group[i];
3047 for (j = 0; j < group->nr; j++) {
caa3d554 3048 pl = &group->pl[j];
270be816 3049 if (i == EXC_DIRS)
caa3d554 3050 free((char *)pl->src);
65edd96a 3051 clear_pattern_list(pl);
270be816 3052 }
caa3d554 3053 free(group->pl);
270be816
AS
3054 }
3055
dad4f23c
EN
3056 for (i = 0; i < dir->ignored_nr; i++)
3057 free(dir->ignored[i]);
3058 for (i = 0; i < dir->nr; i++)
3059 free(dir->entries[i]);
3060 free(dir->ignored);
3061 free(dir->entries);
3062
270be816
AS
3063 stk = dir->exclude_stack;
3064 while (stk) {
3065 struct exclude_stack *prev = stk->prev;
3066 free(stk);
3067 stk = prev;
3068 }
aceb9429 3069 strbuf_release(&dir->basebuf);
dad4f23c 3070
eceba532 3071 dir_init(dir);
270be816 3072}
83c094ad
NTND
3073
3074struct ondisk_untracked_cache {
3075 struct stat_data info_exclude_stat;
3076 struct stat_data excludes_file_stat;
3077 uint32_t dir_flags;
83c094ad
NTND
3078};
3079
268ba201 3080#define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)
83c094ad
NTND
3081
3082struct write_data {
3083 int index; /* number of written untracked_cache_dir */
3084 struct ewah_bitmap *check_only; /* from untracked_cache_dir */
3085 struct ewah_bitmap *valid; /* from untracked_cache_dir */
3086 struct ewah_bitmap *sha1_valid; /* set if exclude_sha1 is not null */
3087 struct strbuf out;
3088 struct strbuf sb_stat;
3089 struct strbuf sb_sha1;
3090};
3091
3092static void stat_data_to_disk(struct stat_data *to, const struct stat_data *from)
3093{
3094 to->sd_ctime.sec = htonl(from->sd_ctime.sec);
3095 to->sd_ctime.nsec = htonl(from->sd_ctime.nsec);
3096 to->sd_mtime.sec = htonl(from->sd_mtime.sec);
3097 to->sd_mtime.nsec = htonl(from->sd_mtime.nsec);
3098 to->sd_dev = htonl(from->sd_dev);
3099 to->sd_ino = htonl(from->sd_ino);
3100 to->sd_uid = htonl(from->sd_uid);
3101 to->sd_gid = htonl(from->sd_gid);
3102 to->sd_size = htonl(from->sd_size);
3103}
3104
3105static void write_one_dir(struct untracked_cache_dir *untracked,
3106 struct write_data *wd)
3107{
3108 struct stat_data stat_data;
3109 struct strbuf *out = &wd->out;
3110 unsigned char intbuf[16];
3111 unsigned int intlen, value;
3112 int i = wd->index++;
3113
3114 /*
3115 * untracked_nr should be reset whenever valid is clear, but
3116 * for safety..
3117 */
3118 if (!untracked->valid) {
3119 untracked->untracked_nr = 0;
3120 untracked->check_only = 0;
3121 }
3122
3123 if (untracked->check_only)
3124 ewah_set(wd->check_only, i);
3125 if (untracked->valid) {
3126 ewah_set(wd->valid, i);
3127 stat_data_to_disk(&stat_data, &untracked->stat_data);
3128 strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data));
3129 }
70c369cd 3130 if (!is_null_oid(&untracked->exclude_oid)) {
83c094ad 3131 ewah_set(wd->sha1_valid, i);
70c369cd 3132 strbuf_add(&wd->sb_sha1, untracked->exclude_oid.hash,
3133 the_hash_algo->rawsz);
83c094ad
NTND
3134 }
3135
3136 intlen = encode_varint(untracked->untracked_nr, intbuf);
3137 strbuf_add(out, intbuf, intlen);
3138
3139 /* skip non-recurse directories */
3140 for (i = 0, value = 0; i < untracked->dirs_nr; i++)
3141 if (untracked->dirs[i]->recurse)
3142 value++;
3143 intlen = encode_varint(value, intbuf);
3144 strbuf_add(out, intbuf, intlen);
3145
3146 strbuf_add(out, untracked->name, strlen(untracked->name) + 1);
3147
3148 for (i = 0; i < untracked->untracked_nr; i++)
3149 strbuf_add(out, untracked->untracked[i],
3150 strlen(untracked->untracked[i]) + 1);
3151
3152 for (i = 0; i < untracked->dirs_nr; i++)
3153 if (untracked->dirs[i]->recurse)
3154 write_one_dir(untracked->dirs[i], wd);
3155}
3156
3157void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked)
3158{
3159 struct ondisk_untracked_cache *ouc;
3160 struct write_data wd;
3161 unsigned char varbuf[16];
e0b83735 3162 int varint_len;
3899b88b 3163 const unsigned hashsz = the_hash_algo->rawsz;
e0b83735 3164
ca56dadb 3165 CALLOC_ARRAY(ouc, 1);
83c094ad
NTND
3166 stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);
3167 stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);
83c094ad 3168 ouc->dir_flags = htonl(untracked->dir_flags);
1e8fef60
NTND
3169
3170 varint_len = encode_varint(untracked->ident.len, varbuf);
3171 strbuf_add(out, varbuf, varint_len);
8109984d 3172 strbuf_addbuf(out, &untracked->ident);
1e8fef60 3173
3899b88b 3174 strbuf_add(out, ouc, sizeof(*ouc));
3175 strbuf_add(out, untracked->ss_info_exclude.oid.hash, hashsz);
3176 strbuf_add(out, untracked->ss_excludes_file.oid.hash, hashsz);
3177 strbuf_add(out, untracked->exclude_per_dir, strlen(untracked->exclude_per_dir) + 1);
6a83d902 3178 FREE_AND_NULL(ouc);
83c094ad
NTND
3179
3180 if (!untracked->root) {
3181 varint_len = encode_varint(0, varbuf);
3182 strbuf_add(out, varbuf, varint_len);
3183 return;
3184 }
3185
3186 wd.index = 0;
3187 wd.check_only = ewah_new();
3188 wd.valid = ewah_new();
3189 wd.sha1_valid = ewah_new();
3190 strbuf_init(&wd.out, 1024);
3191 strbuf_init(&wd.sb_stat, 1024);
3192 strbuf_init(&wd.sb_sha1, 1024);
3193 write_one_dir(untracked->root, &wd);
3194
3195 varint_len = encode_varint(wd.index, varbuf);
3196 strbuf_add(out, varbuf, varint_len);
3197 strbuf_addbuf(out, &wd.out);
3198 ewah_serialize_strbuf(wd.valid, out);
3199 ewah_serialize_strbuf(wd.check_only, out);
3200 ewah_serialize_strbuf(wd.sha1_valid, out);
3201 strbuf_addbuf(out, &wd.sb_stat);
3202 strbuf_addbuf(out, &wd.sb_sha1);
3203 strbuf_addch(out, '\0'); /* safe guard for string lists */
3204
3205 ewah_free(wd.valid);
3206 ewah_free(wd.check_only);
3207 ewah_free(wd.sha1_valid);
3208 strbuf_release(&wd.out);
3209 strbuf_release(&wd.sb_stat);
3210 strbuf_release(&wd.sb_sha1);
3211}
f9e6c649
NTND
3212
3213static void free_untracked(struct untracked_cache_dir *ucd)
3214{
3215 int i;
3216 if (!ucd)
3217 return;
3218 for (i = 0; i < ucd->dirs_nr; i++)
3219 free_untracked(ucd->dirs[i]);
3220 for (i = 0; i < ucd->untracked_nr; i++)
3221 free(ucd->untracked[i]);
3222 free(ucd->untracked);
3223 free(ucd->dirs);
3224 free(ucd);
3225}
3226
3227void free_untracked_cache(struct untracked_cache *uc)
3228{
3229 if (uc)
3230 free_untracked(uc->root);
3231 free(uc);
3232}
3233
3234struct read_data {
3235 int index;
3236 struct untracked_cache_dir **ucd;
3237 struct ewah_bitmap *check_only;
3238 struct ewah_bitmap *valid;
3239 struct ewah_bitmap *sha1_valid;
3240 const unsigned char *data;
3241 const unsigned char *end;
3242};
3243
268ba201 3244static void stat_data_from_disk(struct stat_data *to, const unsigned char *data)
f9e6c649 3245{
268ba201
RS
3246 memcpy(to, data, sizeof(*to));
3247 to->sd_ctime.sec = ntohl(to->sd_ctime.sec);
3248 to->sd_ctime.nsec = ntohl(to->sd_ctime.nsec);
3249 to->sd_mtime.sec = ntohl(to->sd_mtime.sec);
3250 to->sd_mtime.nsec = ntohl(to->sd_mtime.nsec);
3251 to->sd_dev = ntohl(to->sd_dev);
3252 to->sd_ino = ntohl(to->sd_ino);
3253 to->sd_uid = ntohl(to->sd_uid);
3254 to->sd_gid = ntohl(to->sd_gid);
3255 to->sd_size = ntohl(to->sd_size);
f9e6c649
NTND
3256}
3257
3258static int read_one_dir(struct untracked_cache_dir **untracked_,
3259 struct read_data *rd)
3260{
3261 struct untracked_cache_dir ud, *untracked;
b511d6d5 3262 const unsigned char *data = rd->data, *end = rd->end;
c6909f99 3263 const unsigned char *eos;
f9e6c649 3264 unsigned int value;
08bf354d 3265 int i;
f9e6c649
NTND
3266
3267 memset(&ud, 0, sizeof(ud));
3268
b511d6d5
JK
3269 value = decode_varint(&data);
3270 if (data > end)
f9e6c649
NTND
3271 return -1;
3272 ud.recurse = 1;
3273 ud.untracked_alloc = value;
3274 ud.untracked_nr = value;
3275 if (ud.untracked_nr)
b32fa95f 3276 ALLOC_ARRAY(ud.untracked, ud.untracked_nr);
f9e6c649 3277
b511d6d5
JK
3278 ud.dirs_alloc = ud.dirs_nr = decode_varint(&data);
3279 if (data > end)
f9e6c649 3280 return -1;
b32fa95f 3281 ALLOC_ARRAY(ud.dirs, ud.dirs_nr);
f9e6c649 3282
c6909f99
JK
3283 eos = memchr(data, '\0', end - data);
3284 if (!eos || eos == end)
f9e6c649 3285 return -1;
c6909f99 3286
08bf354d 3287 *untracked_ = untracked = xmalloc(st_add3(sizeof(*untracked), eos - data, 1));
f9e6c649 3288 memcpy(untracked, &ud, sizeof(ud));
08bf354d 3289 memcpy(untracked->name, data, eos - data + 1);
b511d6d5 3290 data = eos + 1;
f9e6c649
NTND
3291
3292 for (i = 0; i < untracked->untracked_nr; i++) {
c6909f99
JK
3293 eos = memchr(data, '\0', end - data);
3294 if (!eos || eos == end)
f9e6c649 3295 return -1;
08bf354d 3296 untracked->untracked[i] = xmemdupz(data, eos - data);
b511d6d5 3297 data = eos + 1;
f9e6c649
NTND
3298 }
3299
3300 rd->ucd[rd->index++] = untracked;
3301 rd->data = data;
3302
3303 for (i = 0; i < untracked->dirs_nr; i++) {
08bf354d 3304 if (read_one_dir(untracked->dirs + i, rd) < 0)
f9e6c649
NTND
3305 return -1;
3306 }
3307 return 0;
3308}
3309
3310static void set_check_only(size_t pos, void *cb)
3311{
3312 struct read_data *rd = cb;
3313 struct untracked_cache_dir *ud = rd->ucd[pos];
3314 ud->check_only = 1;
3315}
3316
3317static void read_stat(size_t pos, void *cb)
3318{
3319 struct read_data *rd = cb;
3320 struct untracked_cache_dir *ud = rd->ucd[pos];
3321 if (rd->data + sizeof(struct stat_data) > rd->end) {
3322 rd->data = rd->end + 1;
3323 return;
3324 }
268ba201 3325 stat_data_from_disk(&ud->stat_data, rd->data);
f9e6c649
NTND
3326 rd->data += sizeof(struct stat_data);
3327 ud->valid = 1;
3328}
3329
70c369cd 3330static void read_oid(size_t pos, void *cb)
f9e6c649
NTND
3331{
3332 struct read_data *rd = cb;
3333 struct untracked_cache_dir *ud = rd->ucd[pos];
70c369cd 3334 if (rd->data + the_hash_algo->rawsz > rd->end) {
f9e6c649
NTND
3335 rd->data = rd->end + 1;
3336 return;
3337 }
70c369cd 3338 hashcpy(ud->exclude_oid.hash, rd->data);
3339 rd->data += the_hash_algo->rawsz;
f9e6c649
NTND
3340}
3341
4b33e602
PO
3342static void load_oid_stat(struct oid_stat *oid_stat, const unsigned char *data,
3343 const unsigned char *sha1)
f9e6c649 3344{
4b33e602
PO
3345 stat_data_from_disk(&oid_stat->stat, data);
3346 hashcpy(oid_stat->oid.hash, sha1);
3347 oid_stat->valid = 1;
f9e6c649
NTND
3348}
3349
3350struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz)
3351{
f9e6c649
NTND
3352 struct untracked_cache *uc;
3353 struct read_data rd;
3354 const unsigned char *next = data, *end = (const unsigned char *)data + sz;
1e8fef60 3355 const char *ident;
1140bf01
JK
3356 int ident_len;
3357 ssize_t len;
268ba201 3358 const char *exclude_per_dir;
3899b88b 3359 const unsigned hashsz = the_hash_algo->rawsz;
3360 const unsigned offset = sizeof(struct ondisk_untracked_cache);
3361 const unsigned exclude_per_dir_offset = offset + 2 * hashsz;
f9e6c649
NTND
3362
3363 if (sz <= 1 || end[-1] != '\0')
3364 return NULL;
3365 end--;
3366
1e8fef60
NTND
3367 ident_len = decode_varint(&next);
3368 if (next + ident_len > end)
3369 return NULL;
3370 ident = (const char *)next;
3371 next += ident_len;
3372
3899b88b 3373 if (next + exclude_per_dir_offset + 1 > end)
f9e6c649
NTND
3374 return NULL;
3375
ca56dadb 3376 CALLOC_ARRAY(uc, 1);
1e8fef60
NTND
3377 strbuf_init(&uc->ident, ident_len);
3378 strbuf_add(&uc->ident, ident, ident_len);
4b33e602
PO
3379 load_oid_stat(&uc->ss_info_exclude,
3380 next + ouc_offset(info_exclude_stat),
3899b88b 3381 next + offset);
4b33e602
PO
3382 load_oid_stat(&uc->ss_excludes_file,
3383 next + ouc_offset(excludes_file_stat),
3899b88b 3384 next + offset + hashsz);
268ba201 3385 uc->dir_flags = get_be32(next + ouc_offset(dir_flags));
3899b88b 3386 exclude_per_dir = (const char *)next + exclude_per_dir_offset;
268ba201 3387 uc->exclude_per_dir = xstrdup(exclude_per_dir);
f9e6c649 3388 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */
3899b88b 3389 next += exclude_per_dir_offset + strlen(exclude_per_dir) + 1;
f9e6c649
NTND
3390 if (next >= end)
3391 goto done2;
3392
3393 len = decode_varint(&next);
3394 if (next > end || len == 0)
3395 goto done2;
3396
3397 rd.valid = ewah_new();
3398 rd.check_only = ewah_new();
3399 rd.sha1_valid = ewah_new();
3400 rd.data = next;
3401 rd.end = end;
3402 rd.index = 0;
b32fa95f 3403 ALLOC_ARRAY(rd.ucd, len);
f9e6c649
NTND
3404
3405 if (read_one_dir(&uc->root, &rd) || rd.index != len)
3406 goto done;
3407
3408 next = rd.data;
3409 len = ewah_read_mmap(rd.valid, next, end - next);
3410 if (len < 0)
3411 goto done;
3412
3413 next += len;
3414 len = ewah_read_mmap(rd.check_only, next, end - next);
3415 if (len < 0)
3416 goto done;
3417
3418 next += len;
3419 len = ewah_read_mmap(rd.sha1_valid, next, end - next);
3420 if (len < 0)
3421 goto done;
3422
3423 ewah_each_bit(rd.check_only, set_check_only, &rd);
3424 rd.data = next + len;
3425 ewah_each_bit(rd.valid, read_stat, &rd);
70c369cd 3426 ewah_each_bit(rd.sha1_valid, read_oid, &rd);
f9e6c649
NTND
3427 next = rd.data;
3428
3429done:
3430 free(rd.ucd);
3431 ewah_free(rd.valid);
3432 ewah_free(rd.check_only);
3433 ewah_free(rd.sha1_valid);
3434done2:
3435 if (next != end) {
3436 free_untracked_cache(uc);
3437 uc = NULL;
3438 }
3439 return uc;
3440}
e931371a 3441
73f9145f
NTND
3442static void invalidate_one_directory(struct untracked_cache *uc,
3443 struct untracked_cache_dir *ucd)
3444{
3445 uc->dir_invalidated++;
3446 ucd->valid = 0;
3447 ucd->untracked_nr = 0;
3448}
3449
3450/*
3451 * Normally when an entry is added or removed from a directory,
3452 * invalidating that directory is enough. No need to touch its
3453 * ancestors. When a directory is shown as "foo/bar/" in git-status
3454 * however, deleting or adding an entry may have cascading effect.
3455 *
3456 * Say the "foo/bar/file" has become untracked, we need to tell the
3457 * untracked_cache_dir of "foo" that "bar/" is not an untracked
3458 * directory any more (because "bar" is managed by foo as an untracked
3459 * "file").
3460 *
3461 * Similarly, if "foo/bar/file" moves from untracked to tracked and it
3462 * was the last untracked entry in the entire "foo", we should show
3463 * "foo/" instead. Which means we have to invalidate past "bar" up to
3464 * "foo".
3465 *
3466 * This function traverses all directories from root to leaf. If there
3467 * is a chance of one of the above cases happening, we invalidate back
3468 * to root. Otherwise we just invalidate the leaf. There may be a more
3469 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to
3470 * detect these cases and avoid unnecessary invalidation, for example,
3471 * checking for the untracked entry named "bar/" in "foo", but for now
3472 * stick to something safe and simple.
3473 */
3474static int invalidate_one_component(struct untracked_cache *uc,
3475 struct untracked_cache_dir *dir,
3476 const char *path, int len)
3477{
3478 const char *rest = strchr(path, '/');
3479
3480 if (rest) {
3481 int component_len = rest - path;
3482 struct untracked_cache_dir *d =
3483 lookup_untracked(uc, dir, path, component_len);
3484 int ret =
3485 invalidate_one_component(uc, d, rest + 1,
3486 len - (component_len + 1));
3487 if (ret)
3488 invalidate_one_directory(uc, dir);
3489 return ret;
3490 }
3491
3492 invalidate_one_directory(uc, dir);
3493 return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;
3494}
3495
e931371a 3496void untracked_cache_invalidate_path(struct index_state *istate,
0cacebf0 3497 const char *path, int safe_path)
e931371a 3498{
e931371a
NTND
3499 if (!istate->untracked || !istate->untracked->root)
3500 return;
68f95b26 3501 if (!safe_path && !verify_path(path, 0))
0cacebf0 3502 return;
73f9145f
NTND
3503 invalidate_one_component(istate->untracked, istate->untracked->root,
3504 path, strlen(path));
e931371a
NTND
3505}
3506
3507void untracked_cache_remove_from_index(struct index_state *istate,
3508 const char *path)
3509{
0cacebf0 3510 untracked_cache_invalidate_path(istate, path, 1);
e931371a
NTND
3511}
3512
3513void untracked_cache_add_to_index(struct index_state *istate,
3514 const char *path)
3515{
0cacebf0 3516 untracked_cache_invalidate_path(istate, path, 1);
e931371a 3517}
47e83eb3 3518
da62f786
SB
3519static void connect_wt_gitdir_in_nested(const char *sub_worktree,
3520 const char *sub_gitdir)
3521{
3522 int i;
3523 struct repository subrepo;
3524 struct strbuf sub_wt = STRBUF_INIT;
3525 struct strbuf sub_gd = STRBUF_INIT;
3526
3527 const struct submodule *sub;
3528
3529 /* If the submodule has no working tree, we can ignore it. */
3530 if (repo_init(&subrepo, sub_gitdir, sub_worktree))
3531 return;
3532
3533 if (repo_read_index(&subrepo) < 0)
a80897c1 3534 die(_("index file corrupt in repo %s"), subrepo.gitdir);
da62f786
SB
3535
3536 for (i = 0; i < subrepo.index->cache_nr; i++) {
3537 const struct cache_entry *ce = subrepo.index->cache[i];
3538
3539 if (!S_ISGITLINK(ce->ce_mode))
3540 continue;
3541
3542 while (i + 1 < subrepo.index->cache_nr &&
3543 !strcmp(ce->name, subrepo.index->cache[i + 1]->name))
3544 /*
3545 * Skip entries with the same name in different stages
3546 * to make sure an entry is returned only once.
3547 */
3548 i++;
3549
3550 sub = submodule_from_path(&subrepo, &null_oid, ce->name);
3551 if (!sub || !is_submodule_active(&subrepo, ce->name))
3552 /* .gitmodules broken or inactive sub */
3553 continue;
3554
3555 strbuf_reset(&sub_wt);
3556 strbuf_reset(&sub_gd);
3557 strbuf_addf(&sub_wt, "%s/%s", sub_worktree, sub->path);
3558 strbuf_addf(&sub_gd, "%s/modules/%s", sub_gitdir, sub->name);
3559
3560 connect_work_tree_and_git_dir(sub_wt.buf, sub_gd.buf, 1);
3561 }
3562 strbuf_release(&sub_wt);
3563 strbuf_release(&sub_gd);
3564 repo_clear(&subrepo);
3565}
3566
3567void connect_work_tree_and_git_dir(const char *work_tree_,
3568 const char *git_dir_,
3569 int recurse_into_nested)
47e83eb3 3570{
365444a6
SB
3571 struct strbuf gitfile_sb = STRBUF_INIT;
3572 struct strbuf cfg_sb = STRBUF_INIT;
47e83eb3 3573 struct strbuf rel_path = STRBUF_INIT;
365444a6 3574 char *git_dir, *work_tree;
47e83eb3 3575
365444a6
SB
3576 /* Prepare .git file */
3577 strbuf_addf(&gitfile_sb, "%s/.git", work_tree_);
3578 if (safe_create_leading_directories_const(gitfile_sb.buf))
3579 die(_("could not create directories for %s"), gitfile_sb.buf);
3580
3581 /* Prepare config file */
3582 strbuf_addf(&cfg_sb, "%s/config", git_dir_);
3583 if (safe_create_leading_directories_const(cfg_sb.buf))
3584 die(_("could not create directories for %s"), cfg_sb.buf);
47e83eb3 3585
e394fa01
JH
3586 git_dir = real_pathdup(git_dir_, 1);
3587 work_tree = real_pathdup(work_tree_, 1);
365444a6
SB
3588
3589 /* Write .git file */
3590 write_file(gitfile_sb.buf, "gitdir: %s",
3591 relative_path(git_dir, work_tree, &rel_path));
47e83eb3 3592 /* Update core.worktree setting */
365444a6 3593 git_config_set_in_file(cfg_sb.buf, "core.worktree",
47e83eb3
SB
3594 relative_path(work_tree, git_dir, &rel_path));
3595
365444a6
SB
3596 strbuf_release(&gitfile_sb);
3597 strbuf_release(&cfg_sb);
47e83eb3 3598 strbuf_release(&rel_path);
da62f786
SB
3599
3600 if (recurse_into_nested)
3601 connect_wt_gitdir_in_nested(work_tree, git_dir);
3602
47e83eb3
SB
3603 free(work_tree);
3604 free(git_dir);
3605}
f6f85861
SB
3606
3607/*
3608 * Migrate the git directory of the given path from old_git_dir to new_git_dir.
3609 */
3610void relocate_gitdir(const char *path, const char *old_git_dir, const char *new_git_dir)
3611{
3612 if (rename(old_git_dir, new_git_dir) < 0)
3613 die_errno(_("could not migrate git directory from '%s' to '%s'"),
3614 old_git_dir, new_git_dir);
3615
da62f786 3616 connect_work_tree_and_git_dir(path, new_git_dir, 0);
f6f85861 3617}