Merge branch 'jt/remove-pack-bitmap-global'
[git] / dir.c
1 /*
2  * This handles recursive filename detection with exclude
3  * files, index knowledge etc..
4  *
5  * See Documentation/technical/api-directory-listing.txt
6  *
7  * Copyright (C) Linus Torvalds, 2005-2006
8  *               Junio Hamano, 2005-2006
9  */
10 #define NO_THE_INDEX_COMPATIBILITY_MACROS
11 #include "cache.h"
12 #include "config.h"
13 #include "dir.h"
14 #include "object-store.h"
15 #include "attr.h"
16 #include "refs.h"
17 #include "wildmatch.h"
18 #include "pathspec.h"
19 #include "utf8.h"
20 #include "varint.h"
21 #include "ewah/ewok.h"
22 #include "fsmonitor.h"
23 #include "submodule-config.h"
24
25 /*
26  * Tells read_directory_recursive how a file or directory should be treated.
27  * Values are ordered by significance, e.g. if a directory contains both
28  * excluded and untracked files, it is listed as untracked because
29  * path_untracked > path_excluded.
30  */
31 enum path_treatment {
32         path_none = 0,
33         path_recurse,
34         path_excluded,
35         path_untracked
36 };
37
38 /*
39  * Support data structure for our opendir/readdir/closedir wrappers
40  */
41 struct cached_dir {
42         DIR *fdir;
43         struct untracked_cache_dir *untracked;
44         int nr_files;
45         int nr_dirs;
46
47         struct dirent *de;
48         const char *file;
49         struct untracked_cache_dir *ucd;
50 };
51
52 static enum path_treatment read_directory_recursive(struct dir_struct *dir,
53         struct index_state *istate, const char *path, int len,
54         struct untracked_cache_dir *untracked,
55         int check_only, int stop_at_first_file, const struct pathspec *pathspec);
56 static int get_dtype(struct dirent *de, struct index_state *istate,
57                      const char *path, int len);
58
59 int count_slashes(const char *s)
60 {
61         int cnt = 0;
62         while (*s)
63                 if (*s++ == '/')
64                         cnt++;
65         return cnt;
66 }
67
68 int fspathcmp(const char *a, const char *b)
69 {
70         return ignore_case ? strcasecmp(a, b) : strcmp(a, b);
71 }
72
73 int fspathncmp(const char *a, const char *b, size_t count)
74 {
75         return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count);
76 }
77
78 int git_fnmatch(const struct pathspec_item *item,
79                 const char *pattern, const char *string,
80                 int prefix)
81 {
82         if (prefix > 0) {
83                 if (ps_strncmp(item, pattern, string, prefix))
84                         return WM_NOMATCH;
85                 pattern += prefix;
86                 string += prefix;
87         }
88         if (item->flags & PATHSPEC_ONESTAR) {
89                 int pattern_len = strlen(++pattern);
90                 int string_len = strlen(string);
91                 return string_len < pattern_len ||
92                         ps_strcmp(item, pattern,
93                                   string + string_len - pattern_len);
94         }
95         if (item->magic & PATHSPEC_GLOB)
96                 return wildmatch(pattern, string,
97                                  WM_PATHNAME |
98                                  (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0));
99         else
100                 /* wildmatch has not learned no FNM_PATHNAME mode yet */
101                 return wildmatch(pattern, string,
102                                  item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0);
103 }
104
105 static int fnmatch_icase_mem(const char *pattern, int patternlen,
106                              const char *string, int stringlen,
107                              int flags)
108 {
109         int match_status;
110         struct strbuf pat_buf = STRBUF_INIT;
111         struct strbuf str_buf = STRBUF_INIT;
112         const char *use_pat = pattern;
113         const char *use_str = string;
114
115         if (pattern[patternlen]) {
116                 strbuf_add(&pat_buf, pattern, patternlen);
117                 use_pat = pat_buf.buf;
118         }
119         if (string[stringlen]) {
120                 strbuf_add(&str_buf, string, stringlen);
121                 use_str = str_buf.buf;
122         }
123
124         if (ignore_case)
125                 flags |= WM_CASEFOLD;
126         match_status = wildmatch(use_pat, use_str, flags);
127
128         strbuf_release(&pat_buf);
129         strbuf_release(&str_buf);
130
131         return match_status;
132 }
133
134 static size_t common_prefix_len(const struct pathspec *pathspec)
135 {
136         int n;
137         size_t max = 0;
138
139         /*
140          * ":(icase)path" is treated as a pathspec full of
141          * wildcard. In other words, only prefix is considered common
142          * prefix. If the pathspec is abc/foo abc/bar, running in
143          * subdir xyz, the common prefix is still xyz, not xuz/abc as
144          * in non-:(icase).
145          */
146         GUARD_PATHSPEC(pathspec,
147                        PATHSPEC_FROMTOP |
148                        PATHSPEC_MAXDEPTH |
149                        PATHSPEC_LITERAL |
150                        PATHSPEC_GLOB |
151                        PATHSPEC_ICASE |
152                        PATHSPEC_EXCLUDE |
153                        PATHSPEC_ATTR);
154
155         for (n = 0; n < pathspec->nr; n++) {
156                 size_t i = 0, len = 0, item_len;
157                 if (pathspec->items[n].magic & PATHSPEC_EXCLUDE)
158                         continue;
159                 if (pathspec->items[n].magic & PATHSPEC_ICASE)
160                         item_len = pathspec->items[n].prefix;
161                 else
162                         item_len = pathspec->items[n].nowildcard_len;
163                 while (i < item_len && (n == 0 || i < max)) {
164                         char c = pathspec->items[n].match[i];
165                         if (c != pathspec->items[0].match[i])
166                                 break;
167                         if (c == '/')
168                                 len = i + 1;
169                         i++;
170                 }
171                 if (n == 0 || len < max) {
172                         max = len;
173                         if (!max)
174                                 break;
175                 }
176         }
177         return max;
178 }
179
180 /*
181  * Returns a copy of the longest leading path common among all
182  * pathspecs.
183  */
184 char *common_prefix(const struct pathspec *pathspec)
185 {
186         unsigned long len = common_prefix_len(pathspec);
187
188         return len ? xmemdupz(pathspec->items[0].match, len) : NULL;
189 }
190
191 int fill_directory(struct dir_struct *dir,
192                    struct index_state *istate,
193                    const struct pathspec *pathspec)
194 {
195         const char *prefix;
196         size_t prefix_len;
197
198         /*
199          * Calculate common prefix for the pathspec, and
200          * use that to optimize the directory walk
201          */
202         prefix_len = common_prefix_len(pathspec);
203         prefix = prefix_len ? pathspec->items[0].match : "";
204
205         /* Read the directory and prune it */
206         read_directory(dir, istate, prefix, prefix_len, pathspec);
207
208         return prefix_len;
209 }
210
211 int within_depth(const char *name, int namelen,
212                         int depth, int max_depth)
213 {
214         const char *cp = name, *cpe = name + namelen;
215
216         while (cp < cpe) {
217                 if (*cp++ != '/')
218                         continue;
219                 depth++;
220                 if (depth > max_depth)
221                         return 0;
222         }
223         return 1;
224 }
225
226 /*
227  * Read the contents of the blob with the given OID into a buffer.
228  * Append a trailing LF to the end if the last line doesn't have one.
229  *
230  * Returns:
231  *    -1 when the OID is invalid or unknown or does not refer to a blob.
232  *     0 when the blob is empty.
233  *     1 along with { data, size } of the (possibly augmented) buffer
234  *       when successful.
235  *
236  * Optionally updates the given oid_stat with the given OID (when valid).
237  */
238 static int do_read_blob(const struct object_id *oid, struct oid_stat *oid_stat,
239                         size_t *size_out, char **data_out)
240 {
241         enum object_type type;
242         unsigned long sz;
243         char *data;
244
245         *size_out = 0;
246         *data_out = NULL;
247
248         data = read_object_file(oid, &type, &sz);
249         if (!data || type != OBJ_BLOB) {
250                 free(data);
251                 return -1;
252         }
253
254         if (oid_stat) {
255                 memset(&oid_stat->stat, 0, sizeof(oid_stat->stat));
256                 oidcpy(&oid_stat->oid, oid);
257         }
258
259         if (sz == 0) {
260                 free(data);
261                 return 0;
262         }
263
264         if (data[sz - 1] != '\n') {
265                 data = xrealloc(data, st_add(sz, 1));
266                 data[sz++] = '\n';
267         }
268
269         *size_out = xsize_t(sz);
270         *data_out = data;
271
272         return 1;
273 }
274
275 #define DO_MATCH_EXCLUDE   (1<<0)
276 #define DO_MATCH_DIRECTORY (1<<1)
277 #define DO_MATCH_SUBMODULE (1<<2)
278
279 static int match_attrs(const char *name, int namelen,
280                        const struct pathspec_item *item)
281 {
282         int i;
283
284         git_check_attr(name, item->attr_check);
285         for (i = 0; i < item->attr_match_nr; i++) {
286                 const char *value;
287                 int matched;
288                 enum attr_match_mode match_mode;
289
290                 value = item->attr_check->items[i].value;
291                 match_mode = item->attr_match[i].match_mode;
292
293                 if (ATTR_TRUE(value))
294                         matched = (match_mode == MATCH_SET);
295                 else if (ATTR_FALSE(value))
296                         matched = (match_mode == MATCH_UNSET);
297                 else if (ATTR_UNSET(value))
298                         matched = (match_mode == MATCH_UNSPECIFIED);
299                 else
300                         matched = (match_mode == MATCH_VALUE &&
301                                    !strcmp(item->attr_match[i].value, value));
302                 if (!matched)
303                         return 0;
304         }
305
306         return 1;
307 }
308
309 /*
310  * Does 'match' match the given name?
311  * A match is found if
312  *
313  * (1) the 'match' string is leading directory of 'name', or
314  * (2) the 'match' string is a wildcard and matches 'name', or
315  * (3) the 'match' string is exactly the same as 'name'.
316  *
317  * and the return value tells which case it was.
318  *
319  * It returns 0 when there is no match.
320  */
321 static int match_pathspec_item(const struct pathspec_item *item, int prefix,
322                                const char *name, int namelen, unsigned flags)
323 {
324         /* name/namelen has prefix cut off by caller */
325         const char *match = item->match + prefix;
326         int matchlen = item->len - prefix;
327
328         /*
329          * The normal call pattern is:
330          * 1. prefix = common_prefix_len(ps);
331          * 2. prune something, or fill_directory
332          * 3. match_pathspec()
333          *
334          * 'prefix' at #1 may be shorter than the command's prefix and
335          * it's ok for #2 to match extra files. Those extras will be
336          * trimmed at #3.
337          *
338          * Suppose the pathspec is 'foo' and '../bar' running from
339          * subdir 'xyz'. The common prefix at #1 will be empty, thanks
340          * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The
341          * user does not want XYZ/foo, only the "foo" part should be
342          * case-insensitive. We need to filter out XYZ/foo here. In
343          * other words, we do not trust the caller on comparing the
344          * prefix part when :(icase) is involved. We do exact
345          * comparison ourselves.
346          *
347          * Normally the caller (common_prefix_len() in fact) does
348          * _exact_ matching on name[-prefix+1..-1] and we do not need
349          * to check that part. Be defensive and check it anyway, in
350          * case common_prefix_len is changed, or a new caller is
351          * introduced that does not use common_prefix_len.
352          *
353          * If the penalty turns out too high when prefix is really
354          * long, maybe change it to
355          * strncmp(match, name, item->prefix - prefix)
356          */
357         if (item->prefix && (item->magic & PATHSPEC_ICASE) &&
358             strncmp(item->match, name - prefix, item->prefix))
359                 return 0;
360
361         if (item->attr_match_nr && !match_attrs(name, namelen, item))
362                 return 0;
363
364         /* If the match was just the prefix, we matched */
365         if (!*match)
366                 return MATCHED_RECURSIVELY;
367
368         if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) {
369                 if (matchlen == namelen)
370                         return MATCHED_EXACTLY;
371
372                 if (match[matchlen-1] == '/' || name[matchlen] == '/')
373                         return MATCHED_RECURSIVELY;
374         } else if ((flags & DO_MATCH_DIRECTORY) &&
375                    match[matchlen - 1] == '/' &&
376                    namelen == matchlen - 1 &&
377                    !ps_strncmp(item, match, name, namelen))
378                 return MATCHED_EXACTLY;
379
380         if (item->nowildcard_len < item->len &&
381             !git_fnmatch(item, match, name,
382                          item->nowildcard_len - prefix))
383                 return MATCHED_FNMATCH;
384
385         /* Perform checks to see if "name" is a super set of the pathspec */
386         if (flags & DO_MATCH_SUBMODULE) {
387                 /* name is a literal prefix of the pathspec */
388                 if ((namelen < matchlen) &&
389                     (match[namelen] == '/') &&
390                     !ps_strncmp(item, match, name, namelen))
391                         return MATCHED_RECURSIVELY;
392
393                 /* name" doesn't match up to the first wild character */
394                 if (item->nowildcard_len < item->len &&
395                     ps_strncmp(item, match, name,
396                                item->nowildcard_len - prefix))
397                         return 0;
398
399                 /*
400                  * Here is where we would perform a wildmatch to check if
401                  * "name" can be matched as a directory (or a prefix) against
402                  * the pathspec.  Since wildmatch doesn't have this capability
403                  * at the present we have to punt and say that it is a match,
404                  * potentially returning a false positive
405                  * The submodules themselves will be able to perform more
406                  * accurate matching to determine if the pathspec matches.
407                  */
408                 return MATCHED_RECURSIVELY;
409         }
410
411         return 0;
412 }
413
414 /*
415  * Given a name and a list of pathspecs, returns the nature of the
416  * closest (i.e. most specific) match of the name to any of the
417  * pathspecs.
418  *
419  * The caller typically calls this multiple times with the same
420  * pathspec and seen[] array but with different name/namelen
421  * (e.g. entries from the index) and is interested in seeing if and
422  * how each pathspec matches all the names it calls this function
423  * with.  A mark is left in the seen[] array for each pathspec element
424  * indicating the closest type of match that element achieved, so if
425  * seen[n] remains zero after multiple invocations, that means the nth
426  * pathspec did not match any names, which could indicate that the
427  * user mistyped the nth pathspec.
428  */
429 static int do_match_pathspec(const struct pathspec *ps,
430                              const char *name, int namelen,
431                              int prefix, char *seen,
432                              unsigned flags)
433 {
434         int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE;
435
436         GUARD_PATHSPEC(ps,
437                        PATHSPEC_FROMTOP |
438                        PATHSPEC_MAXDEPTH |
439                        PATHSPEC_LITERAL |
440                        PATHSPEC_GLOB |
441                        PATHSPEC_ICASE |
442                        PATHSPEC_EXCLUDE |
443                        PATHSPEC_ATTR);
444
445         if (!ps->nr) {
446                 if (!ps->recursive ||
447                     !(ps->magic & PATHSPEC_MAXDEPTH) ||
448                     ps->max_depth == -1)
449                         return MATCHED_RECURSIVELY;
450
451                 if (within_depth(name, namelen, 0, ps->max_depth))
452                         return MATCHED_EXACTLY;
453                 else
454                         return 0;
455         }
456
457         name += prefix;
458         namelen -= prefix;
459
460         for (i = ps->nr - 1; i >= 0; i--) {
461                 int how;
462
463                 if ((!exclude &&   ps->items[i].magic & PATHSPEC_EXCLUDE) ||
464                     ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE)))
465                         continue;
466
467                 if (seen && seen[i] == MATCHED_EXACTLY)
468                         continue;
469                 /*
470                  * Make exclude patterns optional and never report
471                  * "pathspec ':(exclude)foo' matches no files"
472                  */
473                 if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE)
474                         seen[i] = MATCHED_FNMATCH;
475                 how = match_pathspec_item(ps->items+i, prefix, name,
476                                           namelen, flags);
477                 if (ps->recursive &&
478                     (ps->magic & PATHSPEC_MAXDEPTH) &&
479                     ps->max_depth != -1 &&
480                     how && how != MATCHED_FNMATCH) {
481                         int len = ps->items[i].len;
482                         if (name[len] == '/')
483                                 len++;
484                         if (within_depth(name+len, namelen-len, 0, ps->max_depth))
485                                 how = MATCHED_EXACTLY;
486                         else
487                                 how = 0;
488                 }
489                 if (how) {
490                         if (retval < how)
491                                 retval = how;
492                         if (seen && seen[i] < how)
493                                 seen[i] = how;
494                 }
495         }
496         return retval;
497 }
498
499 int match_pathspec(const struct pathspec *ps,
500                    const char *name, int namelen,
501                    int prefix, char *seen, int is_dir)
502 {
503         int positive, negative;
504         unsigned flags = is_dir ? DO_MATCH_DIRECTORY : 0;
505         positive = do_match_pathspec(ps, name, namelen,
506                                      prefix, seen, flags);
507         if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive)
508                 return positive;
509         negative = do_match_pathspec(ps, name, namelen,
510                                      prefix, seen,
511                                      flags | DO_MATCH_EXCLUDE);
512         return negative ? 0 : positive;
513 }
514
515 /**
516  * Check if a submodule is a superset of the pathspec
517  */
518 int submodule_path_match(const struct pathspec *ps,
519                          const char *submodule_name,
520                          char *seen)
521 {
522         int matched = do_match_pathspec(ps, submodule_name,
523                                         strlen(submodule_name),
524                                         0, seen,
525                                         DO_MATCH_DIRECTORY |
526                                         DO_MATCH_SUBMODULE);
527         return matched;
528 }
529
530 int report_path_error(const char *ps_matched,
531                       const struct pathspec *pathspec,
532                       const char *prefix)
533 {
534         /*
535          * Make sure all pathspec matched; otherwise it is an error.
536          */
537         int num, errors = 0;
538         for (num = 0; num < pathspec->nr; num++) {
539                 int other, found_dup;
540
541                 if (ps_matched[num])
542                         continue;
543                 /*
544                  * The caller might have fed identical pathspec
545                  * twice.  Do not barf on such a mistake.
546                  * FIXME: parse_pathspec should have eliminated
547                  * duplicate pathspec.
548                  */
549                 for (found_dup = other = 0;
550                      !found_dup && other < pathspec->nr;
551                      other++) {
552                         if (other == num || !ps_matched[other])
553                                 continue;
554                         if (!strcmp(pathspec->items[other].original,
555                                     pathspec->items[num].original))
556                                 /*
557                                  * Ok, we have a match already.
558                                  */
559                                 found_dup = 1;
560                 }
561                 if (found_dup)
562                         continue;
563
564                 error("pathspec '%s' did not match any file(s) known to git.",
565                       pathspec->items[num].original);
566                 errors++;
567         }
568         return errors;
569 }
570
571 /*
572  * Return the length of the "simple" part of a path match limiter.
573  */
574 int simple_length(const char *match)
575 {
576         int len = -1;
577
578         for (;;) {
579                 unsigned char c = *match++;
580                 len++;
581                 if (c == '\0' || is_glob_special(c))
582                         return len;
583         }
584 }
585
586 int no_wildcard(const char *string)
587 {
588         return string[simple_length(string)] == '\0';
589 }
590
591 void parse_exclude_pattern(const char **pattern,
592                            int *patternlen,
593                            unsigned *flags,
594                            int *nowildcardlen)
595 {
596         const char *p = *pattern;
597         size_t i, len;
598
599         *flags = 0;
600         if (*p == '!') {
601                 *flags |= EXC_FLAG_NEGATIVE;
602                 p++;
603         }
604         len = strlen(p);
605         if (len && p[len - 1] == '/') {
606                 len--;
607                 *flags |= EXC_FLAG_MUSTBEDIR;
608         }
609         for (i = 0; i < len; i++) {
610                 if (p[i] == '/')
611                         break;
612         }
613         if (i == len)
614                 *flags |= EXC_FLAG_NODIR;
615         *nowildcardlen = simple_length(p);
616         /*
617          * we should have excluded the trailing slash from 'p' too,
618          * but that's one more allocation. Instead just make sure
619          * nowildcardlen does not exceed real patternlen
620          */
621         if (*nowildcardlen > len)
622                 *nowildcardlen = len;
623         if (*p == '*' && no_wildcard(p + 1))
624                 *flags |= EXC_FLAG_ENDSWITH;
625         *pattern = p;
626         *patternlen = len;
627 }
628
629 void add_exclude(const char *string, const char *base,
630                  int baselen, struct exclude_list *el, int srcpos)
631 {
632         struct exclude *x;
633         int patternlen;
634         unsigned flags;
635         int nowildcardlen;
636
637         parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);
638         if (flags & EXC_FLAG_MUSTBEDIR) {
639                 FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen);
640         } else {
641                 x = xmalloc(sizeof(*x));
642                 x->pattern = string;
643         }
644         x->patternlen = patternlen;
645         x->nowildcardlen = nowildcardlen;
646         x->base = base;
647         x->baselen = baselen;
648         x->flags = flags;
649         x->srcpos = srcpos;
650         ALLOC_GROW(el->excludes, el->nr + 1, el->alloc);
651         el->excludes[el->nr++] = x;
652         x->el = el;
653 }
654
655 static int read_skip_worktree_file_from_index(const struct index_state *istate,
656                                               const char *path,
657                                               size_t *size_out, char **data_out,
658                                               struct oid_stat *oid_stat)
659 {
660         int pos, len;
661
662         len = strlen(path);
663         pos = index_name_pos(istate, path, len);
664         if (pos < 0)
665                 return -1;
666         if (!ce_skip_worktree(istate->cache[pos]))
667                 return -1;
668
669         return do_read_blob(&istate->cache[pos]->oid, oid_stat, size_out, data_out);
670 }
671
672 /*
673  * Frees memory within el which was allocated for exclude patterns and
674  * the file buffer.  Does not free el itself.
675  */
676 void clear_exclude_list(struct exclude_list *el)
677 {
678         int i;
679
680         for (i = 0; i < el->nr; i++)
681                 free(el->excludes[i]);
682         free(el->excludes);
683         free(el->filebuf);
684
685         memset(el, 0, sizeof(*el));
686 }
687
688 static void trim_trailing_spaces(char *buf)
689 {
690         char *p, *last_space = NULL;
691
692         for (p = buf; *p; p++)
693                 switch (*p) {
694                 case ' ':
695                         if (!last_space)
696                                 last_space = p;
697                         break;
698                 case '\\':
699                         p++;
700                         if (!*p)
701                                 return;
702                         /* fallthrough */
703                 default:
704                         last_space = NULL;
705                 }
706
707         if (last_space)
708                 *last_space = '\0';
709 }
710
711 /*
712  * Given a subdirectory name and "dir" of the current directory,
713  * search the subdir in "dir" and return it, or create a new one if it
714  * does not exist in "dir".
715  *
716  * If "name" has the trailing slash, it'll be excluded in the search.
717  */
718 static struct untracked_cache_dir *lookup_untracked(struct untracked_cache *uc,
719                                                     struct untracked_cache_dir *dir,
720                                                     const char *name, int len)
721 {
722         int first, last;
723         struct untracked_cache_dir *d;
724         if (!dir)
725                 return NULL;
726         if (len && name[len - 1] == '/')
727                 len--;
728         first = 0;
729         last = dir->dirs_nr;
730         while (last > first) {
731                 int cmp, next = (last + first) >> 1;
732                 d = dir->dirs[next];
733                 cmp = strncmp(name, d->name, len);
734                 if (!cmp && strlen(d->name) > len)
735                         cmp = -1;
736                 if (!cmp)
737                         return d;
738                 if (cmp < 0) {
739                         last = next;
740                         continue;
741                 }
742                 first = next+1;
743         }
744
745         uc->dir_created++;
746         FLEX_ALLOC_MEM(d, name, name, len);
747
748         ALLOC_GROW(dir->dirs, dir->dirs_nr + 1, dir->dirs_alloc);
749         MOVE_ARRAY(dir->dirs + first + 1, dir->dirs + first,
750                    dir->dirs_nr - first);
751         dir->dirs_nr++;
752         dir->dirs[first] = d;
753         return d;
754 }
755
756 static void do_invalidate_gitignore(struct untracked_cache_dir *dir)
757 {
758         int i;
759         dir->valid = 0;
760         dir->untracked_nr = 0;
761         for (i = 0; i < dir->dirs_nr; i++)
762                 do_invalidate_gitignore(dir->dirs[i]);
763 }
764
765 static void invalidate_gitignore(struct untracked_cache *uc,
766                                  struct untracked_cache_dir *dir)
767 {
768         uc->gitignore_invalidated++;
769         do_invalidate_gitignore(dir);
770 }
771
772 static void invalidate_directory(struct untracked_cache *uc,
773                                  struct untracked_cache_dir *dir)
774 {
775         int i;
776
777         /*
778          * Invalidation increment here is just roughly correct. If
779          * untracked_nr or any of dirs[].recurse is non-zero, we
780          * should increment dir_invalidated too. But that's more
781          * expensive to do.
782          */
783         if (dir->valid)
784                 uc->dir_invalidated++;
785
786         dir->valid = 0;
787         dir->untracked_nr = 0;
788         for (i = 0; i < dir->dirs_nr; i++)
789                 dir->dirs[i]->recurse = 0;
790 }
791
792 static int add_excludes_from_buffer(char *buf, size_t size,
793                                     const char *base, int baselen,
794                                     struct exclude_list *el);
795
796 /*
797  * Given a file with name "fname", read it (either from disk, or from
798  * an index if 'istate' is non-null), parse it and store the
799  * exclude rules in "el".
800  *
801  * If "ss" is not NULL, compute SHA-1 of the exclude file and fill
802  * stat data from disk (only valid if add_excludes returns zero). If
803  * ss_valid is non-zero, "ss" must contain good value as input.
804  */
805 static int add_excludes(const char *fname, const char *base, int baselen,
806                         struct exclude_list *el, struct index_state *istate,
807                         struct oid_stat *oid_stat)
808 {
809         struct stat st;
810         int r;
811         int fd;
812         size_t size = 0;
813         char *buf;
814
815         fd = open(fname, O_RDONLY);
816         if (fd < 0 || fstat(fd, &st) < 0) {
817                 if (fd < 0)
818                         warn_on_fopen_errors(fname);
819                 else
820                         close(fd);
821                 if (!istate)
822                         return -1;
823                 r = read_skip_worktree_file_from_index(istate, fname,
824                                                        &size, &buf,
825                                                        oid_stat);
826                 if (r != 1)
827                         return r;
828         } else {
829                 size = xsize_t(st.st_size);
830                 if (size == 0) {
831                         if (oid_stat) {
832                                 fill_stat_data(&oid_stat->stat, &st);
833                                 oidcpy(&oid_stat->oid, the_hash_algo->empty_blob);
834                                 oid_stat->valid = 1;
835                         }
836                         close(fd);
837                         return 0;
838                 }
839                 buf = xmallocz(size);
840                 if (read_in_full(fd, buf, size) != size) {
841                         free(buf);
842                         close(fd);
843                         return -1;
844                 }
845                 buf[size++] = '\n';
846                 close(fd);
847                 if (oid_stat) {
848                         int pos;
849                         if (oid_stat->valid &&
850                             !match_stat_data_racy(istate, &oid_stat->stat, &st))
851                                 ; /* no content change, ss->sha1 still good */
852                         else if (istate &&
853                                  (pos = index_name_pos(istate, fname, strlen(fname))) >= 0 &&
854                                  !ce_stage(istate->cache[pos]) &&
855                                  ce_uptodate(istate->cache[pos]) &&
856                                  !would_convert_to_git(istate, fname))
857                                 oidcpy(&oid_stat->oid,
858                                        &istate->cache[pos]->oid);
859                         else
860                                 hash_object_file(buf, size, "blob",
861                                                  &oid_stat->oid);
862                         fill_stat_data(&oid_stat->stat, &st);
863                         oid_stat->valid = 1;
864                 }
865         }
866
867         add_excludes_from_buffer(buf, size, base, baselen, el);
868         return 0;
869 }
870
871 static int add_excludes_from_buffer(char *buf, size_t size,
872                                     const char *base, int baselen,
873                                     struct exclude_list *el)
874 {
875         int i, lineno = 1;
876         char *entry;
877
878         el->filebuf = buf;
879
880         if (skip_utf8_bom(&buf, size))
881                 size -= buf - el->filebuf;
882
883         entry = buf;
884
885         for (i = 0; i < size; i++) {
886                 if (buf[i] == '\n') {
887                         if (entry != buf + i && entry[0] != '#') {
888                                 buf[i - (i && buf[i-1] == '\r')] = 0;
889                                 trim_trailing_spaces(entry);
890                                 add_exclude(entry, base, baselen, el, lineno);
891                         }
892                         lineno++;
893                         entry = buf + i + 1;
894                 }
895         }
896         return 0;
897 }
898
899 int add_excludes_from_file_to_list(const char *fname, const char *base,
900                                    int baselen, struct exclude_list *el,
901                                    struct index_state *istate)
902 {
903         return add_excludes(fname, base, baselen, el, istate, NULL);
904 }
905
906 int add_excludes_from_blob_to_list(
907         struct object_id *oid,
908         const char *base, int baselen,
909         struct exclude_list *el)
910 {
911         char *buf;
912         size_t size;
913         int r;
914
915         r = do_read_blob(oid, NULL, &size, &buf);
916         if (r != 1)
917                 return r;
918
919         add_excludes_from_buffer(buf, size, base, baselen, el);
920         return 0;
921 }
922
923 struct exclude_list *add_exclude_list(struct dir_struct *dir,
924                                       int group_type, const char *src)
925 {
926         struct exclude_list *el;
927         struct exclude_list_group *group;
928
929         group = &dir->exclude_list_group[group_type];
930         ALLOC_GROW(group->el, group->nr + 1, group->alloc);
931         el = &group->el[group->nr++];
932         memset(el, 0, sizeof(*el));
933         el->src = src;
934         return el;
935 }
936
937 /*
938  * Used to set up core.excludesfile and .git/info/exclude lists.
939  */
940 static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname,
941                                      struct oid_stat *oid_stat)
942 {
943         struct exclude_list *el;
944         /*
945          * catch setup_standard_excludes() that's called before
946          * dir->untracked is assigned. That function behaves
947          * differently when dir->untracked is non-NULL.
948          */
949         if (!dir->untracked)
950                 dir->unmanaged_exclude_files++;
951         el = add_exclude_list(dir, EXC_FILE, fname);
952         if (add_excludes(fname, "", 0, el, NULL, oid_stat) < 0)
953                 die("cannot use %s as an exclude file", fname);
954 }
955
956 void add_excludes_from_file(struct dir_struct *dir, const char *fname)
957 {
958         dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */
959         add_excludes_from_file_1(dir, fname, NULL);
960 }
961
962 int match_basename(const char *basename, int basenamelen,
963                    const char *pattern, int prefix, int patternlen,
964                    unsigned flags)
965 {
966         if (prefix == patternlen) {
967                 if (patternlen == basenamelen &&
968                     !fspathncmp(pattern, basename, basenamelen))
969                         return 1;
970         } else if (flags & EXC_FLAG_ENDSWITH) {
971                 /* "*literal" matching against "fooliteral" */
972                 if (patternlen - 1 <= basenamelen &&
973                     !fspathncmp(pattern + 1,
974                                    basename + basenamelen - (patternlen - 1),
975                                    patternlen - 1))
976                         return 1;
977         } else {
978                 if (fnmatch_icase_mem(pattern, patternlen,
979                                       basename, basenamelen,
980                                       0) == 0)
981                         return 1;
982         }
983         return 0;
984 }
985
986 int match_pathname(const char *pathname, int pathlen,
987                    const char *base, int baselen,
988                    const char *pattern, int prefix, int patternlen,
989                    unsigned flags)
990 {
991         const char *name;
992         int namelen;
993
994         /*
995          * match with FNM_PATHNAME; the pattern has base implicitly
996          * in front of it.
997          */
998         if (*pattern == '/') {
999                 pattern++;
1000                 patternlen--;
1001                 prefix--;
1002         }
1003
1004         /*
1005          * baselen does not count the trailing slash. base[] may or
1006          * may not end with a trailing slash though.
1007          */
1008         if (pathlen < baselen + 1 ||
1009             (baselen && pathname[baselen] != '/') ||
1010             fspathncmp(pathname, base, baselen))
1011                 return 0;
1012
1013         namelen = baselen ? pathlen - baselen - 1 : pathlen;
1014         name = pathname + pathlen - namelen;
1015
1016         if (prefix) {
1017                 /*
1018                  * if the non-wildcard part is longer than the
1019                  * remaining pathname, surely it cannot match.
1020                  */
1021                 if (prefix > namelen)
1022                         return 0;
1023
1024                 if (fspathncmp(pattern, name, prefix))
1025                         return 0;
1026                 pattern += prefix;
1027                 patternlen -= prefix;
1028                 name    += prefix;
1029                 namelen -= prefix;
1030
1031                 /*
1032                  * If the whole pattern did not have a wildcard,
1033                  * then our prefix match is all we need; we
1034                  * do not need to call fnmatch at all.
1035                  */
1036                 if (!patternlen && !namelen)
1037                         return 1;
1038         }
1039
1040         return fnmatch_icase_mem(pattern, patternlen,
1041                                  name, namelen,
1042                                  WM_PATHNAME) == 0;
1043 }
1044
1045 /*
1046  * Scan the given exclude list in reverse to see whether pathname
1047  * should be ignored.  The first match (i.e. the last on the list), if
1048  * any, determines the fate.  Returns the exclude_list element which
1049  * matched, or NULL for undecided.
1050  */
1051 static struct exclude *last_exclude_matching_from_list(const char *pathname,
1052                                                        int pathlen,
1053                                                        const char *basename,
1054                                                        int *dtype,
1055                                                        struct exclude_list *el,
1056                                                        struct index_state *istate)
1057 {
1058         struct exclude *exc = NULL; /* undecided */
1059         int i;
1060
1061         if (!el->nr)
1062                 return NULL;    /* undefined */
1063
1064         for (i = el->nr - 1; 0 <= i; i--) {
1065                 struct exclude *x = el->excludes[i];
1066                 const char *exclude = x->pattern;
1067                 int prefix = x->nowildcardlen;
1068
1069                 if (x->flags & EXC_FLAG_MUSTBEDIR) {
1070                         if (*dtype == DT_UNKNOWN)
1071                                 *dtype = get_dtype(NULL, istate, pathname, pathlen);
1072                         if (*dtype != DT_DIR)
1073                                 continue;
1074                 }
1075
1076                 if (x->flags & EXC_FLAG_NODIR) {
1077                         if (match_basename(basename,
1078                                            pathlen - (basename - pathname),
1079                                            exclude, prefix, x->patternlen,
1080                                            x->flags)) {
1081                                 exc = x;
1082                                 break;
1083                         }
1084                         continue;
1085                 }
1086
1087                 assert(x->baselen == 0 || x->base[x->baselen - 1] == '/');
1088                 if (match_pathname(pathname, pathlen,
1089                                    x->base, x->baselen ? x->baselen - 1 : 0,
1090                                    exclude, prefix, x->patternlen, x->flags)) {
1091                         exc = x;
1092                         break;
1093                 }
1094         }
1095         return exc;
1096 }
1097
1098 /*
1099  * Scan the list and let the last match determine the fate.
1100  * Return 1 for exclude, 0 for include and -1 for undecided.
1101  */
1102 int is_excluded_from_list(const char *pathname,
1103                           int pathlen, const char *basename, int *dtype,
1104                           struct exclude_list *el, struct index_state *istate)
1105 {
1106         struct exclude *exclude;
1107         exclude = last_exclude_matching_from_list(pathname, pathlen, basename,
1108                                                   dtype, el, istate);
1109         if (exclude)
1110                 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
1111         return -1; /* undecided */
1112 }
1113
1114 static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,
1115                                                         struct index_state *istate,
1116                 const char *pathname, int pathlen, const char *basename,
1117                 int *dtype_p)
1118 {
1119         int i, j;
1120         struct exclude_list_group *group;
1121         struct exclude *exclude;
1122         for (i = EXC_CMDL; i <= EXC_FILE; i++) {
1123                 group = &dir->exclude_list_group[i];
1124                 for (j = group->nr - 1; j >= 0; j--) {
1125                         exclude = last_exclude_matching_from_list(
1126                                 pathname, pathlen, basename, dtype_p,
1127                                 &group->el[j], istate);
1128                         if (exclude)
1129                                 return exclude;
1130                 }
1131         }
1132         return NULL;
1133 }
1134
1135 /*
1136  * Loads the per-directory exclude list for the substring of base
1137  * which has a char length of baselen.
1138  */
1139 static void prep_exclude(struct dir_struct *dir,
1140                          struct index_state *istate,
1141                          const char *base, int baselen)
1142 {
1143         struct exclude_list_group *group;
1144         struct exclude_list *el;
1145         struct exclude_stack *stk = NULL;
1146         struct untracked_cache_dir *untracked;
1147         int current;
1148
1149         group = &dir->exclude_list_group[EXC_DIRS];
1150
1151         /*
1152          * Pop the exclude lists from the EXCL_DIRS exclude_list_group
1153          * which originate from directories not in the prefix of the
1154          * path being checked.
1155          */
1156         while ((stk = dir->exclude_stack) != NULL) {
1157                 if (stk->baselen <= baselen &&
1158                     !strncmp(dir->basebuf.buf, base, stk->baselen))
1159                         break;
1160                 el = &group->el[dir->exclude_stack->exclude_ix];
1161                 dir->exclude_stack = stk->prev;
1162                 dir->exclude = NULL;
1163                 free((char *)el->src); /* see strbuf_detach() below */
1164                 clear_exclude_list(el);
1165                 free(stk);
1166                 group->nr--;
1167         }
1168
1169         /* Skip traversing into sub directories if the parent is excluded */
1170         if (dir->exclude)
1171                 return;
1172
1173         /*
1174          * Lazy initialization. All call sites currently just
1175          * memset(dir, 0, sizeof(*dir)) before use. Changing all of
1176          * them seems lots of work for little benefit.
1177          */
1178         if (!dir->basebuf.buf)
1179                 strbuf_init(&dir->basebuf, PATH_MAX);
1180
1181         /* Read from the parent directories and push them down. */
1182         current = stk ? stk->baselen : -1;
1183         strbuf_setlen(&dir->basebuf, current < 0 ? 0 : current);
1184         if (dir->untracked)
1185                 untracked = stk ? stk->ucd : dir->untracked->root;
1186         else
1187                 untracked = NULL;
1188
1189         while (current < baselen) {
1190                 const char *cp;
1191                 struct oid_stat oid_stat;
1192
1193                 stk = xcalloc(1, sizeof(*stk));
1194                 if (current < 0) {
1195                         cp = base;
1196                         current = 0;
1197                 } else {
1198                         cp = strchr(base + current + 1, '/');
1199                         if (!cp)
1200                                 die("oops in prep_exclude");
1201                         cp++;
1202                         untracked =
1203                                 lookup_untracked(dir->untracked, untracked,
1204                                                  base + current,
1205                                                  cp - base - current);
1206                 }
1207                 stk->prev = dir->exclude_stack;
1208                 stk->baselen = cp - base;
1209                 stk->exclude_ix = group->nr;
1210                 stk->ucd = untracked;
1211                 el = add_exclude_list(dir, EXC_DIRS, NULL);
1212                 strbuf_add(&dir->basebuf, base + current, stk->baselen - current);
1213                 assert(stk->baselen == dir->basebuf.len);
1214
1215                 /* Abort if the directory is excluded */
1216                 if (stk->baselen) {
1217                         int dt = DT_DIR;
1218                         dir->basebuf.buf[stk->baselen - 1] = 0;
1219                         dir->exclude = last_exclude_matching_from_lists(dir,
1220                                                                         istate,
1221                                 dir->basebuf.buf, stk->baselen - 1,
1222                                 dir->basebuf.buf + current, &dt);
1223                         dir->basebuf.buf[stk->baselen - 1] = '/';
1224                         if (dir->exclude &&
1225                             dir->exclude->flags & EXC_FLAG_NEGATIVE)
1226                                 dir->exclude = NULL;
1227                         if (dir->exclude) {
1228                                 dir->exclude_stack = stk;
1229                                 return;
1230                         }
1231                 }
1232
1233                 /* Try to read per-directory file */
1234                 oidclr(&oid_stat.oid);
1235                 oid_stat.valid = 0;
1236                 if (dir->exclude_per_dir &&
1237                     /*
1238                      * If we know that no files have been added in
1239                      * this directory (i.e. valid_cached_dir() has
1240                      * been executed and set untracked->valid) ..
1241                      */
1242                     (!untracked || !untracked->valid ||
1243                      /*
1244                       * .. and .gitignore does not exist before
1245                       * (i.e. null exclude_oid). Then we can skip
1246                       * loading .gitignore, which would result in
1247                       * ENOENT anyway.
1248                       */
1249                      !is_null_oid(&untracked->exclude_oid))) {
1250                         /*
1251                          * dir->basebuf gets reused by the traversal, but we
1252                          * need fname to remain unchanged to ensure the src
1253                          * member of each struct exclude correctly
1254                          * back-references its source file.  Other invocations
1255                          * of add_exclude_list provide stable strings, so we
1256                          * strbuf_detach() and free() here in the caller.
1257                          */
1258                         struct strbuf sb = STRBUF_INIT;
1259                         strbuf_addbuf(&sb, &dir->basebuf);
1260                         strbuf_addstr(&sb, dir->exclude_per_dir);
1261                         el->src = strbuf_detach(&sb, NULL);
1262                         add_excludes(el->src, el->src, stk->baselen, el, istate,
1263                                      untracked ? &oid_stat : NULL);
1264                 }
1265                 /*
1266                  * NEEDSWORK: when untracked cache is enabled, prep_exclude()
1267                  * will first be called in valid_cached_dir() then maybe many
1268                  * times more in last_exclude_matching(). When the cache is
1269                  * used, last_exclude_matching() will not be called and
1270                  * reading .gitignore content will be a waste.
1271                  *
1272                  * So when it's called by valid_cached_dir() and we can get
1273                  * .gitignore SHA-1 from the index (i.e. .gitignore is not
1274                  * modified on work tree), we could delay reading the
1275                  * .gitignore content until we absolutely need it in
1276                  * last_exclude_matching(). Be careful about ignore rule
1277                  * order, though, if you do that.
1278                  */
1279                 if (untracked &&
1280                     oidcmp(&oid_stat.oid, &untracked->exclude_oid)) {
1281                         invalidate_gitignore(dir->untracked, untracked);
1282                         oidcpy(&untracked->exclude_oid, &oid_stat.oid);
1283                 }
1284                 dir->exclude_stack = stk;
1285                 current = stk->baselen;
1286         }
1287         strbuf_setlen(&dir->basebuf, baselen);
1288 }
1289
1290 /*
1291  * Loads the exclude lists for the directory containing pathname, then
1292  * scans all exclude lists to determine whether pathname is excluded.
1293  * Returns the exclude_list element which matched, or NULL for
1294  * undecided.
1295  */
1296 struct exclude *last_exclude_matching(struct dir_struct *dir,
1297                                       struct index_state *istate,
1298                                       const char *pathname,
1299                                       int *dtype_p)
1300 {
1301         int pathlen = strlen(pathname);
1302         const char *basename = strrchr(pathname, '/');
1303         basename = (basename) ? basename+1 : pathname;
1304
1305         prep_exclude(dir, istate, pathname, basename-pathname);
1306
1307         if (dir->exclude)
1308                 return dir->exclude;
1309
1310         return last_exclude_matching_from_lists(dir, istate, pathname, pathlen,
1311                         basename, dtype_p);
1312 }
1313
1314 /*
1315  * Loads the exclude lists for the directory containing pathname, then
1316  * scans all exclude lists to determine whether pathname is excluded.
1317  * Returns 1 if true, otherwise 0.
1318  */
1319 int is_excluded(struct dir_struct *dir, struct index_state *istate,
1320                 const char *pathname, int *dtype_p)
1321 {
1322         struct exclude *exclude =
1323                 last_exclude_matching(dir, istate, pathname, dtype_p);
1324         if (exclude)
1325                 return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
1326         return 0;
1327 }
1328
1329 static struct dir_entry *dir_entry_new(const char *pathname, int len)
1330 {
1331         struct dir_entry *ent;
1332
1333         FLEX_ALLOC_MEM(ent, name, pathname, len);
1334         ent->len = len;
1335         return ent;
1336 }
1337
1338 static struct dir_entry *dir_add_name(struct dir_struct *dir,
1339                                       struct index_state *istate,
1340                                       const char *pathname, int len)
1341 {
1342         if (index_file_exists(istate, pathname, len, ignore_case))
1343                 return NULL;
1344
1345         ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);
1346         return dir->entries[dir->nr++] = dir_entry_new(pathname, len);
1347 }
1348
1349 struct dir_entry *dir_add_ignored(struct dir_struct *dir,
1350                                   struct index_state *istate,
1351                                   const char *pathname, int len)
1352 {
1353         if (!index_name_is_other(istate, pathname, len))
1354                 return NULL;
1355
1356         ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);
1357         return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);
1358 }
1359
1360 enum exist_status {
1361         index_nonexistent = 0,
1362         index_directory,
1363         index_gitdir
1364 };
1365
1366 /*
1367  * Do not use the alphabetically sorted index to look up
1368  * the directory name; instead, use the case insensitive
1369  * directory hash.
1370  */
1371 static enum exist_status directory_exists_in_index_icase(struct index_state *istate,
1372                                                          const char *dirname, int len)
1373 {
1374         struct cache_entry *ce;
1375
1376         if (index_dir_exists(istate, dirname, len))
1377                 return index_directory;
1378
1379         ce = index_file_exists(istate, dirname, len, ignore_case);
1380         if (ce && S_ISGITLINK(ce->ce_mode))
1381                 return index_gitdir;
1382
1383         return index_nonexistent;
1384 }
1385
1386 /*
1387  * The index sorts alphabetically by entry name, which
1388  * means that a gitlink sorts as '\0' at the end, while
1389  * a directory (which is defined not as an entry, but as
1390  * the files it contains) will sort with the '/' at the
1391  * end.
1392  */
1393 static enum exist_status directory_exists_in_index(struct index_state *istate,
1394                                                    const char *dirname, int len)
1395 {
1396         int pos;
1397
1398         if (ignore_case)
1399                 return directory_exists_in_index_icase(istate, dirname, len);
1400
1401         pos = index_name_pos(istate, dirname, len);
1402         if (pos < 0)
1403                 pos = -pos-1;
1404         while (pos < istate->cache_nr) {
1405                 const struct cache_entry *ce = istate->cache[pos++];
1406                 unsigned char endchar;
1407
1408                 if (strncmp(ce->name, dirname, len))
1409                         break;
1410                 endchar = ce->name[len];
1411                 if (endchar > '/')
1412                         break;
1413                 if (endchar == '/')
1414                         return index_directory;
1415                 if (!endchar && S_ISGITLINK(ce->ce_mode))
1416                         return index_gitdir;
1417         }
1418         return index_nonexistent;
1419 }
1420
1421 /*
1422  * When we find a directory when traversing the filesystem, we
1423  * have three distinct cases:
1424  *
1425  *  - ignore it
1426  *  - see it as a directory
1427  *  - recurse into it
1428  *
1429  * and which one we choose depends on a combination of existing
1430  * git index contents and the flags passed into the directory
1431  * traversal routine.
1432  *
1433  * Case 1: If we *already* have entries in the index under that
1434  * directory name, we always recurse into the directory to see
1435  * all the files.
1436  *
1437  * Case 2: If we *already* have that directory name as a gitlink,
1438  * we always continue to see it as a gitlink, regardless of whether
1439  * there is an actual git directory there or not (it might not
1440  * be checked out as a subproject!)
1441  *
1442  * Case 3: if we didn't have it in the index previously, we
1443  * have a few sub-cases:
1444  *
1445  *  (a) if "show_other_directories" is true, we show it as
1446  *      just a directory, unless "hide_empty_directories" is
1447  *      also true, in which case we need to check if it contains any
1448  *      untracked and / or ignored files.
1449  *  (b) if it looks like a git directory, and we don't have
1450  *      'no_gitlinks' set we treat it as a gitlink, and show it
1451  *      as a directory.
1452  *  (c) otherwise, we recurse into it.
1453  */
1454 static enum path_treatment treat_directory(struct dir_struct *dir,
1455         struct index_state *istate,
1456         struct untracked_cache_dir *untracked,
1457         const char *dirname, int len, int baselen, int exclude,
1458         const struct pathspec *pathspec)
1459 {
1460         /* The "len-1" is to strip the final '/' */
1461         switch (directory_exists_in_index(istate, dirname, len-1)) {
1462         case index_directory:
1463                 return path_recurse;
1464
1465         case index_gitdir:
1466                 return path_none;
1467
1468         case index_nonexistent:
1469                 if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)
1470                         break;
1471                 if (exclude &&
1472                         (dir->flags & DIR_SHOW_IGNORED_TOO) &&
1473                         (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING)) {
1474
1475                         /*
1476                          * This is an excluded directory and we are
1477                          * showing ignored paths that match an exclude
1478                          * pattern.  (e.g. show directory as ignored
1479                          * only if it matches an exclude pattern).
1480                          * This path will either be 'path_excluded`
1481                          * (if we are showing empty directories or if
1482                          * the directory is not empty), or will be
1483                          * 'path_none' (empty directory, and we are
1484                          * not showing empty directories).
1485                          */
1486                         if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))
1487                                 return path_excluded;
1488
1489                         if (read_directory_recursive(dir, istate, dirname, len,
1490                                                      untracked, 1, 1, pathspec) == path_excluded)
1491                                 return path_excluded;
1492
1493                         return path_none;
1494                 }
1495                 if (!(dir->flags & DIR_NO_GITLINKS)) {
1496                         struct object_id oid;
1497                         if (resolve_gitlink_ref(dirname, "HEAD", &oid) == 0)
1498                                 return exclude ? path_excluded : path_untracked;
1499                 }
1500                 return path_recurse;
1501         }
1502
1503         /* This is the "show_other_directories" case */
1504
1505         if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))
1506                 return exclude ? path_excluded : path_untracked;
1507
1508         untracked = lookup_untracked(dir->untracked, untracked,
1509                                      dirname + baselen, len - baselen);
1510
1511         /*
1512          * If this is an excluded directory, then we only need to check if
1513          * the directory contains any files.
1514          */
1515         return read_directory_recursive(dir, istate, dirname, len,
1516                                         untracked, 1, exclude, pathspec);
1517 }
1518
1519 /*
1520  * This is an inexact early pruning of any recursive directory
1521  * reading - if the path cannot possibly be in the pathspec,
1522  * return true, and we'll skip it early.
1523  */
1524 static int simplify_away(const char *path, int pathlen,
1525                          const struct pathspec *pathspec)
1526 {
1527         int i;
1528
1529         if (!pathspec || !pathspec->nr)
1530                 return 0;
1531
1532         GUARD_PATHSPEC(pathspec,
1533                        PATHSPEC_FROMTOP |
1534                        PATHSPEC_MAXDEPTH |
1535                        PATHSPEC_LITERAL |
1536                        PATHSPEC_GLOB |
1537                        PATHSPEC_ICASE |
1538                        PATHSPEC_EXCLUDE |
1539                        PATHSPEC_ATTR);
1540
1541         for (i = 0; i < pathspec->nr; i++) {
1542                 const struct pathspec_item *item = &pathspec->items[i];
1543                 int len = item->nowildcard_len;
1544
1545                 if (len > pathlen)
1546                         len = pathlen;
1547                 if (!ps_strncmp(item, item->match, path, len))
1548                         return 0;
1549         }
1550
1551         return 1;
1552 }
1553
1554 /*
1555  * This function tells us whether an excluded path matches a
1556  * list of "interesting" pathspecs. That is, whether a path matched
1557  * by any of the pathspecs could possibly be ignored by excluding
1558  * the specified path. This can happen if:
1559  *
1560  *   1. the path is mentioned explicitly in the pathspec
1561  *
1562  *   2. the path is a directory prefix of some element in the
1563  *      pathspec
1564  */
1565 static int exclude_matches_pathspec(const char *path, int pathlen,
1566                                     const struct pathspec *pathspec)
1567 {
1568         int i;
1569
1570         if (!pathspec || !pathspec->nr)
1571                 return 0;
1572
1573         GUARD_PATHSPEC(pathspec,
1574                        PATHSPEC_FROMTOP |
1575                        PATHSPEC_MAXDEPTH |
1576                        PATHSPEC_LITERAL |
1577                        PATHSPEC_GLOB |
1578                        PATHSPEC_ICASE |
1579                        PATHSPEC_EXCLUDE);
1580
1581         for (i = 0; i < pathspec->nr; i++) {
1582                 const struct pathspec_item *item = &pathspec->items[i];
1583                 int len = item->nowildcard_len;
1584
1585                 if (len == pathlen &&
1586                     !ps_strncmp(item, item->match, path, pathlen))
1587                         return 1;
1588                 if (len > pathlen &&
1589                     item->match[pathlen] == '/' &&
1590                     !ps_strncmp(item, item->match, path, pathlen))
1591                         return 1;
1592         }
1593         return 0;
1594 }
1595
1596 static int get_index_dtype(struct index_state *istate,
1597                            const char *path, int len)
1598 {
1599         int pos;
1600         const struct cache_entry *ce;
1601
1602         ce = index_file_exists(istate, path, len, 0);
1603         if (ce) {
1604                 if (!ce_uptodate(ce))
1605                         return DT_UNKNOWN;
1606                 if (S_ISGITLINK(ce->ce_mode))
1607                         return DT_DIR;
1608                 /*
1609                  * Nobody actually cares about the
1610                  * difference between DT_LNK and DT_REG
1611                  */
1612                 return DT_REG;
1613         }
1614
1615         /* Try to look it up as a directory */
1616         pos = index_name_pos(istate, path, len);
1617         if (pos >= 0)
1618                 return DT_UNKNOWN;
1619         pos = -pos-1;
1620         while (pos < istate->cache_nr) {
1621                 ce = istate->cache[pos++];
1622                 if (strncmp(ce->name, path, len))
1623                         break;
1624                 if (ce->name[len] > '/')
1625                         break;
1626                 if (ce->name[len] < '/')
1627                         continue;
1628                 if (!ce_uptodate(ce))
1629                         break;  /* continue? */
1630                 return DT_DIR;
1631         }
1632         return DT_UNKNOWN;
1633 }
1634
1635 static int get_dtype(struct dirent *de, struct index_state *istate,
1636                      const char *path, int len)
1637 {
1638         int dtype = de ? DTYPE(de) : DT_UNKNOWN;
1639         struct stat st;
1640
1641         if (dtype != DT_UNKNOWN)
1642                 return dtype;
1643         dtype = get_index_dtype(istate, path, len);
1644         if (dtype != DT_UNKNOWN)
1645                 return dtype;
1646         if (lstat(path, &st))
1647                 return dtype;
1648         if (S_ISREG(st.st_mode))
1649                 return DT_REG;
1650         if (S_ISDIR(st.st_mode))
1651                 return DT_DIR;
1652         if (S_ISLNK(st.st_mode))
1653                 return DT_LNK;
1654         return dtype;
1655 }
1656
1657 static enum path_treatment treat_one_path(struct dir_struct *dir,
1658                                           struct untracked_cache_dir *untracked,
1659                                           struct index_state *istate,
1660                                           struct strbuf *path,
1661                                           int baselen,
1662                                           const struct pathspec *pathspec,
1663                                           int dtype, struct dirent *de)
1664 {
1665         int exclude;
1666         int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case);
1667         enum path_treatment path_treatment;
1668
1669         if (dtype == DT_UNKNOWN)
1670                 dtype = get_dtype(de, istate, path->buf, path->len);
1671
1672         /* Always exclude indexed files */
1673         if (dtype != DT_DIR && has_path_in_index)
1674                 return path_none;
1675
1676         /*
1677          * When we are looking at a directory P in the working tree,
1678          * there are three cases:
1679          *
1680          * (1) P exists in the index.  Everything inside the directory P in
1681          * the working tree needs to go when P is checked out from the
1682          * index.
1683          *
1684          * (2) P does not exist in the index, but there is P/Q in the index.
1685          * We know P will stay a directory when we check out the contents
1686          * of the index, but we do not know yet if there is a directory
1687          * P/Q in the working tree to be killed, so we need to recurse.
1688          *
1689          * (3) P does not exist in the index, and there is no P/Q in the index
1690          * to require P to be a directory, either.  Only in this case, we
1691          * know that everything inside P will not be killed without
1692          * recursing.
1693          */
1694         if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&
1695             (dtype == DT_DIR) &&
1696             !has_path_in_index &&
1697             (directory_exists_in_index(istate, path->buf, path->len) == index_nonexistent))
1698                 return path_none;
1699
1700         exclude = is_excluded(dir, istate, path->buf, &dtype);
1701
1702         /*
1703          * Excluded? If we don't explicitly want to show
1704          * ignored files, ignore it
1705          */
1706         if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))
1707                 return path_excluded;
1708
1709         switch (dtype) {
1710         default:
1711                 return path_none;
1712         case DT_DIR:
1713                 strbuf_addch(path, '/');
1714                 path_treatment = treat_directory(dir, istate, untracked,
1715                                                  path->buf, path->len,
1716                                                  baselen, exclude, pathspec);
1717                 /*
1718                  * If 1) we only want to return directories that
1719                  * match an exclude pattern and 2) this directory does
1720                  * not match an exclude pattern but all of its
1721                  * contents are excluded, then indicate that we should
1722                  * recurse into this directory (instead of marking the
1723                  * directory itself as an ignored path).
1724                  */
1725                 if (!exclude &&
1726                     path_treatment == path_excluded &&
1727                     (dir->flags & DIR_SHOW_IGNORED_TOO) &&
1728                     (dir->flags & DIR_SHOW_IGNORED_TOO_MODE_MATCHING))
1729                         return path_recurse;
1730                 return path_treatment;
1731         case DT_REG:
1732         case DT_LNK:
1733                 return exclude ? path_excluded : path_untracked;
1734         }
1735 }
1736
1737 static enum path_treatment treat_path_fast(struct dir_struct *dir,
1738                                            struct untracked_cache_dir *untracked,
1739                                            struct cached_dir *cdir,
1740                                            struct index_state *istate,
1741                                            struct strbuf *path,
1742                                            int baselen,
1743                                            const struct pathspec *pathspec)
1744 {
1745         strbuf_setlen(path, baselen);
1746         if (!cdir->ucd) {
1747                 strbuf_addstr(path, cdir->file);
1748                 return path_untracked;
1749         }
1750         strbuf_addstr(path, cdir->ucd->name);
1751         /* treat_one_path() does this before it calls treat_directory() */
1752         strbuf_complete(path, '/');
1753         if (cdir->ucd->check_only)
1754                 /*
1755                  * check_only is set as a result of treat_directory() getting
1756                  * to its bottom. Verify again the same set of directories
1757                  * with check_only set.
1758                  */
1759                 return read_directory_recursive(dir, istate, path->buf, path->len,
1760                                                 cdir->ucd, 1, 0, pathspec);
1761         /*
1762          * We get path_recurse in the first run when
1763          * directory_exists_in_index() returns index_nonexistent. We
1764          * are sure that new changes in the index does not impact the
1765          * outcome. Return now.
1766          */
1767         return path_recurse;
1768 }
1769
1770 static enum path_treatment treat_path(struct dir_struct *dir,
1771                                       struct untracked_cache_dir *untracked,
1772                                       struct cached_dir *cdir,
1773                                       struct index_state *istate,
1774                                       struct strbuf *path,
1775                                       int baselen,
1776                                       const struct pathspec *pathspec)
1777 {
1778         int dtype;
1779         struct dirent *de = cdir->de;
1780
1781         if (!de)
1782                 return treat_path_fast(dir, untracked, cdir, istate, path,
1783                                        baselen, pathspec);
1784         if (is_dot_or_dotdot(de->d_name) || !fspathcmp(de->d_name, ".git"))
1785                 return path_none;
1786         strbuf_setlen(path, baselen);
1787         strbuf_addstr(path, de->d_name);
1788         if (simplify_away(path->buf, path->len, pathspec))
1789                 return path_none;
1790
1791         dtype = DTYPE(de);
1792         return treat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de);
1793 }
1794
1795 static void add_untracked(struct untracked_cache_dir *dir, const char *name)
1796 {
1797         if (!dir)
1798                 return;
1799         ALLOC_GROW(dir->untracked, dir->untracked_nr + 1,
1800                    dir->untracked_alloc);
1801         dir->untracked[dir->untracked_nr++] = xstrdup(name);
1802 }
1803
1804 static int valid_cached_dir(struct dir_struct *dir,
1805                             struct untracked_cache_dir *untracked,
1806                             struct index_state *istate,
1807                             struct strbuf *path,
1808                             int check_only)
1809 {
1810         struct stat st;
1811
1812         if (!untracked)
1813                 return 0;
1814
1815         /*
1816          * With fsmonitor, we can trust the untracked cache's valid field.
1817          */
1818         refresh_fsmonitor(istate);
1819         if (!(dir->untracked->use_fsmonitor && untracked->valid)) {
1820                 if (lstat(path->len ? path->buf : ".", &st)) {
1821                         memset(&untracked->stat_data, 0, sizeof(untracked->stat_data));
1822                         return 0;
1823                 }
1824                 if (!untracked->valid ||
1825                         match_stat_data_racy(istate, &untracked->stat_data, &st)) {
1826                         fill_stat_data(&untracked->stat_data, &st);
1827                         return 0;
1828                 }
1829         }
1830
1831         if (untracked->check_only != !!check_only)
1832                 return 0;
1833
1834         /*
1835          * prep_exclude will be called eventually on this directory,
1836          * but it's called much later in last_exclude_matching(). We
1837          * need it now to determine the validity of the cache for this
1838          * path. The next calls will be nearly no-op, the way
1839          * prep_exclude() is designed.
1840          */
1841         if (path->len && path->buf[path->len - 1] != '/') {
1842                 strbuf_addch(path, '/');
1843                 prep_exclude(dir, istate, path->buf, path->len);
1844                 strbuf_setlen(path, path->len - 1);
1845         } else
1846                 prep_exclude(dir, istate, path->buf, path->len);
1847
1848         /* hopefully prep_exclude() haven't invalidated this entry... */
1849         return untracked->valid;
1850 }
1851
1852 static int open_cached_dir(struct cached_dir *cdir,
1853                            struct dir_struct *dir,
1854                            struct untracked_cache_dir *untracked,
1855                            struct index_state *istate,
1856                            struct strbuf *path,
1857                            int check_only)
1858 {
1859         const char *c_path;
1860
1861         memset(cdir, 0, sizeof(*cdir));
1862         cdir->untracked = untracked;
1863         if (valid_cached_dir(dir, untracked, istate, path, check_only))
1864                 return 0;
1865         c_path = path->len ? path->buf : ".";
1866         cdir->fdir = opendir(c_path);
1867         if (!cdir->fdir)
1868                 warning_errno(_("could not open directory '%s'"), c_path);
1869         if (dir->untracked) {
1870                 invalidate_directory(dir->untracked, untracked);
1871                 dir->untracked->dir_opened++;
1872         }
1873         if (!cdir->fdir)
1874                 return -1;
1875         return 0;
1876 }
1877
1878 static int read_cached_dir(struct cached_dir *cdir)
1879 {
1880         if (cdir->fdir) {
1881                 cdir->de = readdir(cdir->fdir);
1882                 if (!cdir->de)
1883                         return -1;
1884                 return 0;
1885         }
1886         while (cdir->nr_dirs < cdir->untracked->dirs_nr) {
1887                 struct untracked_cache_dir *d = cdir->untracked->dirs[cdir->nr_dirs];
1888                 if (!d->recurse) {
1889                         cdir->nr_dirs++;
1890                         continue;
1891                 }
1892                 cdir->ucd = d;
1893                 cdir->nr_dirs++;
1894                 return 0;
1895         }
1896         cdir->ucd = NULL;
1897         if (cdir->nr_files < cdir->untracked->untracked_nr) {
1898                 struct untracked_cache_dir *d = cdir->untracked;
1899                 cdir->file = d->untracked[cdir->nr_files++];
1900                 return 0;
1901         }
1902         return -1;
1903 }
1904
1905 static void close_cached_dir(struct cached_dir *cdir)
1906 {
1907         if (cdir->fdir)
1908                 closedir(cdir->fdir);
1909         /*
1910          * We have gone through this directory and found no untracked
1911          * entries. Mark it valid.
1912          */
1913         if (cdir->untracked) {
1914                 cdir->untracked->valid = 1;
1915                 cdir->untracked->recurse = 1;
1916         }
1917 }
1918
1919 /*
1920  * Read a directory tree. We currently ignore anything but
1921  * directories, regular files and symlinks. That's because git
1922  * doesn't handle them at all yet. Maybe that will change some
1923  * day.
1924  *
1925  * Also, we ignore the name ".git" (even if it is not a directory).
1926  * That likely will not change.
1927  *
1928  * If 'stop_at_first_file' is specified, 'path_excluded' is returned
1929  * to signal that a file was found. This is the least significant value that
1930  * indicates that a file was encountered that does not depend on the order of
1931  * whether an untracked or exluded path was encountered first.
1932  *
1933  * Returns the most significant path_treatment value encountered in the scan.
1934  * If 'stop_at_first_file' is specified, `path_excluded` is the most
1935  * significant path_treatment value that will be returned.
1936  */
1937
1938 static enum path_treatment read_directory_recursive(struct dir_struct *dir,
1939         struct index_state *istate, const char *base, int baselen,
1940         struct untracked_cache_dir *untracked, int check_only,
1941         int stop_at_first_file, const struct pathspec *pathspec)
1942 {
1943         struct cached_dir cdir;
1944         enum path_treatment state, subdir_state, dir_state = path_none;
1945         struct strbuf path = STRBUF_INIT;
1946
1947         strbuf_add(&path, base, baselen);
1948
1949         if (open_cached_dir(&cdir, dir, untracked, istate, &path, check_only))
1950                 goto out;
1951
1952         if (untracked)
1953                 untracked->check_only = !!check_only;
1954
1955         while (!read_cached_dir(&cdir)) {
1956                 /* check how the file or directory should be treated */
1957                 state = treat_path(dir, untracked, &cdir, istate, &path,
1958                                    baselen, pathspec);
1959
1960                 if (state > dir_state)
1961                         dir_state = state;
1962
1963                 /* recurse into subdir if instructed by treat_path */
1964                 if ((state == path_recurse) ||
1965                         ((state == path_untracked) &&
1966                          (dir->flags & DIR_SHOW_IGNORED_TOO) &&
1967                          (get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) {
1968                         struct untracked_cache_dir *ud;
1969                         ud = lookup_untracked(dir->untracked, untracked,
1970                                               path.buf + baselen,
1971                                               path.len - baselen);
1972                         subdir_state =
1973                                 read_directory_recursive(dir, istate, path.buf,
1974                                                          path.len, ud,
1975                                                          check_only, stop_at_first_file, pathspec);
1976                         if (subdir_state > dir_state)
1977                                 dir_state = subdir_state;
1978                 }
1979
1980                 if (check_only) {
1981                         if (stop_at_first_file) {
1982                                 /*
1983                                  * If stopping at first file, then
1984                                  * signal that a file was found by
1985                                  * returning `path_excluded`. This is
1986                                  * to return a consistent value
1987                                  * regardless of whether an ignored or
1988                                  * excluded file happened to be
1989                                  * encountered 1st.
1990                                  *
1991                                  * In current usage, the
1992                                  * `stop_at_first_file` is passed when
1993                                  * an ancestor directory has matched
1994                                  * an exclude pattern, so any found
1995                                  * files will be excluded.
1996                                  */
1997                                 if (dir_state >= path_excluded) {
1998                                         dir_state = path_excluded;
1999                                         break;
2000                                 }
2001                         }
2002
2003                         /* abort early if maximum state has been reached */
2004                         if (dir_state == path_untracked) {
2005                                 if (cdir.fdir)
2006                                         add_untracked(untracked, path.buf + baselen);
2007                                 break;
2008                         }
2009                         /* skip the dir_add_* part */
2010                         continue;
2011                 }
2012
2013                 /* add the path to the appropriate result list */
2014                 switch (state) {
2015                 case path_excluded:
2016                         if (dir->flags & DIR_SHOW_IGNORED)
2017                                 dir_add_name(dir, istate, path.buf, path.len);
2018                         else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||
2019                                 ((dir->flags & DIR_COLLECT_IGNORED) &&
2020                                 exclude_matches_pathspec(path.buf, path.len,
2021                                                          pathspec)))
2022                                 dir_add_ignored(dir, istate, path.buf, path.len);
2023                         break;
2024
2025                 case path_untracked:
2026                         if (dir->flags & DIR_SHOW_IGNORED)
2027                                 break;
2028                         dir_add_name(dir, istate, path.buf, path.len);
2029                         if (cdir.fdir)
2030                                 add_untracked(untracked, path.buf + baselen);
2031                         break;
2032
2033                 default:
2034                         break;
2035                 }
2036         }
2037         close_cached_dir(&cdir);
2038  out:
2039         strbuf_release(&path);
2040
2041         return dir_state;
2042 }
2043
2044 int cmp_dir_entry(const void *p1, const void *p2)
2045 {
2046         const struct dir_entry *e1 = *(const struct dir_entry **)p1;
2047         const struct dir_entry *e2 = *(const struct dir_entry **)p2;
2048
2049         return name_compare(e1->name, e1->len, e2->name, e2->len);
2050 }
2051
2052 /* check if *out lexically strictly contains *in */
2053 int check_dir_entry_contains(const struct dir_entry *out, const struct dir_entry *in)
2054 {
2055         return (out->len < in->len) &&
2056                 (out->name[out->len - 1] == '/') &&
2057                 !memcmp(out->name, in->name, out->len);
2058 }
2059
2060 static int treat_leading_path(struct dir_struct *dir,
2061                               struct index_state *istate,
2062                               const char *path, int len,
2063                               const struct pathspec *pathspec)
2064 {
2065         struct strbuf sb = STRBUF_INIT;
2066         int baselen, rc = 0;
2067         const char *cp;
2068         int old_flags = dir->flags;
2069
2070         while (len && path[len - 1] == '/')
2071                 len--;
2072         if (!len)
2073                 return 1;
2074         baselen = 0;
2075         dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;
2076         while (1) {
2077                 cp = path + baselen + !!baselen;
2078                 cp = memchr(cp, '/', path + len - cp);
2079                 if (!cp)
2080                         baselen = len;
2081                 else
2082                         baselen = cp - path;
2083                 strbuf_setlen(&sb, 0);
2084                 strbuf_add(&sb, path, baselen);
2085                 if (!is_directory(sb.buf))
2086                         break;
2087                 if (simplify_away(sb.buf, sb.len, pathspec))
2088                         break;
2089                 if (treat_one_path(dir, NULL, istate, &sb, baselen, pathspec,
2090                                    DT_DIR, NULL) == path_none)
2091                         break; /* do not recurse into it */
2092                 if (len <= baselen) {
2093                         rc = 1;
2094                         break; /* finished checking */
2095                 }
2096         }
2097         strbuf_release(&sb);
2098         dir->flags = old_flags;
2099         return rc;
2100 }
2101
2102 static const char *get_ident_string(void)
2103 {
2104         static struct strbuf sb = STRBUF_INIT;
2105         struct utsname uts;
2106
2107         if (sb.len)
2108                 return sb.buf;
2109         if (uname(&uts) < 0)
2110                 die_errno(_("failed to get kernel name and information"));
2111         strbuf_addf(&sb, "Location %s, system %s", get_git_work_tree(),
2112                     uts.sysname);
2113         return sb.buf;
2114 }
2115
2116 static int ident_in_untracked(const struct untracked_cache *uc)
2117 {
2118         /*
2119          * Previous git versions may have saved many NUL separated
2120          * strings in the "ident" field, but it is insane to manage
2121          * many locations, so just take care of the first one.
2122          */
2123
2124         return !strcmp(uc->ident.buf, get_ident_string());
2125 }
2126
2127 static void set_untracked_ident(struct untracked_cache *uc)
2128 {
2129         strbuf_reset(&uc->ident);
2130         strbuf_addstr(&uc->ident, get_ident_string());
2131
2132         /*
2133          * This strbuf used to contain a list of NUL separated
2134          * strings, so save NUL too for backward compatibility.
2135          */
2136         strbuf_addch(&uc->ident, 0);
2137 }
2138
2139 static void new_untracked_cache(struct index_state *istate)
2140 {
2141         struct untracked_cache *uc = xcalloc(1, sizeof(*uc));
2142         strbuf_init(&uc->ident, 100);
2143         uc->exclude_per_dir = ".gitignore";
2144         /* should be the same flags used by git-status */
2145         uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;
2146         set_untracked_ident(uc);
2147         istate->untracked = uc;
2148         istate->cache_changed |= UNTRACKED_CHANGED;
2149 }
2150
2151 void add_untracked_cache(struct index_state *istate)
2152 {
2153         if (!istate->untracked) {
2154                 new_untracked_cache(istate);
2155         } else {
2156                 if (!ident_in_untracked(istate->untracked)) {
2157                         free_untracked_cache(istate->untracked);
2158                         new_untracked_cache(istate);
2159                 }
2160         }
2161 }
2162
2163 void remove_untracked_cache(struct index_state *istate)
2164 {
2165         if (istate->untracked) {
2166                 free_untracked_cache(istate->untracked);
2167                 istate->untracked = NULL;
2168                 istate->cache_changed |= UNTRACKED_CHANGED;
2169         }
2170 }
2171
2172 static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,
2173                                                       int base_len,
2174                                                       const struct pathspec *pathspec)
2175 {
2176         struct untracked_cache_dir *root;
2177         static int untracked_cache_disabled = -1;
2178
2179         if (!dir->untracked)
2180                 return NULL;
2181         if (untracked_cache_disabled < 0)
2182                 untracked_cache_disabled = git_env_bool("GIT_DISABLE_UNTRACKED_CACHE", 0);
2183         if (untracked_cache_disabled)
2184                 return NULL;
2185
2186         /*
2187          * We only support $GIT_DIR/info/exclude and core.excludesfile
2188          * as the global ignore rule files. Any other additions
2189          * (e.g. from command line) invalidate the cache. This
2190          * condition also catches running setup_standard_excludes()
2191          * before setting dir->untracked!
2192          */
2193         if (dir->unmanaged_exclude_files)
2194                 return NULL;
2195
2196         /*
2197          * Optimize for the main use case only: whole-tree git
2198          * status. More work involved in treat_leading_path() if we
2199          * use cache on just a subset of the worktree. pathspec
2200          * support could make the matter even worse.
2201          */
2202         if (base_len || (pathspec && pathspec->nr))
2203                 return NULL;
2204
2205         /* Different set of flags may produce different results */
2206         if (dir->flags != dir->untracked->dir_flags ||
2207             /*
2208              * See treat_directory(), case index_nonexistent. Without
2209              * this flag, we may need to also cache .git file content
2210              * for the resolve_gitlink_ref() call, which we don't.
2211              */
2212             !(dir->flags & DIR_SHOW_OTHER_DIRECTORIES) ||
2213             /* We don't support collecting ignore files */
2214             (dir->flags & (DIR_SHOW_IGNORED | DIR_SHOW_IGNORED_TOO |
2215                            DIR_COLLECT_IGNORED)))
2216                 return NULL;
2217
2218         /*
2219          * If we use .gitignore in the cache and now you change it to
2220          * .gitexclude, everything will go wrong.
2221          */
2222         if (dir->exclude_per_dir != dir->untracked->exclude_per_dir &&
2223             strcmp(dir->exclude_per_dir, dir->untracked->exclude_per_dir))
2224                 return NULL;
2225
2226         /*
2227          * EXC_CMDL is not considered in the cache. If people set it,
2228          * skip the cache.
2229          */
2230         if (dir->exclude_list_group[EXC_CMDL].nr)
2231                 return NULL;
2232
2233         if (!ident_in_untracked(dir->untracked)) {
2234                 warning(_("Untracked cache is disabled on this system or location."));
2235                 return NULL;
2236         }
2237
2238         if (!dir->untracked->root) {
2239                 const int len = sizeof(*dir->untracked->root);
2240                 dir->untracked->root = xmalloc(len);
2241                 memset(dir->untracked->root, 0, len);
2242         }
2243
2244         /* Validate $GIT_DIR/info/exclude and core.excludesfile */
2245         root = dir->untracked->root;
2246         if (oidcmp(&dir->ss_info_exclude.oid,
2247                    &dir->untracked->ss_info_exclude.oid)) {
2248                 invalidate_gitignore(dir->untracked, root);
2249                 dir->untracked->ss_info_exclude = dir->ss_info_exclude;
2250         }
2251         if (oidcmp(&dir->ss_excludes_file.oid,
2252                    &dir->untracked->ss_excludes_file.oid)) {
2253                 invalidate_gitignore(dir->untracked, root);
2254                 dir->untracked->ss_excludes_file = dir->ss_excludes_file;
2255         }
2256
2257         /* Make sure this directory is not dropped out at saving phase */
2258         root->recurse = 1;
2259         return root;
2260 }
2261
2262 int read_directory(struct dir_struct *dir, struct index_state *istate,
2263                    const char *path, int len, const struct pathspec *pathspec)
2264 {
2265         struct untracked_cache_dir *untracked;
2266         uint64_t start = getnanotime();
2267
2268         if (has_symlink_leading_path(path, len))
2269                 return dir->nr;
2270
2271         untracked = validate_untracked_cache(dir, len, pathspec);
2272         if (!untracked)
2273                 /*
2274                  * make sure untracked cache code path is disabled,
2275                  * e.g. prep_exclude()
2276                  */
2277                 dir->untracked = NULL;
2278         if (!len || treat_leading_path(dir, istate, path, len, pathspec))
2279                 read_directory_recursive(dir, istate, path, len, untracked, 0, 0, pathspec);
2280         QSORT(dir->entries, dir->nr, cmp_dir_entry);
2281         QSORT(dir->ignored, dir->ignored_nr, cmp_dir_entry);
2282
2283         /*
2284          * If DIR_SHOW_IGNORED_TOO is set, read_directory_recursive() will
2285          * also pick up untracked contents of untracked dirs; by default
2286          * we discard these, but given DIR_KEEP_UNTRACKED_CONTENTS we do not.
2287          */
2288         if ((dir->flags & DIR_SHOW_IGNORED_TOO) &&
2289                      !(dir->flags & DIR_KEEP_UNTRACKED_CONTENTS)) {
2290                 int i, j;
2291
2292                 /* remove from dir->entries untracked contents of untracked dirs */
2293                 for (i = j = 0; j < dir->nr; j++) {
2294                         if (i &&
2295                             check_dir_entry_contains(dir->entries[i - 1], dir->entries[j])) {
2296                                 FREE_AND_NULL(dir->entries[j]);
2297                         } else {
2298                                 dir->entries[i++] = dir->entries[j];
2299                         }
2300                 }
2301
2302                 dir->nr = i;
2303         }
2304
2305         trace_performance_since(start, "read directory %.*s", len, path);
2306         if (dir->untracked) {
2307                 static int force_untracked_cache = -1;
2308                 static struct trace_key trace_untracked_stats = TRACE_KEY_INIT(UNTRACKED_STATS);
2309
2310                 if (force_untracked_cache < 0)
2311                         force_untracked_cache =
2312                                 git_env_bool("GIT_FORCE_UNTRACKED_CACHE", 0);
2313                 trace_printf_key(&trace_untracked_stats,
2314                                  "node creation: %u\n"
2315                                  "gitignore invalidation: %u\n"
2316                                  "directory invalidation: %u\n"
2317                                  "opendir: %u\n",
2318                                  dir->untracked->dir_created,
2319                                  dir->untracked->gitignore_invalidated,
2320                                  dir->untracked->dir_invalidated,
2321                                  dir->untracked->dir_opened);
2322                 if (force_untracked_cache &&
2323                         dir->untracked == istate->untracked &&
2324                     (dir->untracked->dir_opened ||
2325                      dir->untracked->gitignore_invalidated ||
2326                      dir->untracked->dir_invalidated))
2327                         istate->cache_changed |= UNTRACKED_CHANGED;
2328                 if (dir->untracked != istate->untracked) {
2329                         FREE_AND_NULL(dir->untracked);
2330                 }
2331         }
2332         return dir->nr;
2333 }
2334
2335 int file_exists(const char *f)
2336 {
2337         struct stat sb;
2338         return lstat(f, &sb) == 0;
2339 }
2340
2341 static int cmp_icase(char a, char b)
2342 {
2343         if (a == b)
2344                 return 0;
2345         if (ignore_case)
2346                 return toupper(a) - toupper(b);
2347         return a - b;
2348 }
2349
2350 /*
2351  * Given two normalized paths (a trailing slash is ok), if subdir is
2352  * outside dir, return -1.  Otherwise return the offset in subdir that
2353  * can be used as relative path to dir.
2354  */
2355 int dir_inside_of(const char *subdir, const char *dir)
2356 {
2357         int offset = 0;
2358
2359         assert(dir && subdir && *dir && *subdir);
2360
2361         while (*dir && *subdir && !cmp_icase(*dir, *subdir)) {
2362                 dir++;
2363                 subdir++;
2364                 offset++;
2365         }
2366
2367         /* hel[p]/me vs hel[l]/yeah */
2368         if (*dir && *subdir)
2369                 return -1;
2370
2371         if (!*subdir)
2372                 return !*dir ? offset : -1; /* same dir */
2373
2374         /* foo/[b]ar vs foo/[] */
2375         if (is_dir_sep(dir[-1]))
2376                 return is_dir_sep(subdir[-1]) ? offset : -1;
2377
2378         /* foo[/]bar vs foo[] */
2379         return is_dir_sep(*subdir) ? offset + 1 : -1;
2380 }
2381
2382 int is_inside_dir(const char *dir)
2383 {
2384         char *cwd;
2385         int rc;
2386
2387         if (!dir)
2388                 return 0;
2389
2390         cwd = xgetcwd();
2391         rc = (dir_inside_of(cwd, dir) >= 0);
2392         free(cwd);
2393         return rc;
2394 }
2395
2396 int is_empty_dir(const char *path)
2397 {
2398         DIR *dir = opendir(path);
2399         struct dirent *e;
2400         int ret = 1;
2401
2402         if (!dir)
2403                 return 0;
2404
2405         while ((e = readdir(dir)) != NULL)
2406                 if (!is_dot_or_dotdot(e->d_name)) {
2407                         ret = 0;
2408                         break;
2409                 }
2410
2411         closedir(dir);
2412         return ret;
2413 }
2414
2415 static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)
2416 {
2417         DIR *dir;
2418         struct dirent *e;
2419         int ret = 0, original_len = path->len, len, kept_down = 0;
2420         int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);
2421         int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);
2422         struct object_id submodule_head;
2423
2424         if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&
2425             !resolve_gitlink_ref(path->buf, "HEAD", &submodule_head)) {
2426                 /* Do not descend and nuke a nested git work tree. */
2427                 if (kept_up)
2428                         *kept_up = 1;
2429                 return 0;
2430         }
2431
2432         flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;
2433         dir = opendir(path->buf);
2434         if (!dir) {
2435                 if (errno == ENOENT)
2436                         return keep_toplevel ? -1 : 0;
2437                 else if (errno == EACCES && !keep_toplevel)
2438                         /*
2439                          * An empty dir could be removable even if it
2440                          * is unreadable:
2441                          */
2442                         return rmdir(path->buf);
2443                 else
2444                         return -1;
2445         }
2446         strbuf_complete(path, '/');
2447
2448         len = path->len;
2449         while ((e = readdir(dir)) != NULL) {
2450                 struct stat st;
2451                 if (is_dot_or_dotdot(e->d_name))
2452                         continue;
2453
2454                 strbuf_setlen(path, len);
2455                 strbuf_addstr(path, e->d_name);
2456                 if (lstat(path->buf, &st)) {
2457                         if (errno == ENOENT)
2458                                 /*
2459                                  * file disappeared, which is what we
2460                                  * wanted anyway
2461                                  */
2462                                 continue;
2463                         /* fall thru */
2464                 } else if (S_ISDIR(st.st_mode)) {
2465                         if (!remove_dir_recurse(path, flag, &kept_down))
2466                                 continue; /* happy */
2467                 } else if (!only_empty &&
2468                            (!unlink(path->buf) || errno == ENOENT)) {
2469                         continue; /* happy, too */
2470                 }
2471
2472                 /* path too long, stat fails, or non-directory still exists */
2473                 ret = -1;
2474                 break;
2475         }
2476         closedir(dir);
2477
2478         strbuf_setlen(path, original_len);
2479         if (!ret && !keep_toplevel && !kept_down)
2480                 ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;
2481         else if (kept_up)
2482                 /*
2483                  * report the uplevel that it is not an error that we
2484                  * did not rmdir() our directory.
2485                  */
2486                 *kept_up = !ret;
2487         return ret;
2488 }
2489
2490 int remove_dir_recursively(struct strbuf *path, int flag)
2491 {
2492         return remove_dir_recurse(path, flag, NULL);
2493 }
2494
2495 static GIT_PATH_FUNC(git_path_info_exclude, "info/exclude")
2496
2497 void setup_standard_excludes(struct dir_struct *dir)
2498 {
2499         dir->exclude_per_dir = ".gitignore";
2500
2501         /* core.excludefile defaulting to $XDG_HOME/git/ignore */
2502         if (!excludes_file)
2503                 excludes_file = xdg_config_home("ignore");
2504         if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))
2505                 add_excludes_from_file_1(dir, excludes_file,
2506                                          dir->untracked ? &dir->ss_excludes_file : NULL);
2507
2508         /* per repository user preference */
2509         if (startup_info->have_repository) {
2510                 const char *path = git_path_info_exclude();
2511                 if (!access_or_warn(path, R_OK, 0))
2512                         add_excludes_from_file_1(dir, path,
2513                                                  dir->untracked ? &dir->ss_info_exclude : NULL);
2514         }
2515 }
2516
2517 int remove_path(const char *name)
2518 {
2519         char *slash;
2520
2521         if (unlink(name) && !is_missing_file_error(errno))
2522                 return -1;
2523
2524         slash = strrchr(name, '/');
2525         if (slash) {
2526                 char *dirs = xstrdup(name);
2527                 slash = dirs + (slash - name);
2528                 do {
2529                         *slash = '\0';
2530                 } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));
2531                 free(dirs);
2532         }
2533         return 0;
2534 }
2535
2536 /*
2537  * Frees memory within dir which was allocated for exclude lists and
2538  * the exclude_stack.  Does not free dir itself.
2539  */
2540 void clear_directory(struct dir_struct *dir)
2541 {
2542         int i, j;
2543         struct exclude_list_group *group;
2544         struct exclude_list *el;
2545         struct exclude_stack *stk;
2546
2547         for (i = EXC_CMDL; i <= EXC_FILE; i++) {
2548                 group = &dir->exclude_list_group[i];
2549                 for (j = 0; j < group->nr; j++) {
2550                         el = &group->el[j];
2551                         if (i == EXC_DIRS)
2552                                 free((char *)el->src);
2553                         clear_exclude_list(el);
2554                 }
2555                 free(group->el);
2556         }
2557
2558         stk = dir->exclude_stack;
2559         while (stk) {
2560                 struct exclude_stack *prev = stk->prev;
2561                 free(stk);
2562                 stk = prev;
2563         }
2564         strbuf_release(&dir->basebuf);
2565 }
2566
2567 struct ondisk_untracked_cache {
2568         struct stat_data info_exclude_stat;
2569         struct stat_data excludes_file_stat;
2570         uint32_t dir_flags;
2571         unsigned char info_exclude_sha1[20];
2572         unsigned char excludes_file_sha1[20];
2573         char exclude_per_dir[FLEX_ARRAY];
2574 };
2575
2576 #define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)
2577 #define ouc_size(len) (ouc_offset(exclude_per_dir) + len + 1)
2578
2579 struct write_data {
2580         int index;         /* number of written untracked_cache_dir */
2581         struct ewah_bitmap *check_only; /* from untracked_cache_dir */
2582         struct ewah_bitmap *valid;      /* from untracked_cache_dir */
2583         struct ewah_bitmap *sha1_valid; /* set if exclude_sha1 is not null */
2584         struct strbuf out;
2585         struct strbuf sb_stat;
2586         struct strbuf sb_sha1;
2587 };
2588
2589 static void stat_data_to_disk(struct stat_data *to, const struct stat_data *from)
2590 {
2591         to->sd_ctime.sec  = htonl(from->sd_ctime.sec);
2592         to->sd_ctime.nsec = htonl(from->sd_ctime.nsec);
2593         to->sd_mtime.sec  = htonl(from->sd_mtime.sec);
2594         to->sd_mtime.nsec = htonl(from->sd_mtime.nsec);
2595         to->sd_dev        = htonl(from->sd_dev);
2596         to->sd_ino        = htonl(from->sd_ino);
2597         to->sd_uid        = htonl(from->sd_uid);
2598         to->sd_gid        = htonl(from->sd_gid);
2599         to->sd_size       = htonl(from->sd_size);
2600 }
2601
2602 static void write_one_dir(struct untracked_cache_dir *untracked,
2603                           struct write_data *wd)
2604 {
2605         struct stat_data stat_data;
2606         struct strbuf *out = &wd->out;
2607         unsigned char intbuf[16];
2608         unsigned int intlen, value;
2609         int i = wd->index++;
2610
2611         /*
2612          * untracked_nr should be reset whenever valid is clear, but
2613          * for safety..
2614          */
2615         if (!untracked->valid) {
2616                 untracked->untracked_nr = 0;
2617                 untracked->check_only = 0;
2618         }
2619
2620         if (untracked->check_only)
2621                 ewah_set(wd->check_only, i);
2622         if (untracked->valid) {
2623                 ewah_set(wd->valid, i);
2624                 stat_data_to_disk(&stat_data, &untracked->stat_data);
2625                 strbuf_add(&wd->sb_stat, &stat_data, sizeof(stat_data));
2626         }
2627         if (!is_null_oid(&untracked->exclude_oid)) {
2628                 ewah_set(wd->sha1_valid, i);
2629                 strbuf_add(&wd->sb_sha1, untracked->exclude_oid.hash,
2630                            the_hash_algo->rawsz);
2631         }
2632
2633         intlen = encode_varint(untracked->untracked_nr, intbuf);
2634         strbuf_add(out, intbuf, intlen);
2635
2636         /* skip non-recurse directories */
2637         for (i = 0, value = 0; i < untracked->dirs_nr; i++)
2638                 if (untracked->dirs[i]->recurse)
2639                         value++;
2640         intlen = encode_varint(value, intbuf);
2641         strbuf_add(out, intbuf, intlen);
2642
2643         strbuf_add(out, untracked->name, strlen(untracked->name) + 1);
2644
2645         for (i = 0; i < untracked->untracked_nr; i++)
2646                 strbuf_add(out, untracked->untracked[i],
2647                            strlen(untracked->untracked[i]) + 1);
2648
2649         for (i = 0; i < untracked->dirs_nr; i++)
2650                 if (untracked->dirs[i]->recurse)
2651                         write_one_dir(untracked->dirs[i], wd);
2652 }
2653
2654 void write_untracked_extension(struct strbuf *out, struct untracked_cache *untracked)
2655 {
2656         struct ondisk_untracked_cache *ouc;
2657         struct write_data wd;
2658         unsigned char varbuf[16];
2659         int varint_len;
2660         size_t len = strlen(untracked->exclude_per_dir);
2661
2662         FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);
2663         stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);
2664         stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);
2665         hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.oid.hash);
2666         hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.oid.hash);
2667         ouc->dir_flags = htonl(untracked->dir_flags);
2668
2669         varint_len = encode_varint(untracked->ident.len, varbuf);
2670         strbuf_add(out, varbuf, varint_len);
2671         strbuf_addbuf(out, &untracked->ident);
2672
2673         strbuf_add(out, ouc, ouc_size(len));
2674         FREE_AND_NULL(ouc);
2675
2676         if (!untracked->root) {
2677                 varint_len = encode_varint(0, varbuf);
2678                 strbuf_add(out, varbuf, varint_len);
2679                 return;
2680         }
2681
2682         wd.index      = 0;
2683         wd.check_only = ewah_new();
2684         wd.valid      = ewah_new();
2685         wd.sha1_valid = ewah_new();
2686         strbuf_init(&wd.out, 1024);
2687         strbuf_init(&wd.sb_stat, 1024);
2688         strbuf_init(&wd.sb_sha1, 1024);
2689         write_one_dir(untracked->root, &wd);
2690
2691         varint_len = encode_varint(wd.index, varbuf);
2692         strbuf_add(out, varbuf, varint_len);
2693         strbuf_addbuf(out, &wd.out);
2694         ewah_serialize_strbuf(wd.valid, out);
2695         ewah_serialize_strbuf(wd.check_only, out);
2696         ewah_serialize_strbuf(wd.sha1_valid, out);
2697         strbuf_addbuf(out, &wd.sb_stat);
2698         strbuf_addbuf(out, &wd.sb_sha1);
2699         strbuf_addch(out, '\0'); /* safe guard for string lists */
2700
2701         ewah_free(wd.valid);
2702         ewah_free(wd.check_only);
2703         ewah_free(wd.sha1_valid);
2704         strbuf_release(&wd.out);
2705         strbuf_release(&wd.sb_stat);
2706         strbuf_release(&wd.sb_sha1);
2707 }
2708
2709 static void free_untracked(struct untracked_cache_dir *ucd)
2710 {
2711         int i;
2712         if (!ucd)
2713                 return;
2714         for (i = 0; i < ucd->dirs_nr; i++)
2715                 free_untracked(ucd->dirs[i]);
2716         for (i = 0; i < ucd->untracked_nr; i++)
2717                 free(ucd->untracked[i]);
2718         free(ucd->untracked);
2719         free(ucd->dirs);
2720         free(ucd);
2721 }
2722
2723 void free_untracked_cache(struct untracked_cache *uc)
2724 {
2725         if (uc)
2726                 free_untracked(uc->root);
2727         free(uc);
2728 }
2729
2730 struct read_data {
2731         int index;
2732         struct untracked_cache_dir **ucd;
2733         struct ewah_bitmap *check_only;
2734         struct ewah_bitmap *valid;
2735         struct ewah_bitmap *sha1_valid;
2736         const unsigned char *data;
2737         const unsigned char *end;
2738 };
2739
2740 static void stat_data_from_disk(struct stat_data *to, const unsigned char *data)
2741 {
2742         memcpy(to, data, sizeof(*to));
2743         to->sd_ctime.sec  = ntohl(to->sd_ctime.sec);
2744         to->sd_ctime.nsec = ntohl(to->sd_ctime.nsec);
2745         to->sd_mtime.sec  = ntohl(to->sd_mtime.sec);
2746         to->sd_mtime.nsec = ntohl(to->sd_mtime.nsec);
2747         to->sd_dev        = ntohl(to->sd_dev);
2748         to->sd_ino        = ntohl(to->sd_ino);
2749         to->sd_uid        = ntohl(to->sd_uid);
2750         to->sd_gid        = ntohl(to->sd_gid);
2751         to->sd_size       = ntohl(to->sd_size);
2752 }
2753
2754 static int read_one_dir(struct untracked_cache_dir **untracked_,
2755                         struct read_data *rd)
2756 {
2757         struct untracked_cache_dir ud, *untracked;
2758         const unsigned char *next, *data = rd->data, *end = rd->end;
2759         unsigned int value;
2760         int i, len;
2761
2762         memset(&ud, 0, sizeof(ud));
2763
2764         next = data;
2765         value = decode_varint(&next);
2766         if (next > end)
2767                 return -1;
2768         ud.recurse         = 1;
2769         ud.untracked_alloc = value;
2770         ud.untracked_nr    = value;
2771         if (ud.untracked_nr)
2772                 ALLOC_ARRAY(ud.untracked, ud.untracked_nr);
2773         data = next;
2774
2775         next = data;
2776         ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);
2777         if (next > end)
2778                 return -1;
2779         ALLOC_ARRAY(ud.dirs, ud.dirs_nr);
2780         data = next;
2781
2782         len = strlen((const char *)data);
2783         next = data + len + 1;
2784         if (next > rd->end)
2785                 return -1;
2786         *untracked_ = untracked = xmalloc(st_add(sizeof(*untracked), len));
2787         memcpy(untracked, &ud, sizeof(ud));
2788         memcpy(untracked->name, data, len + 1);
2789         data = next;
2790
2791         for (i = 0; i < untracked->untracked_nr; i++) {
2792                 len = strlen((const char *)data);
2793                 next = data + len + 1;
2794                 if (next > rd->end)
2795                         return -1;
2796                 untracked->untracked[i] = xstrdup((const char*)data);
2797                 data = next;
2798         }
2799
2800         rd->ucd[rd->index++] = untracked;
2801         rd->data = data;
2802
2803         for (i = 0; i < untracked->dirs_nr; i++) {
2804                 len = read_one_dir(untracked->dirs + i, rd);
2805                 if (len < 0)
2806                         return -1;
2807         }
2808         return 0;
2809 }
2810
2811 static void set_check_only(size_t pos, void *cb)
2812 {
2813         struct read_data *rd = cb;
2814         struct untracked_cache_dir *ud = rd->ucd[pos];
2815         ud->check_only = 1;
2816 }
2817
2818 static void read_stat(size_t pos, void *cb)
2819 {
2820         struct read_data *rd = cb;
2821         struct untracked_cache_dir *ud = rd->ucd[pos];
2822         if (rd->data + sizeof(struct stat_data) > rd->end) {
2823                 rd->data = rd->end + 1;
2824                 return;
2825         }
2826         stat_data_from_disk(&ud->stat_data, rd->data);
2827         rd->data += sizeof(struct stat_data);
2828         ud->valid = 1;
2829 }
2830
2831 static void read_oid(size_t pos, void *cb)
2832 {
2833         struct read_data *rd = cb;
2834         struct untracked_cache_dir *ud = rd->ucd[pos];
2835         if (rd->data + the_hash_algo->rawsz > rd->end) {
2836                 rd->data = rd->end + 1;
2837                 return;
2838         }
2839         hashcpy(ud->exclude_oid.hash, rd->data);
2840         rd->data += the_hash_algo->rawsz;
2841 }
2842
2843 static void load_oid_stat(struct oid_stat *oid_stat, const unsigned char *data,
2844                           const unsigned char *sha1)
2845 {
2846         stat_data_from_disk(&oid_stat->stat, data);
2847         hashcpy(oid_stat->oid.hash, sha1);
2848         oid_stat->valid = 1;
2849 }
2850
2851 struct untracked_cache *read_untracked_extension(const void *data, unsigned long sz)
2852 {
2853         struct untracked_cache *uc;
2854         struct read_data rd;
2855         const unsigned char *next = data, *end = (const unsigned char *)data + sz;
2856         const char *ident;
2857         int ident_len;
2858         ssize_t len;
2859         const char *exclude_per_dir;
2860
2861         if (sz <= 1 || end[-1] != '\0')
2862                 return NULL;
2863         end--;
2864
2865         ident_len = decode_varint(&next);
2866         if (next + ident_len > end)
2867                 return NULL;
2868         ident = (const char *)next;
2869         next += ident_len;
2870
2871         if (next + ouc_size(0) > end)
2872                 return NULL;
2873
2874         uc = xcalloc(1, sizeof(*uc));
2875         strbuf_init(&uc->ident, ident_len);
2876         strbuf_add(&uc->ident, ident, ident_len);
2877         load_oid_stat(&uc->ss_info_exclude,
2878                       next + ouc_offset(info_exclude_stat),
2879                       next + ouc_offset(info_exclude_sha1));
2880         load_oid_stat(&uc->ss_excludes_file,
2881                       next + ouc_offset(excludes_file_stat),
2882                       next + ouc_offset(excludes_file_sha1));
2883         uc->dir_flags = get_be32(next + ouc_offset(dir_flags));
2884         exclude_per_dir = (const char *)next + ouc_offset(exclude_per_dir);
2885         uc->exclude_per_dir = xstrdup(exclude_per_dir);
2886         /* NUL after exclude_per_dir is covered by sizeof(*ouc) */
2887         next += ouc_size(strlen(exclude_per_dir));
2888         if (next >= end)
2889                 goto done2;
2890
2891         len = decode_varint(&next);
2892         if (next > end || len == 0)
2893                 goto done2;
2894
2895         rd.valid      = ewah_new();
2896         rd.check_only = ewah_new();
2897         rd.sha1_valid = ewah_new();
2898         rd.data       = next;
2899         rd.end        = end;
2900         rd.index      = 0;
2901         ALLOC_ARRAY(rd.ucd, len);
2902
2903         if (read_one_dir(&uc->root, &rd) || rd.index != len)
2904                 goto done;
2905
2906         next = rd.data;
2907         len = ewah_read_mmap(rd.valid, next, end - next);
2908         if (len < 0)
2909                 goto done;
2910
2911         next += len;
2912         len = ewah_read_mmap(rd.check_only, next, end - next);
2913         if (len < 0)
2914                 goto done;
2915
2916         next += len;
2917         len = ewah_read_mmap(rd.sha1_valid, next, end - next);
2918         if (len < 0)
2919                 goto done;
2920
2921         ewah_each_bit(rd.check_only, set_check_only, &rd);
2922         rd.data = next + len;
2923         ewah_each_bit(rd.valid, read_stat, &rd);
2924         ewah_each_bit(rd.sha1_valid, read_oid, &rd);
2925         next = rd.data;
2926
2927 done:
2928         free(rd.ucd);
2929         ewah_free(rd.valid);
2930         ewah_free(rd.check_only);
2931         ewah_free(rd.sha1_valid);
2932 done2:
2933         if (next != end) {
2934                 free_untracked_cache(uc);
2935                 uc = NULL;
2936         }
2937         return uc;
2938 }
2939
2940 static void invalidate_one_directory(struct untracked_cache *uc,
2941                                      struct untracked_cache_dir *ucd)
2942 {
2943         uc->dir_invalidated++;
2944         ucd->valid = 0;
2945         ucd->untracked_nr = 0;
2946 }
2947
2948 /*
2949  * Normally when an entry is added or removed from a directory,
2950  * invalidating that directory is enough. No need to touch its
2951  * ancestors. When a directory is shown as "foo/bar/" in git-status
2952  * however, deleting or adding an entry may have cascading effect.
2953  *
2954  * Say the "foo/bar/file" has become untracked, we need to tell the
2955  * untracked_cache_dir of "foo" that "bar/" is not an untracked
2956  * directory any more (because "bar" is managed by foo as an untracked
2957  * "file").
2958  *
2959  * Similarly, if "foo/bar/file" moves from untracked to tracked and it
2960  * was the last untracked entry in the entire "foo", we should show
2961  * "foo/" instead. Which means we have to invalidate past "bar" up to
2962  * "foo".
2963  *
2964  * This function traverses all directories from root to leaf. If there
2965  * is a chance of one of the above cases happening, we invalidate back
2966  * to root. Otherwise we just invalidate the leaf. There may be a more
2967  * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to
2968  * detect these cases and avoid unnecessary invalidation, for example,
2969  * checking for the untracked entry named "bar/" in "foo", but for now
2970  * stick to something safe and simple.
2971  */
2972 static int invalidate_one_component(struct untracked_cache *uc,
2973                                     struct untracked_cache_dir *dir,
2974                                     const char *path, int len)
2975 {
2976         const char *rest = strchr(path, '/');
2977
2978         if (rest) {
2979                 int component_len = rest - path;
2980                 struct untracked_cache_dir *d =
2981                         lookup_untracked(uc, dir, path, component_len);
2982                 int ret =
2983                         invalidate_one_component(uc, d, rest + 1,
2984                                                  len - (component_len + 1));
2985                 if (ret)
2986                         invalidate_one_directory(uc, dir);
2987                 return ret;
2988         }
2989
2990         invalidate_one_directory(uc, dir);
2991         return uc->dir_flags & DIR_SHOW_OTHER_DIRECTORIES;
2992 }
2993
2994 void untracked_cache_invalidate_path(struct index_state *istate,
2995                                      const char *path, int safe_path)
2996 {
2997         if (!istate->untracked || !istate->untracked->root)
2998                 return;
2999         if (!safe_path && !verify_path(path, 0))
3000                 return;
3001         invalidate_one_component(istate->untracked, istate->untracked->root,
3002                                  path, strlen(path));
3003 }
3004
3005 void untracked_cache_remove_from_index(struct index_state *istate,
3006                                        const char *path)
3007 {
3008         untracked_cache_invalidate_path(istate, path, 1);
3009 }
3010
3011 void untracked_cache_add_to_index(struct index_state *istate,
3012                                   const char *path)
3013 {
3014         untracked_cache_invalidate_path(istate, path, 1);
3015 }
3016
3017 static void connect_wt_gitdir_in_nested(const char *sub_worktree,
3018                                         const char *sub_gitdir)
3019 {
3020         int i;
3021         struct repository subrepo;
3022         struct strbuf sub_wt = STRBUF_INIT;
3023         struct strbuf sub_gd = STRBUF_INIT;
3024
3025         const struct submodule *sub;
3026
3027         /* If the submodule has no working tree, we can ignore it. */
3028         if (repo_init(&subrepo, sub_gitdir, sub_worktree))
3029                 return;
3030
3031         if (repo_read_index(&subrepo) < 0)
3032                 die("index file corrupt in repo %s", subrepo.gitdir);
3033
3034         for (i = 0; i < subrepo.index->cache_nr; i++) {
3035                 const struct cache_entry *ce = subrepo.index->cache[i];
3036
3037                 if (!S_ISGITLINK(ce->ce_mode))
3038                         continue;
3039
3040                 while (i + 1 < subrepo.index->cache_nr &&
3041                        !strcmp(ce->name, subrepo.index->cache[i + 1]->name))
3042                         /*
3043                          * Skip entries with the same name in different stages
3044                          * to make sure an entry is returned only once.
3045                          */
3046                         i++;
3047
3048                 sub = submodule_from_path(&subrepo, &null_oid, ce->name);
3049                 if (!sub || !is_submodule_active(&subrepo, ce->name))
3050                         /* .gitmodules broken or inactive sub */
3051                         continue;
3052
3053                 strbuf_reset(&sub_wt);
3054                 strbuf_reset(&sub_gd);
3055                 strbuf_addf(&sub_wt, "%s/%s", sub_worktree, sub->path);
3056                 strbuf_addf(&sub_gd, "%s/modules/%s", sub_gitdir, sub->name);
3057
3058                 connect_work_tree_and_git_dir(sub_wt.buf, sub_gd.buf, 1);
3059         }
3060         strbuf_release(&sub_wt);
3061         strbuf_release(&sub_gd);
3062         repo_clear(&subrepo);
3063 }
3064
3065 void connect_work_tree_and_git_dir(const char *work_tree_,
3066                                    const char *git_dir_,
3067                                    int recurse_into_nested)
3068 {
3069         struct strbuf gitfile_sb = STRBUF_INIT;
3070         struct strbuf cfg_sb = STRBUF_INIT;
3071         struct strbuf rel_path = STRBUF_INIT;
3072         char *git_dir, *work_tree;
3073
3074         /* Prepare .git file */
3075         strbuf_addf(&gitfile_sb, "%s/.git", work_tree_);
3076         if (safe_create_leading_directories_const(gitfile_sb.buf))
3077                 die(_("could not create directories for %s"), gitfile_sb.buf);
3078
3079         /* Prepare config file */
3080         strbuf_addf(&cfg_sb, "%s/config", git_dir_);
3081         if (safe_create_leading_directories_const(cfg_sb.buf))
3082                 die(_("could not create directories for %s"), cfg_sb.buf);
3083
3084         git_dir = real_pathdup(git_dir_, 1);
3085         work_tree = real_pathdup(work_tree_, 1);
3086
3087         /* Write .git file */
3088         write_file(gitfile_sb.buf, "gitdir: %s",
3089                    relative_path(git_dir, work_tree, &rel_path));
3090         /* Update core.worktree setting */
3091         git_config_set_in_file(cfg_sb.buf, "core.worktree",
3092                                relative_path(work_tree, git_dir, &rel_path));
3093
3094         strbuf_release(&gitfile_sb);
3095         strbuf_release(&cfg_sb);
3096         strbuf_release(&rel_path);
3097
3098         if (recurse_into_nested)
3099                 connect_wt_gitdir_in_nested(work_tree, git_dir);
3100
3101         free(work_tree);
3102         free(git_dir);
3103 }
3104
3105 /*
3106  * Migrate the git directory of the given path from old_git_dir to new_git_dir.
3107  */
3108 void relocate_gitdir(const char *path, const char *old_git_dir, const char *new_git_dir)
3109 {
3110         if (rename(old_git_dir, new_git_dir) < 0)
3111                 die_errno(_("could not migrate git directory from '%s' to '%s'"),
3112                         old_git_dir, new_git_dir);
3113
3114         connect_work_tree_and_git_dir(path, new_git_dir, 0);
3115 }