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