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