124b4341099fcca11e3dd4cf6ef101291a972f52
   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
  16struct path_simplify {
  17        int len;
  18        const char *path;
  19};
  20
  21/*
  22 * Tells read_directory_recursive how a file or directory should be treated.
  23 * Values are ordered by significance, e.g. if a directory contains both
  24 * excluded and untracked files, it is listed as untracked because
  25 * path_untracked > path_excluded.
  26 */
  27enum path_treatment {
  28        path_none = 0,
  29        path_recurse,
  30        path_excluded,
  31        path_untracked
  32};
  33
  34static enum path_treatment read_directory_recursive(struct dir_struct *dir,
  35        const char *path, int len,
  36        int check_only, const struct path_simplify *simplify);
  37static int get_dtype(struct dirent *de, const char *path, int len);
  38
  39/* helper string functions with support for the ignore_case flag */
  40int strcmp_icase(const char *a, const char *b)
  41{
  42        return ignore_case ? strcasecmp(a, b) : strcmp(a, b);
  43}
  44
  45int strncmp_icase(const char *a, const char *b, size_t count)
  46{
  47        return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count);
  48}
  49
  50int fnmatch_icase(const char *pattern, const char *string, int flags)
  51{
  52        return fnmatch(pattern, string, flags | (ignore_case ? FNM_CASEFOLD : 0));
  53}
  54
  55inline int git_fnmatch(const struct pathspec_item *item,
  56                       const char *pattern, const char *string,
  57                       int prefix)
  58{
  59        if (prefix > 0) {
  60                if (ps_strncmp(item, pattern, string, prefix))
  61                        return FNM_NOMATCH;
  62                pattern += prefix;
  63                string += prefix;
  64        }
  65        if (item->flags & PATHSPEC_ONESTAR) {
  66                int pattern_len = strlen(++pattern);
  67                int string_len = strlen(string);
  68                return string_len < pattern_len ||
  69                        ps_strcmp(item, pattern,
  70                                  string + string_len - pattern_len);
  71        }
  72        if (item->magic & PATHSPEC_GLOB)
  73                return wildmatch(pattern, string,
  74                                 WM_PATHNAME |
  75                                 (item->magic & PATHSPEC_ICASE ? WM_CASEFOLD : 0),
  76                                 NULL);
  77        else
  78                /* wildmatch has not learned no FNM_PATHNAME mode yet */
  79                return fnmatch(pattern, string,
  80                               item->magic & PATHSPEC_ICASE ? FNM_CASEFOLD : 0);
  81}
  82
  83static int fnmatch_icase_mem(const char *pattern, int patternlen,
  84                             const char *string, int stringlen,
  85                             int flags)
  86{
  87        int match_status;
  88        struct strbuf pat_buf = STRBUF_INIT;
  89        struct strbuf str_buf = STRBUF_INIT;
  90        const char *use_pat = pattern;
  91        const char *use_str = string;
  92
  93        if (pattern[patternlen]) {
  94                strbuf_add(&pat_buf, pattern, patternlen);
  95                use_pat = pat_buf.buf;
  96        }
  97        if (string[stringlen]) {
  98                strbuf_add(&str_buf, string, stringlen);
  99                use_str = str_buf.buf;
 100        }
 101
 102        if (ignore_case)
 103                flags |= WM_CASEFOLD;
 104        match_status = wildmatch(use_pat, use_str, flags, NULL);
 105
 106        strbuf_release(&pat_buf);
 107        strbuf_release(&str_buf);
 108
 109        return match_status;
 110}
 111
 112static size_t common_prefix_len(const struct pathspec *pathspec)
 113{
 114        int n;
 115        size_t max = 0;
 116
 117        /*
 118         * ":(icase)path" is treated as a pathspec full of
 119         * wildcard. In other words, only prefix is considered common
 120         * prefix. If the pathspec is abc/foo abc/bar, running in
 121         * subdir xyz, the common prefix is still xyz, not xuz/abc as
 122         * in non-:(icase).
 123         */
 124        GUARD_PATHSPEC(pathspec,
 125                       PATHSPEC_FROMTOP |
 126                       PATHSPEC_MAXDEPTH |
 127                       PATHSPEC_LITERAL |
 128                       PATHSPEC_GLOB |
 129                       PATHSPEC_ICASE |
 130                       PATHSPEC_EXCLUDE);
 131
 132        for (n = 0; n < pathspec->nr; n++) {
 133                size_t i = 0, len = 0, item_len;
 134                if (pathspec->items[n].magic & PATHSPEC_EXCLUDE)
 135                        continue;
 136                if (pathspec->items[n].magic & PATHSPEC_ICASE)
 137                        item_len = pathspec->items[n].prefix;
 138                else
 139                        item_len = pathspec->items[n].nowildcard_len;
 140                while (i < item_len && (n == 0 || i < max)) {
 141                        char c = pathspec->items[n].match[i];
 142                        if (c != pathspec->items[0].match[i])
 143                                break;
 144                        if (c == '/')
 145                                len = i + 1;
 146                        i++;
 147                }
 148                if (n == 0 || len < max) {
 149                        max = len;
 150                        if (!max)
 151                                break;
 152                }
 153        }
 154        return max;
 155}
 156
 157/*
 158 * Returns a copy of the longest leading path common among all
 159 * pathspecs.
 160 */
 161char *common_prefix(const struct pathspec *pathspec)
 162{
 163        unsigned long len = common_prefix_len(pathspec);
 164
 165        return len ? xmemdupz(pathspec->items[0].match, len) : NULL;
 166}
 167
 168int fill_directory(struct dir_struct *dir, const struct pathspec *pathspec)
 169{
 170        size_t len;
 171
 172        /*
 173         * Calculate common prefix for the pathspec, and
 174         * use that to optimize the directory walk
 175         */
 176        len = common_prefix_len(pathspec);
 177
 178        /* Read the directory and prune it */
 179        read_directory(dir, pathspec->nr ? pathspec->_raw[0] : "", len, pathspec);
 180        return len;
 181}
 182
 183int within_depth(const char *name, int namelen,
 184                        int depth, int max_depth)
 185{
 186        const char *cp = name, *cpe = name + namelen;
 187
 188        while (cp < cpe) {
 189                if (*cp++ != '/')
 190                        continue;
 191                depth++;
 192                if (depth > max_depth)
 193                        return 0;
 194        }
 195        return 1;
 196}
 197
 198#define DO_MATCH_EXCLUDE   1
 199
 200/*
 201 * Does 'match' match the given name?
 202 * A match is found if
 203 *
 204 * (1) the 'match' string is leading directory of 'name', or
 205 * (2) the 'match' string is a wildcard and matches 'name', or
 206 * (3) the 'match' string is exactly the same as 'name'.
 207 *
 208 * and the return value tells which case it was.
 209 *
 210 * It returns 0 when there is no match.
 211 */
 212static int match_pathspec_item(const struct pathspec_item *item, int prefix,
 213                               const char *name, int namelen, unsigned flags)
 214{
 215        /* name/namelen has prefix cut off by caller */
 216        const char *match = item->match + prefix;
 217        int matchlen = item->len - prefix;
 218
 219        /*
 220         * The normal call pattern is:
 221         * 1. prefix = common_prefix_len(ps);
 222         * 2. prune something, or fill_directory
 223         * 3. match_pathspec()
 224         *
 225         * 'prefix' at #1 may be shorter than the command's prefix and
 226         * it's ok for #2 to match extra files. Those extras will be
 227         * trimmed at #3.
 228         *
 229         * Suppose the pathspec is 'foo' and '../bar' running from
 230         * subdir 'xyz'. The common prefix at #1 will be empty, thanks
 231         * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The
 232         * user does not want XYZ/foo, only the "foo" part should be
 233         * case-insensitive. We need to filter out XYZ/foo here. In
 234         * other words, we do not trust the caller on comparing the
 235         * prefix part when :(icase) is involved. We do exact
 236         * comparison ourselves.
 237         *
 238         * Normally the caller (common_prefix_len() in fact) does
 239         * _exact_ matching on name[-prefix+1..-1] and we do not need
 240         * to check that part. Be defensive and check it anyway, in
 241         * case common_prefix_len is changed, or a new caller is
 242         * introduced that does not use common_prefix_len.
 243         *
 244         * If the penalty turns out too high when prefix is really
 245         * long, maybe change it to
 246         * strncmp(match, name, item->prefix - prefix)
 247         */
 248        if (item->prefix && (item->magic & PATHSPEC_ICASE) &&
 249            strncmp(item->match, name - prefix, item->prefix))
 250                return 0;
 251
 252        /* If the match was just the prefix, we matched */
 253        if (!*match)
 254                return MATCHED_RECURSIVELY;
 255
 256        if (matchlen <= namelen && !ps_strncmp(item, match, name, matchlen)) {
 257                if (matchlen == namelen)
 258                        return MATCHED_EXACTLY;
 259
 260                if (match[matchlen-1] == '/' || name[matchlen] == '/')
 261                        return MATCHED_RECURSIVELY;
 262        }
 263
 264        if (item->nowildcard_len < item->len &&
 265            !git_fnmatch(item, match, name,
 266                         item->nowildcard_len - prefix))
 267                return MATCHED_FNMATCH;
 268
 269        return 0;
 270}
 271
 272/*
 273 * Given a name and a list of pathspecs, returns the nature of the
 274 * closest (i.e. most specific) match of the name to any of the
 275 * pathspecs.
 276 *
 277 * The caller typically calls this multiple times with the same
 278 * pathspec and seen[] array but with different name/namelen
 279 * (e.g. entries from the index) and is interested in seeing if and
 280 * how each pathspec matches all the names it calls this function
 281 * with.  A mark is left in the seen[] array for each pathspec element
 282 * indicating the closest type of match that element achieved, so if
 283 * seen[n] remains zero after multiple invocations, that means the nth
 284 * pathspec did not match any names, which could indicate that the
 285 * user mistyped the nth pathspec.
 286 */
 287static int do_match_pathspec(const struct pathspec *ps,
 288                             const char *name, int namelen,
 289                             int prefix, char *seen,
 290                             unsigned flags)
 291{
 292        int i, retval = 0, exclude = flags & DO_MATCH_EXCLUDE;
 293
 294        GUARD_PATHSPEC(ps,
 295                       PATHSPEC_FROMTOP |
 296                       PATHSPEC_MAXDEPTH |
 297                       PATHSPEC_LITERAL |
 298                       PATHSPEC_GLOB |
 299                       PATHSPEC_ICASE |
 300                       PATHSPEC_EXCLUDE);
 301
 302        if (!ps->nr) {
 303                if (!ps->recursive ||
 304                    !(ps->magic & PATHSPEC_MAXDEPTH) ||
 305                    ps->max_depth == -1)
 306                        return MATCHED_RECURSIVELY;
 307
 308                if (within_depth(name, namelen, 0, ps->max_depth))
 309                        return MATCHED_EXACTLY;
 310                else
 311                        return 0;
 312        }
 313
 314        name += prefix;
 315        namelen -= prefix;
 316
 317        for (i = ps->nr - 1; i >= 0; i--) {
 318                int how;
 319
 320                if ((!exclude &&   ps->items[i].magic & PATHSPEC_EXCLUDE) ||
 321                    ( exclude && !(ps->items[i].magic & PATHSPEC_EXCLUDE)))
 322                        continue;
 323
 324                if (seen && seen[i] == MATCHED_EXACTLY)
 325                        continue;
 326                /*
 327                 * Make exclude patterns optional and never report
 328                 * "pathspec ':(exclude)foo' matches no files"
 329                 */
 330                if (seen && ps->items[i].magic & PATHSPEC_EXCLUDE)
 331                        seen[i] = MATCHED_FNMATCH;
 332                how = match_pathspec_item(ps->items+i, prefix, name,
 333                                          namelen, flags);
 334                if (ps->recursive &&
 335                    (ps->magic & PATHSPEC_MAXDEPTH) &&
 336                    ps->max_depth != -1 &&
 337                    how && how != MATCHED_FNMATCH) {
 338                        int len = ps->items[i].len;
 339                        if (name[len] == '/')
 340                                len++;
 341                        if (within_depth(name+len, namelen-len, 0, ps->max_depth))
 342                                how = MATCHED_EXACTLY;
 343                        else
 344                                how = 0;
 345                }
 346                if (how) {
 347                        if (retval < how)
 348                                retval = how;
 349                        if (seen && seen[i] < how)
 350                                seen[i] = how;
 351                }
 352        }
 353        return retval;
 354}
 355
 356int match_pathspec(const struct pathspec *ps,
 357                   const char *name, int namelen,
 358                   int prefix, char *seen)
 359{
 360        int positive, negative;
 361        unsigned flags = 0;
 362        positive = do_match_pathspec(ps, name, namelen,
 363                                     prefix, seen, flags);
 364        if (!(ps->magic & PATHSPEC_EXCLUDE) || !positive)
 365                return positive;
 366        negative = do_match_pathspec(ps, name, namelen,
 367                                     prefix, seen,
 368                                     flags | DO_MATCH_EXCLUDE);
 369        return negative ? 0 : positive;
 370}
 371
 372/*
 373 * Return the length of the "simple" part of a path match limiter.
 374 */
 375int simple_length(const char *match)
 376{
 377        int len = -1;
 378
 379        for (;;) {
 380                unsigned char c = *match++;
 381                len++;
 382                if (c == '\0' || is_glob_special(c))
 383                        return len;
 384        }
 385}
 386
 387int no_wildcard(const char *string)
 388{
 389        return string[simple_length(string)] == '\0';
 390}
 391
 392void parse_exclude_pattern(const char **pattern,
 393                           int *patternlen,
 394                           int *flags,
 395                           int *nowildcardlen)
 396{
 397        const char *p = *pattern;
 398        size_t i, len;
 399
 400        *flags = 0;
 401        if (*p == '!') {
 402                *flags |= EXC_FLAG_NEGATIVE;
 403                p++;
 404        }
 405        len = strlen(p);
 406        if (len && p[len - 1] == '/') {
 407                len--;
 408                *flags |= EXC_FLAG_MUSTBEDIR;
 409        }
 410        for (i = 0; i < len; i++) {
 411                if (p[i] == '/')
 412                        break;
 413        }
 414        if (i == len)
 415                *flags |= EXC_FLAG_NODIR;
 416        *nowildcardlen = simple_length(p);
 417        /*
 418         * we should have excluded the trailing slash from 'p' too,
 419         * but that's one more allocation. Instead just make sure
 420         * nowildcardlen does not exceed real patternlen
 421         */
 422        if (*nowildcardlen > len)
 423                *nowildcardlen = len;
 424        if (*p == '*' && no_wildcard(p + 1))
 425                *flags |= EXC_FLAG_ENDSWITH;
 426        *pattern = p;
 427        *patternlen = len;
 428}
 429
 430void add_exclude(const char *string, const char *base,
 431                 int baselen, struct exclude_list *el, int srcpos)
 432{
 433        struct exclude *x;
 434        int patternlen;
 435        int flags;
 436        int nowildcardlen;
 437
 438        parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);
 439        if (flags & EXC_FLAG_MUSTBEDIR) {
 440                char *s;
 441                x = xmalloc(sizeof(*x) + patternlen + 1);
 442                s = (char *)(x+1);
 443                memcpy(s, string, patternlen);
 444                s[patternlen] = '\0';
 445                x->pattern = s;
 446        } else {
 447                x = xmalloc(sizeof(*x));
 448                x->pattern = string;
 449        }
 450        x->patternlen = patternlen;
 451        x->nowildcardlen = nowildcardlen;
 452        x->base = base;
 453        x->baselen = baselen;
 454        x->flags = flags;
 455        x->srcpos = srcpos;
 456        ALLOC_GROW(el->excludes, el->nr + 1, el->alloc);
 457        el->excludes[el->nr++] = x;
 458        x->el = el;
 459}
 460
 461static void *read_skip_worktree_file_from_index(const char *path, size_t *size)
 462{
 463        int pos, len;
 464        unsigned long sz;
 465        enum object_type type;
 466        void *data;
 467
 468        len = strlen(path);
 469        pos = cache_name_pos(path, len);
 470        if (pos < 0)
 471                return NULL;
 472        if (!ce_skip_worktree(active_cache[pos]))
 473                return NULL;
 474        data = read_sha1_file(active_cache[pos]->sha1, &type, &sz);
 475        if (!data || type != OBJ_BLOB) {
 476                free(data);
 477                return NULL;
 478        }
 479        *size = xsize_t(sz);
 480        return data;
 481}
 482
 483/*
 484 * Frees memory within el which was allocated for exclude patterns and
 485 * the file buffer.  Does not free el itself.
 486 */
 487void clear_exclude_list(struct exclude_list *el)
 488{
 489        int i;
 490
 491        for (i = 0; i < el->nr; i++)
 492                free(el->excludes[i]);
 493        free(el->excludes);
 494        free(el->filebuf);
 495
 496        el->nr = 0;
 497        el->excludes = NULL;
 498        el->filebuf = NULL;
 499}
 500
 501int add_excludes_from_file_to_list(const char *fname,
 502                                   const char *base,
 503                                   int baselen,
 504                                   struct exclude_list *el,
 505                                   int check_index)
 506{
 507        struct stat st;
 508        int fd, i, lineno = 1;
 509        size_t size = 0;
 510        char *buf, *entry;
 511
 512        fd = open(fname, O_RDONLY);
 513        if (fd < 0 || fstat(fd, &st) < 0) {
 514                if (errno != ENOENT)
 515                        warn_on_inaccessible(fname);
 516                if (0 <= fd)
 517                        close(fd);
 518                if (!check_index ||
 519                    (buf = read_skip_worktree_file_from_index(fname, &size)) == NULL)
 520                        return -1;
 521                if (size == 0) {
 522                        free(buf);
 523                        return 0;
 524                }
 525                if (buf[size-1] != '\n') {
 526                        buf = xrealloc(buf, size+1);
 527                        buf[size++] = '\n';
 528                }
 529        }
 530        else {
 531                size = xsize_t(st.st_size);
 532                if (size == 0) {
 533                        close(fd);
 534                        return 0;
 535                }
 536                buf = xmalloc(size+1);
 537                if (read_in_full(fd, buf, size) != size) {
 538                        free(buf);
 539                        close(fd);
 540                        return -1;
 541                }
 542                buf[size++] = '\n';
 543                close(fd);
 544        }
 545
 546        el->filebuf = buf;
 547        entry = buf;
 548        for (i = 0; i < size; i++) {
 549                if (buf[i] == '\n') {
 550                        if (entry != buf + i && entry[0] != '#') {
 551                                buf[i - (i && buf[i-1] == '\r')] = 0;
 552                                add_exclude(entry, base, baselen, el, lineno);
 553                        }
 554                        lineno++;
 555                        entry = buf + i + 1;
 556                }
 557        }
 558        return 0;
 559}
 560
 561struct exclude_list *add_exclude_list(struct dir_struct *dir,
 562                                      int group_type, const char *src)
 563{
 564        struct exclude_list *el;
 565        struct exclude_list_group *group;
 566
 567        group = &dir->exclude_list_group[group_type];
 568        ALLOC_GROW(group->el, group->nr + 1, group->alloc);
 569        el = &group->el[group->nr++];
 570        memset(el, 0, sizeof(*el));
 571        el->src = src;
 572        return el;
 573}
 574
 575/*
 576 * Used to set up core.excludesfile and .git/info/exclude lists.
 577 */
 578void add_excludes_from_file(struct dir_struct *dir, const char *fname)
 579{
 580        struct exclude_list *el;
 581        el = add_exclude_list(dir, EXC_FILE, fname);
 582        if (add_excludes_from_file_to_list(fname, "", 0, el, 0) < 0)
 583                die("cannot use %s as an exclude file", fname);
 584}
 585
 586int match_basename(const char *basename, int basenamelen,
 587                   const char *pattern, int prefix, int patternlen,
 588                   int flags)
 589{
 590        if (prefix == patternlen) {
 591                if (patternlen == basenamelen &&
 592                    !strncmp_icase(pattern, basename, basenamelen))
 593                        return 1;
 594        } else if (flags & EXC_FLAG_ENDSWITH) {
 595                /* "*literal" matching against "fooliteral" */
 596                if (patternlen - 1 <= basenamelen &&
 597                    !strncmp_icase(pattern + 1,
 598                                   basename + basenamelen - (patternlen - 1),
 599                                   patternlen - 1))
 600                        return 1;
 601        } else {
 602                if (fnmatch_icase_mem(pattern, patternlen,
 603                                      basename, basenamelen,
 604                                      0) == 0)
 605                        return 1;
 606        }
 607        return 0;
 608}
 609
 610int match_pathname(const char *pathname, int pathlen,
 611                   const char *base, int baselen,
 612                   const char *pattern, int prefix, int patternlen,
 613                   int flags)
 614{
 615        const char *name;
 616        int namelen;
 617
 618        /*
 619         * match with FNM_PATHNAME; the pattern has base implicitly
 620         * in front of it.
 621         */
 622        if (*pattern == '/') {
 623                pattern++;
 624                patternlen--;
 625                prefix--;
 626        }
 627
 628        /*
 629         * baselen does not count the trailing slash. base[] may or
 630         * may not end with a trailing slash though.
 631         */
 632        if (pathlen < baselen + 1 ||
 633            (baselen && pathname[baselen] != '/') ||
 634            strncmp_icase(pathname, base, baselen))
 635                return 0;
 636
 637        namelen = baselen ? pathlen - baselen - 1 : pathlen;
 638        name = pathname + pathlen - namelen;
 639
 640        if (prefix) {
 641                /*
 642                 * if the non-wildcard part is longer than the
 643                 * remaining pathname, surely it cannot match.
 644                 */
 645                if (prefix > namelen)
 646                        return 0;
 647
 648                if (strncmp_icase(pattern, name, prefix))
 649                        return 0;
 650                pattern += prefix;
 651                patternlen -= prefix;
 652                name    += prefix;
 653                namelen -= prefix;
 654
 655                /*
 656                 * If the whole pattern did not have a wildcard,
 657                 * then our prefix match is all we need; we
 658                 * do not need to call fnmatch at all.
 659                 */
 660                if (!patternlen && !namelen)
 661                        return 1;
 662        }
 663
 664        return fnmatch_icase_mem(pattern, patternlen,
 665                                 name, namelen,
 666                                 WM_PATHNAME) == 0;
 667}
 668
 669/*
 670 * Scan the given exclude list in reverse to see whether pathname
 671 * should be ignored.  The first match (i.e. the last on the list), if
 672 * any, determines the fate.  Returns the exclude_list element which
 673 * matched, or NULL for undecided.
 674 */
 675static struct exclude *last_exclude_matching_from_list(const char *pathname,
 676                                                       int pathlen,
 677                                                       const char *basename,
 678                                                       int *dtype,
 679                                                       struct exclude_list *el)
 680{
 681        int i;
 682
 683        if (!el->nr)
 684                return NULL;    /* undefined */
 685
 686        for (i = el->nr - 1; 0 <= i; i--) {
 687                struct exclude *x = el->excludes[i];
 688                const char *exclude = x->pattern;
 689                int prefix = x->nowildcardlen;
 690
 691                if (x->flags & EXC_FLAG_MUSTBEDIR) {
 692                        if (*dtype == DT_UNKNOWN)
 693                                *dtype = get_dtype(NULL, pathname, pathlen);
 694                        if (*dtype != DT_DIR)
 695                                continue;
 696                }
 697
 698                if (x->flags & EXC_FLAG_NODIR) {
 699                        if (match_basename(basename,
 700                                           pathlen - (basename - pathname),
 701                                           exclude, prefix, x->patternlen,
 702                                           x->flags))
 703                                return x;
 704                        continue;
 705                }
 706
 707                assert(x->baselen == 0 || x->base[x->baselen - 1] == '/');
 708                if (match_pathname(pathname, pathlen,
 709                                   x->base, x->baselen ? x->baselen - 1 : 0,
 710                                   exclude, prefix, x->patternlen, x->flags))
 711                        return x;
 712        }
 713        return NULL; /* undecided */
 714}
 715
 716/*
 717 * Scan the list and let the last match determine the fate.
 718 * Return 1 for exclude, 0 for include and -1 for undecided.
 719 */
 720int is_excluded_from_list(const char *pathname,
 721                          int pathlen, const char *basename, int *dtype,
 722                          struct exclude_list *el)
 723{
 724        struct exclude *exclude;
 725        exclude = last_exclude_matching_from_list(pathname, pathlen, basename, dtype, el);
 726        if (exclude)
 727                return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
 728        return -1; /* undecided */
 729}
 730
 731static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir,
 732                const char *pathname, int pathlen, const char *basename,
 733                int *dtype_p)
 734{
 735        int i, j;
 736        struct exclude_list_group *group;
 737        struct exclude *exclude;
 738        for (i = EXC_CMDL; i <= EXC_FILE; i++) {
 739                group = &dir->exclude_list_group[i];
 740                for (j = group->nr - 1; j >= 0; j--) {
 741                        exclude = last_exclude_matching_from_list(
 742                                pathname, pathlen, basename, dtype_p,
 743                                &group->el[j]);
 744                        if (exclude)
 745                                return exclude;
 746                }
 747        }
 748        return NULL;
 749}
 750
 751/*
 752 * Loads the per-directory exclude list for the substring of base
 753 * which has a char length of baselen.
 754 */
 755static void prep_exclude(struct dir_struct *dir, const char *base, int baselen)
 756{
 757        struct exclude_list_group *group;
 758        struct exclude_list *el;
 759        struct exclude_stack *stk = NULL;
 760        int current;
 761
 762        group = &dir->exclude_list_group[EXC_DIRS];
 763
 764        /* Pop the exclude lists from the EXCL_DIRS exclude_list_group
 765         * which originate from directories not in the prefix of the
 766         * path being checked. */
 767        while ((stk = dir->exclude_stack) != NULL) {
 768                if (stk->baselen <= baselen &&
 769                    !strncmp(dir->basebuf, base, stk->baselen))
 770                        break;
 771                el = &group->el[dir->exclude_stack->exclude_ix];
 772                dir->exclude_stack = stk->prev;
 773                dir->exclude = NULL;
 774                free((char *)el->src); /* see strdup() below */
 775                clear_exclude_list(el);
 776                free(stk);
 777                group->nr--;
 778        }
 779
 780        /* Skip traversing into sub directories if the parent is excluded */
 781        if (dir->exclude)
 782                return;
 783
 784        /* Read from the parent directories and push them down. */
 785        current = stk ? stk->baselen : -1;
 786        while (current < baselen) {
 787                struct exclude_stack *stk = xcalloc(1, sizeof(*stk));
 788                const char *cp;
 789
 790                if (current < 0) {
 791                        cp = base;
 792                        current = 0;
 793                }
 794                else {
 795                        cp = strchr(base + current + 1, '/');
 796                        if (!cp)
 797                                die("oops in prep_exclude");
 798                        cp++;
 799                }
 800                stk->prev = dir->exclude_stack;
 801                stk->baselen = cp - base;
 802                stk->exclude_ix = group->nr;
 803                el = add_exclude_list(dir, EXC_DIRS, NULL);
 804                memcpy(dir->basebuf + current, base + current,
 805                       stk->baselen - current);
 806
 807                /* Abort if the directory is excluded */
 808                if (stk->baselen) {
 809                        int dt = DT_DIR;
 810                        dir->basebuf[stk->baselen - 1] = 0;
 811                        dir->exclude = last_exclude_matching_from_lists(dir,
 812                                dir->basebuf, stk->baselen - 1,
 813                                dir->basebuf + current, &dt);
 814                        dir->basebuf[stk->baselen - 1] = '/';
 815                        if (dir->exclude &&
 816                            dir->exclude->flags & EXC_FLAG_NEGATIVE)
 817                                dir->exclude = NULL;
 818                        if (dir->exclude) {
 819                                dir->basebuf[stk->baselen] = 0;
 820                                dir->exclude_stack = stk;
 821                                return;
 822                        }
 823                }
 824
 825                /* Try to read per-directory file unless path is too long */
 826                if (dir->exclude_per_dir &&
 827                    stk->baselen + strlen(dir->exclude_per_dir) < PATH_MAX) {
 828                        strcpy(dir->basebuf + stk->baselen,
 829                                        dir->exclude_per_dir);
 830                        /*
 831                         * dir->basebuf gets reused by the traversal, but we
 832                         * need fname to remain unchanged to ensure the src
 833                         * member of each struct exclude correctly
 834                         * back-references its source file.  Other invocations
 835                         * of add_exclude_list provide stable strings, so we
 836                         * strdup() and free() here in the caller.
 837                         */
 838                        el->src = strdup(dir->basebuf);
 839                        add_excludes_from_file_to_list(dir->basebuf,
 840                                        dir->basebuf, stk->baselen, el, 1);
 841                }
 842                dir->exclude_stack = stk;
 843                current = stk->baselen;
 844        }
 845        dir->basebuf[baselen] = '\0';
 846}
 847
 848/*
 849 * Loads the exclude lists for the directory containing pathname, then
 850 * scans all exclude lists to determine whether pathname is excluded.
 851 * Returns the exclude_list element which matched, or NULL for
 852 * undecided.
 853 */
 854struct exclude *last_exclude_matching(struct dir_struct *dir,
 855                                             const char *pathname,
 856                                             int *dtype_p)
 857{
 858        int pathlen = strlen(pathname);
 859        const char *basename = strrchr(pathname, '/');
 860        basename = (basename) ? basename+1 : pathname;
 861
 862        prep_exclude(dir, pathname, basename-pathname);
 863
 864        if (dir->exclude)
 865                return dir->exclude;
 866
 867        return last_exclude_matching_from_lists(dir, pathname, pathlen,
 868                        basename, dtype_p);
 869}
 870
 871/*
 872 * Loads the exclude lists for the directory containing pathname, then
 873 * scans all exclude lists to determine whether pathname is excluded.
 874 * Returns 1 if true, otherwise 0.
 875 */
 876int is_excluded(struct dir_struct *dir, const char *pathname, int *dtype_p)
 877{
 878        struct exclude *exclude =
 879                last_exclude_matching(dir, pathname, dtype_p);
 880        if (exclude)
 881                return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1;
 882        return 0;
 883}
 884
 885static struct dir_entry *dir_entry_new(const char *pathname, int len)
 886{
 887        struct dir_entry *ent;
 888
 889        ent = xmalloc(sizeof(*ent) + len + 1);
 890        ent->len = len;
 891        memcpy(ent->name, pathname, len);
 892        ent->name[len] = 0;
 893        return ent;
 894}
 895
 896static struct dir_entry *dir_add_name(struct dir_struct *dir, const char *pathname, int len)
 897{
 898        if (cache_file_exists(pathname, len, ignore_case))
 899                return NULL;
 900
 901        ALLOC_GROW(dir->entries, dir->nr+1, dir->alloc);
 902        return dir->entries[dir->nr++] = dir_entry_new(pathname, len);
 903}
 904
 905struct dir_entry *dir_add_ignored(struct dir_struct *dir, const char *pathname, int len)
 906{
 907        if (!cache_name_is_other(pathname, len))
 908                return NULL;
 909
 910        ALLOC_GROW(dir->ignored, dir->ignored_nr+1, dir->ignored_alloc);
 911        return dir->ignored[dir->ignored_nr++] = dir_entry_new(pathname, len);
 912}
 913
 914enum exist_status {
 915        index_nonexistent = 0,
 916        index_directory,
 917        index_gitdir
 918};
 919
 920/*
 921 * Do not use the alphabetically sorted index to look up
 922 * the directory name; instead, use the case insensitive
 923 * directory hash.
 924 */
 925static enum exist_status directory_exists_in_index_icase(const char *dirname, int len)
 926{
 927        const struct cache_entry *ce = cache_dir_exists(dirname, len);
 928        unsigned char endchar;
 929
 930        if (!ce)
 931                return index_nonexistent;
 932        endchar = ce->name[len];
 933
 934        /*
 935         * The cache_entry structure returned will contain this dirname
 936         * and possibly additional path components.
 937         */
 938        if (endchar == '/')
 939                return index_directory;
 940
 941        /*
 942         * If there are no additional path components, then this cache_entry
 943         * represents a submodule.  Submodules, despite being directories,
 944         * are stored in the cache without a closing slash.
 945         */
 946        if (!endchar && S_ISGITLINK(ce->ce_mode))
 947                return index_gitdir;
 948
 949        /* This should never be hit, but it exists just in case. */
 950        return index_nonexistent;
 951}
 952
 953/*
 954 * The index sorts alphabetically by entry name, which
 955 * means that a gitlink sorts as '\0' at the end, while
 956 * a directory (which is defined not as an entry, but as
 957 * the files it contains) will sort with the '/' at the
 958 * end.
 959 */
 960static enum exist_status directory_exists_in_index(const char *dirname, int len)
 961{
 962        int pos;
 963
 964        if (ignore_case)
 965                return directory_exists_in_index_icase(dirname, len);
 966
 967        pos = cache_name_pos(dirname, len);
 968        if (pos < 0)
 969                pos = -pos-1;
 970        while (pos < active_nr) {
 971                const struct cache_entry *ce = active_cache[pos++];
 972                unsigned char endchar;
 973
 974                if (strncmp(ce->name, dirname, len))
 975                        break;
 976                endchar = ce->name[len];
 977                if (endchar > '/')
 978                        break;
 979                if (endchar == '/')
 980                        return index_directory;
 981                if (!endchar && S_ISGITLINK(ce->ce_mode))
 982                        return index_gitdir;
 983        }
 984        return index_nonexistent;
 985}
 986
 987/*
 988 * When we find a directory when traversing the filesystem, we
 989 * have three distinct cases:
 990 *
 991 *  - ignore it
 992 *  - see it as a directory
 993 *  - recurse into it
 994 *
 995 * and which one we choose depends on a combination of existing
 996 * git index contents and the flags passed into the directory
 997 * traversal routine.
 998 *
 999 * Case 1: If we *already* have entries in the index under that
1000 * directory name, we always recurse into the directory to see
1001 * all the files.
1002 *
1003 * Case 2: If we *already* have that directory name as a gitlink,
1004 * we always continue to see it as a gitlink, regardless of whether
1005 * there is an actual git directory there or not (it might not
1006 * be checked out as a subproject!)
1007 *
1008 * Case 3: if we didn't have it in the index previously, we
1009 * have a few sub-cases:
1010 *
1011 *  (a) if "show_other_directories" is true, we show it as
1012 *      just a directory, unless "hide_empty_directories" is
1013 *      also true, in which case we need to check if it contains any
1014 *      untracked and / or ignored files.
1015 *  (b) if it looks like a git directory, and we don't have
1016 *      'no_gitlinks' set we treat it as a gitlink, and show it
1017 *      as a directory.
1018 *  (c) otherwise, we recurse into it.
1019 */
1020static enum path_treatment treat_directory(struct dir_struct *dir,
1021        const char *dirname, int len, int exclude,
1022        const struct path_simplify *simplify)
1023{
1024        /* The "len-1" is to strip the final '/' */
1025        switch (directory_exists_in_index(dirname, len-1)) {
1026        case index_directory:
1027                return path_recurse;
1028
1029        case index_gitdir:
1030                return path_none;
1031
1032        case index_nonexistent:
1033                if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES)
1034                        break;
1035                if (!(dir->flags & DIR_NO_GITLINKS)) {
1036                        unsigned char sha1[20];
1037                        if (resolve_gitlink_ref(dirname, "HEAD", sha1) == 0)
1038                                return path_untracked;
1039                }
1040                return path_recurse;
1041        }
1042
1043        /* This is the "show_other_directories" case */
1044
1045        if (!(dir->flags & DIR_HIDE_EMPTY_DIRECTORIES))
1046                return exclude ? path_excluded : path_untracked;
1047
1048        return read_directory_recursive(dir, dirname, len, 1, simplify);
1049}
1050
1051/*
1052 * This is an inexact early pruning of any recursive directory
1053 * reading - if the path cannot possibly be in the pathspec,
1054 * return true, and we'll skip it early.
1055 */
1056static int simplify_away(const char *path, int pathlen, const struct path_simplify *simplify)
1057{
1058        if (simplify) {
1059                for (;;) {
1060                        const char *match = simplify->path;
1061                        int len = simplify->len;
1062
1063                        if (!match)
1064                                break;
1065                        if (len > pathlen)
1066                                len = pathlen;
1067                        if (!memcmp(path, match, len))
1068                                return 0;
1069                        simplify++;
1070                }
1071                return 1;
1072        }
1073        return 0;
1074}
1075
1076/*
1077 * This function tells us whether an excluded path matches a
1078 * list of "interesting" pathspecs. That is, whether a path matched
1079 * by any of the pathspecs could possibly be ignored by excluding
1080 * the specified path. This can happen if:
1081 *
1082 *   1. the path is mentioned explicitly in the pathspec
1083 *
1084 *   2. the path is a directory prefix of some element in the
1085 *      pathspec
1086 */
1087static int exclude_matches_pathspec(const char *path, int len,
1088                const struct path_simplify *simplify)
1089{
1090        if (simplify) {
1091                for (; simplify->path; simplify++) {
1092                        if (len == simplify->len
1093                            && !memcmp(path, simplify->path, len))
1094                                return 1;
1095                        if (len < simplify->len
1096                            && simplify->path[len] == '/'
1097                            && !memcmp(path, simplify->path, len))
1098                                return 1;
1099                }
1100        }
1101        return 0;
1102}
1103
1104static int get_index_dtype(const char *path, int len)
1105{
1106        int pos;
1107        const struct cache_entry *ce;
1108
1109        ce = cache_file_exists(path, len, 0);
1110        if (ce) {
1111                if (!ce_uptodate(ce))
1112                        return DT_UNKNOWN;
1113                if (S_ISGITLINK(ce->ce_mode))
1114                        return DT_DIR;
1115                /*
1116                 * Nobody actually cares about the
1117                 * difference between DT_LNK and DT_REG
1118                 */
1119                return DT_REG;
1120        }
1121
1122        /* Try to look it up as a directory */
1123        pos = cache_name_pos(path, len);
1124        if (pos >= 0)
1125                return DT_UNKNOWN;
1126        pos = -pos-1;
1127        while (pos < active_nr) {
1128                ce = active_cache[pos++];
1129                if (strncmp(ce->name, path, len))
1130                        break;
1131                if (ce->name[len] > '/')
1132                        break;
1133                if (ce->name[len] < '/')
1134                        continue;
1135                if (!ce_uptodate(ce))
1136                        break;  /* continue? */
1137                return DT_DIR;
1138        }
1139        return DT_UNKNOWN;
1140}
1141
1142static int get_dtype(struct dirent *de, const char *path, int len)
1143{
1144        int dtype = de ? DTYPE(de) : DT_UNKNOWN;
1145        struct stat st;
1146
1147        if (dtype != DT_UNKNOWN)
1148                return dtype;
1149        dtype = get_index_dtype(path, len);
1150        if (dtype != DT_UNKNOWN)
1151                return dtype;
1152        if (lstat(path, &st))
1153                return dtype;
1154        if (S_ISREG(st.st_mode))
1155                return DT_REG;
1156        if (S_ISDIR(st.st_mode))
1157                return DT_DIR;
1158        if (S_ISLNK(st.st_mode))
1159                return DT_LNK;
1160        return dtype;
1161}
1162
1163static enum path_treatment treat_one_path(struct dir_struct *dir,
1164                                          struct strbuf *path,
1165                                          const struct path_simplify *simplify,
1166                                          int dtype, struct dirent *de)
1167{
1168        int exclude;
1169        int has_path_in_index = !!cache_file_exists(path->buf, path->len, ignore_case);
1170
1171        if (dtype == DT_UNKNOWN)
1172                dtype = get_dtype(de, path->buf, path->len);
1173
1174        /* Always exclude indexed files */
1175        if (dtype != DT_DIR && has_path_in_index)
1176                return path_none;
1177
1178        /*
1179         * When we are looking at a directory P in the working tree,
1180         * there are three cases:
1181         *
1182         * (1) P exists in the index.  Everything inside the directory P in
1183         * the working tree needs to go when P is checked out from the
1184         * index.
1185         *
1186         * (2) P does not exist in the index, but there is P/Q in the index.
1187         * We know P will stay a directory when we check out the contents
1188         * of the index, but we do not know yet if there is a directory
1189         * P/Q in the working tree to be killed, so we need to recurse.
1190         *
1191         * (3) P does not exist in the index, and there is no P/Q in the index
1192         * to require P to be a directory, either.  Only in this case, we
1193         * know that everything inside P will not be killed without
1194         * recursing.
1195         */
1196        if ((dir->flags & DIR_COLLECT_KILLED_ONLY) &&
1197            (dtype == DT_DIR) &&
1198            !has_path_in_index &&
1199            (directory_exists_in_index(path->buf, path->len) == index_nonexistent))
1200                return path_none;
1201
1202        exclude = is_excluded(dir, path->buf, &dtype);
1203
1204        /*
1205         * Excluded? If we don't explicitly want to show
1206         * ignored files, ignore it
1207         */
1208        if (exclude && !(dir->flags & (DIR_SHOW_IGNORED|DIR_SHOW_IGNORED_TOO)))
1209                return path_excluded;
1210
1211        switch (dtype) {
1212        default:
1213                return path_none;
1214        case DT_DIR:
1215                strbuf_addch(path, '/');
1216                return treat_directory(dir, path->buf, path->len, exclude,
1217                        simplify);
1218        case DT_REG:
1219        case DT_LNK:
1220                return exclude ? path_excluded : path_untracked;
1221        }
1222}
1223
1224static enum path_treatment treat_path(struct dir_struct *dir,
1225                                      struct dirent *de,
1226                                      struct strbuf *path,
1227                                      int baselen,
1228                                      const struct path_simplify *simplify)
1229{
1230        int dtype;
1231
1232        if (is_dot_or_dotdot(de->d_name) || !strcmp(de->d_name, ".git"))
1233                return path_none;
1234        strbuf_setlen(path, baselen);
1235        strbuf_addstr(path, de->d_name);
1236        if (simplify_away(path->buf, path->len, simplify))
1237                return path_none;
1238
1239        dtype = DTYPE(de);
1240        return treat_one_path(dir, path, simplify, dtype, de);
1241}
1242
1243/*
1244 * Read a directory tree. We currently ignore anything but
1245 * directories, regular files and symlinks. That's because git
1246 * doesn't handle them at all yet. Maybe that will change some
1247 * day.
1248 *
1249 * Also, we ignore the name ".git" (even if it is not a directory).
1250 * That likely will not change.
1251 *
1252 * Returns the most significant path_treatment value encountered in the scan.
1253 */
1254static enum path_treatment read_directory_recursive(struct dir_struct *dir,
1255                                    const char *base, int baselen,
1256                                    int check_only,
1257                                    const struct path_simplify *simplify)
1258{
1259        DIR *fdir;
1260        enum path_treatment state, subdir_state, dir_state = path_none;
1261        struct dirent *de;
1262        struct strbuf path = STRBUF_INIT;
1263
1264        strbuf_add(&path, base, baselen);
1265
1266        fdir = opendir(path.len ? path.buf : ".");
1267        if (!fdir)
1268                goto out;
1269
1270        while ((de = readdir(fdir)) != NULL) {
1271                /* check how the file or directory should be treated */
1272                state = treat_path(dir, de, &path, baselen, simplify);
1273                if (state > dir_state)
1274                        dir_state = state;
1275
1276                /* recurse into subdir if instructed by treat_path */
1277                if (state == path_recurse) {
1278                        subdir_state = read_directory_recursive(dir, path.buf,
1279                                path.len, check_only, simplify);
1280                        if (subdir_state > dir_state)
1281                                dir_state = subdir_state;
1282                }
1283
1284                if (check_only) {
1285                        /* abort early if maximum state has been reached */
1286                        if (dir_state == path_untracked)
1287                                break;
1288                        /* skip the dir_add_* part */
1289                        continue;
1290                }
1291
1292                /* add the path to the appropriate result list */
1293                switch (state) {
1294                case path_excluded:
1295                        if (dir->flags & DIR_SHOW_IGNORED)
1296                                dir_add_name(dir, path.buf, path.len);
1297                        else if ((dir->flags & DIR_SHOW_IGNORED_TOO) ||
1298                                ((dir->flags & DIR_COLLECT_IGNORED) &&
1299                                exclude_matches_pathspec(path.buf, path.len,
1300                                        simplify)))
1301                                dir_add_ignored(dir, path.buf, path.len);
1302                        break;
1303
1304                case path_untracked:
1305                        if (!(dir->flags & DIR_SHOW_IGNORED))
1306                                dir_add_name(dir, path.buf, path.len);
1307                        break;
1308
1309                default:
1310                        break;
1311                }
1312        }
1313        closedir(fdir);
1314 out:
1315        strbuf_release(&path);
1316
1317        return dir_state;
1318}
1319
1320static int cmp_name(const void *p1, const void *p2)
1321{
1322        const struct dir_entry *e1 = *(const struct dir_entry **)p1;
1323        const struct dir_entry *e2 = *(const struct dir_entry **)p2;
1324
1325        return cache_name_compare(e1->name, e1->len,
1326                                  e2->name, e2->len);
1327}
1328
1329static struct path_simplify *create_simplify(const char **pathspec)
1330{
1331        int nr, alloc = 0;
1332        struct path_simplify *simplify = NULL;
1333
1334        if (!pathspec)
1335                return NULL;
1336
1337        for (nr = 0 ; ; nr++) {
1338                const char *match;
1339                if (nr >= alloc) {
1340                        alloc = alloc_nr(alloc);
1341                        simplify = xrealloc(simplify, alloc * sizeof(*simplify));
1342                }
1343                match = *pathspec++;
1344                if (!match)
1345                        break;
1346                simplify[nr].path = match;
1347                simplify[nr].len = simple_length(match);
1348        }
1349        simplify[nr].path = NULL;
1350        simplify[nr].len = 0;
1351        return simplify;
1352}
1353
1354static void free_simplify(struct path_simplify *simplify)
1355{
1356        free(simplify);
1357}
1358
1359static int treat_leading_path(struct dir_struct *dir,
1360                              const char *path, int len,
1361                              const struct path_simplify *simplify)
1362{
1363        struct strbuf sb = STRBUF_INIT;
1364        int baselen, rc = 0;
1365        const char *cp;
1366        int old_flags = dir->flags;
1367
1368        while (len && path[len - 1] == '/')
1369                len--;
1370        if (!len)
1371                return 1;
1372        baselen = 0;
1373        dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES;
1374        while (1) {
1375                cp = path + baselen + !!baselen;
1376                cp = memchr(cp, '/', path + len - cp);
1377                if (!cp)
1378                        baselen = len;
1379                else
1380                        baselen = cp - path;
1381                strbuf_setlen(&sb, 0);
1382                strbuf_add(&sb, path, baselen);
1383                if (!is_directory(sb.buf))
1384                        break;
1385                if (simplify_away(sb.buf, sb.len, simplify))
1386                        break;
1387                if (treat_one_path(dir, &sb, simplify,
1388                                   DT_DIR, NULL) == path_none)
1389                        break; /* do not recurse into it */
1390                if (len <= baselen) {
1391                        rc = 1;
1392                        break; /* finished checking */
1393                }
1394        }
1395        strbuf_release(&sb);
1396        dir->flags = old_flags;
1397        return rc;
1398}
1399
1400int read_directory(struct dir_struct *dir, const char *path, int len, const struct pathspec *pathspec)
1401{
1402        struct path_simplify *simplify;
1403
1404        /*
1405         * Check out create_simplify()
1406         */
1407        if (pathspec)
1408                GUARD_PATHSPEC(pathspec,
1409                               PATHSPEC_FROMTOP |
1410                               PATHSPEC_MAXDEPTH |
1411                               PATHSPEC_LITERAL |
1412                               PATHSPEC_GLOB |
1413                               PATHSPEC_ICASE |
1414                               PATHSPEC_EXCLUDE);
1415
1416        if (has_symlink_leading_path(path, len))
1417                return dir->nr;
1418
1419        /*
1420         * exclude patterns are treated like positive ones in
1421         * create_simplify. Usually exclude patterns should be a
1422         * subset of positive ones, which has no impacts on
1423         * create_simplify().
1424         */
1425        simplify = create_simplify(pathspec ? pathspec->_raw : NULL);
1426        if (!len || treat_leading_path(dir, path, len, simplify))
1427                read_directory_recursive(dir, path, len, 0, simplify);
1428        free_simplify(simplify);
1429        qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);
1430        qsort(dir->ignored, dir->ignored_nr, sizeof(struct dir_entry *), cmp_name);
1431        return dir->nr;
1432}
1433
1434int file_exists(const char *f)
1435{
1436        struct stat sb;
1437        return lstat(f, &sb) == 0;
1438}
1439
1440/*
1441 * Given two normalized paths (a trailing slash is ok), if subdir is
1442 * outside dir, return -1.  Otherwise return the offset in subdir that
1443 * can be used as relative path to dir.
1444 */
1445int dir_inside_of(const char *subdir, const char *dir)
1446{
1447        int offset = 0;
1448
1449        assert(dir && subdir && *dir && *subdir);
1450
1451        while (*dir && *subdir && *dir == *subdir) {
1452                dir++;
1453                subdir++;
1454                offset++;
1455        }
1456
1457        /* hel[p]/me vs hel[l]/yeah */
1458        if (*dir && *subdir)
1459                return -1;
1460
1461        if (!*subdir)
1462                return !*dir ? offset : -1; /* same dir */
1463
1464        /* foo/[b]ar vs foo/[] */
1465        if (is_dir_sep(dir[-1]))
1466                return is_dir_sep(subdir[-1]) ? offset : -1;
1467
1468        /* foo[/]bar vs foo[] */
1469        return is_dir_sep(*subdir) ? offset + 1 : -1;
1470}
1471
1472int is_inside_dir(const char *dir)
1473{
1474        char cwd[PATH_MAX];
1475        if (!dir)
1476                return 0;
1477        if (!getcwd(cwd, sizeof(cwd)))
1478                die_errno("can't find the current directory");
1479        return dir_inside_of(cwd, dir) >= 0;
1480}
1481
1482int is_empty_dir(const char *path)
1483{
1484        DIR *dir = opendir(path);
1485        struct dirent *e;
1486        int ret = 1;
1487
1488        if (!dir)
1489                return 0;
1490
1491        while ((e = readdir(dir)) != NULL)
1492                if (!is_dot_or_dotdot(e->d_name)) {
1493                        ret = 0;
1494                        break;
1495                }
1496
1497        closedir(dir);
1498        return ret;
1499}
1500
1501static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up)
1502{
1503        DIR *dir;
1504        struct dirent *e;
1505        int ret = 0, original_len = path->len, len, kept_down = 0;
1506        int only_empty = (flag & REMOVE_DIR_EMPTY_ONLY);
1507        int keep_toplevel = (flag & REMOVE_DIR_KEEP_TOPLEVEL);
1508        unsigned char submodule_head[20];
1509
1510        if ((flag & REMOVE_DIR_KEEP_NESTED_GIT) &&
1511            !resolve_gitlink_ref(path->buf, "HEAD", submodule_head)) {
1512                /* Do not descend and nuke a nested git work tree. */
1513                if (kept_up)
1514                        *kept_up = 1;
1515                return 0;
1516        }
1517
1518        flag &= ~REMOVE_DIR_KEEP_TOPLEVEL;
1519        dir = opendir(path->buf);
1520        if (!dir) {
1521                if (errno == ENOENT)
1522                        return keep_toplevel ? -1 : 0;
1523                else if (errno == EACCES && !keep_toplevel)
1524                        /*
1525                         * An empty dir could be removable even if it
1526                         * is unreadable:
1527                         */
1528                        return rmdir(path->buf);
1529                else
1530                        return -1;
1531        }
1532        if (path->buf[original_len - 1] != '/')
1533                strbuf_addch(path, '/');
1534
1535        len = path->len;
1536        while ((e = readdir(dir)) != NULL) {
1537                struct stat st;
1538                if (is_dot_or_dotdot(e->d_name))
1539                        continue;
1540
1541                strbuf_setlen(path, len);
1542                strbuf_addstr(path, e->d_name);
1543                if (lstat(path->buf, &st)) {
1544                        if (errno == ENOENT)
1545                                /*
1546                                 * file disappeared, which is what we
1547                                 * wanted anyway
1548                                 */
1549                                continue;
1550                        /* fall thru */
1551                } else if (S_ISDIR(st.st_mode)) {
1552                        if (!remove_dir_recurse(path, flag, &kept_down))
1553                                continue; /* happy */
1554                } else if (!only_empty &&
1555                           (!unlink(path->buf) || errno == ENOENT)) {
1556                        continue; /* happy, too */
1557                }
1558
1559                /* path too long, stat fails, or non-directory still exists */
1560                ret = -1;
1561                break;
1562        }
1563        closedir(dir);
1564
1565        strbuf_setlen(path, original_len);
1566        if (!ret && !keep_toplevel && !kept_down)
1567                ret = (!rmdir(path->buf) || errno == ENOENT) ? 0 : -1;
1568        else if (kept_up)
1569                /*
1570                 * report the uplevel that it is not an error that we
1571                 * did not rmdir() our directory.
1572                 */
1573                *kept_up = !ret;
1574        return ret;
1575}
1576
1577int remove_dir_recursively(struct strbuf *path, int flag)
1578{
1579        return remove_dir_recurse(path, flag, NULL);
1580}
1581
1582void setup_standard_excludes(struct dir_struct *dir)
1583{
1584        const char *path;
1585        char *xdg_path;
1586
1587        dir->exclude_per_dir = ".gitignore";
1588        path = git_path("info/exclude");
1589        if (!excludes_file) {
1590                home_config_paths(NULL, &xdg_path, "ignore");
1591                excludes_file = xdg_path;
1592        }
1593        if (!access_or_warn(path, R_OK, 0))
1594                add_excludes_from_file(dir, path);
1595        if (excludes_file && !access_or_warn(excludes_file, R_OK, 0))
1596                add_excludes_from_file(dir, excludes_file);
1597}
1598
1599int remove_path(const char *name)
1600{
1601        char *slash;
1602
1603        if (unlink(name) && errno != ENOENT && errno != ENOTDIR)
1604                return -1;
1605
1606        slash = strrchr(name, '/');
1607        if (slash) {
1608                char *dirs = xstrdup(name);
1609                slash = dirs + (slash - name);
1610                do {
1611                        *slash = '\0';
1612                } while (rmdir(dirs) == 0 && (slash = strrchr(dirs, '/')));
1613                free(dirs);
1614        }
1615        return 0;
1616}
1617
1618/*
1619 * Frees memory within dir which was allocated for exclude lists and
1620 * the exclude_stack.  Does not free dir itself.
1621 */
1622void clear_directory(struct dir_struct *dir)
1623{
1624        int i, j;
1625        struct exclude_list_group *group;
1626        struct exclude_list *el;
1627        struct exclude_stack *stk;
1628
1629        for (i = EXC_CMDL; i <= EXC_FILE; i++) {
1630                group = &dir->exclude_list_group[i];
1631                for (j = 0; j < group->nr; j++) {
1632                        el = &group->el[j];
1633                        if (i == EXC_DIRS)
1634                                free((char *)el->src);
1635                        clear_exclude_list(el);
1636                }
1637                free(group->el);
1638        }
1639
1640        stk = dir->exclude_stack;
1641        while (stk) {
1642                struct exclude_stack *prev = stk->prev;
1643                free(stk);
1644                stk = prev;
1645        }
1646}