dir.con commit Merge branch 'dt/gc-ignore-old-gc-logs' (c96bc18)
   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 */
  25enum 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 */
  35struct 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
  46static 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);
  49static int get_dtype(struct dirent *de, const char *path, int len);
  50
  51int fspathcmp(const char *a, const char *b)
  52{
  53        return ignore_case ? strcasecmp(a, b) : strcmp(a, b);
  54}
  55
  56int 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
  61int 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
  90static 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
 119static 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 */
 168char *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
 175int 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
 193int 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 */
 224static 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 */
 329static 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
 398int 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 */
 417int 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
 429int 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 */
 473int 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
 485int no_wildcard(const char *string)
 486{
 487        return string[simple_length(string)] == '\0';
 488}
 489
 490void 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
 528void 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
 554static 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 */
 585void 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
 597static 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 */
 627static 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
 665static 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
 674static 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
 681static 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 */
 701static 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
 786int 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
 793struct 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 */
 810static 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
 826void 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
 832int 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
 856int 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 */
 921static 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 */
 971int 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
 982static 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 */
1006static 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 */
1160struct 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 */
1182int 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
1191static 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
1200static 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
1209struct 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
1218enum 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 */
1229static 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 */
1250static 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 */
1310static 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 */
1350static 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 */
1390static 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
1421static 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
1459static 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
1480static 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
1543static 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
1575static 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
1599static 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
1608static 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
1654static 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
1672static 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
1699static 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 */
1724static 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
1805static 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
1813static 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
1854static 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
1868static 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
1879static 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
1891static 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
1903void 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
1915void 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
1924static 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
2009int 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
2052int file_exists(const char *f)
2053{
2054        struct stat sb;
2055        return lstat(f, &sb) == 0;
2056}
2057
2058static 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 */
2072int 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
2099int 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
2113int 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
2132static 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
2207int remove_dir_recursively(struct strbuf *path, int flag)
2208{
2209        return remove_dir_recurse(path, flag, NULL);
2210}
2211
2212static GIT_PATH_FUNC(git_path_info_exclude, "info/exclude")
2213
2214void 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
2234int 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 */
2257void 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
2284struct 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
2295struct 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
2305static 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
2318static 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
2369void 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
2425static 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
2439void free_untracked_cache(struct untracked_cache *uc)
2440{
2441        if (uc)
2442                free_untracked(uc->root);
2443        free(uc);
2444}
2445
2446struct 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
2456static 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
2469static 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
2526static 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
2533static 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
2546static 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
2558static 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
2567struct 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
2640done:
2641        free(rd.ucd);
2642        ewah_free(rd.valid);
2643        ewah_free(rd.check_only);
2644        ewah_free(rd.sha1_valid);
2645done2:
2646        if (next != end) {
2647                free_untracked_cache(uc);
2648                uc = NULL;
2649        }
2650        return uc;
2651}
2652
2653static 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 */
2685static 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
2707void 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
2716void untracked_cache_remove_from_index(struct index_state *istate,
2717                                       const char *path)
2718{
2719        untracked_cache_invalidate_path(istate, path);
2720}
2721
2722void 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 */
2729void 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 */
2756void 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}