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