/* Traverse a file hierarchy.

   Copyright (C) 2004-2017 Free Software Foundation, Inc.

   This program is free software: you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

/*-

 * Copyright (c) 1990, 1993, 1994

 *      The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS" AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include <config.h>

#if defined LIBC_SCCS && !defined GCC_LINT && !defined lint

static char sccsid[] = "@(#)fts.c       8.6 (Berkeley) 8/14/94";

#endif

#include "fts_.h"

#if HAVE_SYS_PARAM_H || defined _LIBC

# include <sys/param.h>

#endif

#ifdef _LIBC

# include <include/sys/stat.h>

#else

# include <sys/stat.h>

#endif

#include <fcntl.h>

#include <errno.h>

#include <stdalign.h>

#include <stdbool.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#if ! _LIBC

# include "fcntl--.h"

# include "dirent--.h"

# include "unistd--.h"

/* FIXME - use fcntl(F_DUPFD_CLOEXEC)/openat(O_CLOEXEC) once they are

   supported.  */

# include "cloexec.h"

# include "flexmember.h"

# include "openat.h"

# include "same-inode.h"

#endif

#include <dirent.h>

#ifndef _D_EXACT_NAMLEN

# define _D_EXACT_NAMLEN(dirent) strlen ((dirent)->d_name)

#endif

#if HAVE_STRUCT_DIRENT_D_TYPE

/* True if the type of the directory entry D is known.  */

# define DT_IS_KNOWN(d) ((d)->d_type != DT_UNKNOWN)

/* True if the type of the directory entry D must be T.  */

# define DT_MUST_BE(d, t) ((d)->d_type == (t))

# define D_TYPE(d) ((d)->d_type)

#else

# define DT_IS_KNOWN(d) false

# define DT_MUST_BE(d, t) false

# define D_TYPE(d) DT_UNKNOWN

# undef DT_UNKNOWN

# define DT_UNKNOWN 0

/* Any nonzero values will do here, so long as they're distinct.

   Undef any existing macros out of the way.  */

# undef DT_BLK

# undef DT_CHR

# undef DT_DIR

# undef DT_FIFO

# undef DT_LNK

# undef DT_REG

# undef DT_SOCK

# define DT_BLK 1

# define DT_CHR 2

# define DT_DIR 3

# define DT_FIFO 4

# define DT_LNK 5

# define DT_REG 6

# define DT_SOCK 7

#endif

#ifndef S_IFLNK

# define S_IFLNK 0

#endif

#ifndef S_IFSOCK

# define S_IFSOCK 0

#endif

enum

{

  NOT_AN_INODE_NUMBER = 0

};

#ifdef D_INO_IN_DIRENT

# define D_INO(dp) (dp)->d_ino

#else

/* Some systems don't have inodes, so fake them to avoid lots of ifdefs.  */

# define D_INO(dp) NOT_AN_INODE_NUMBER

#endif

/* If possible (see max_entries, below), read no more than this many directory

   entries at a time.  Without this limit (i.e., when using non-NULL

   fts_compar), processing a directory with 4,000,000 entries requires ~1GiB

   of memory, and handling 64M entries would require 16GiB of memory.  */

#ifndef FTS_MAX_READDIR_ENTRIES

# define FTS_MAX_READDIR_ENTRIES 100000

#endif

/* If there are more than this many entries in a directory,

   and the conditions mentioned below are satisfied, then sort

   the entries on inode number before any further processing.  */

#ifndef FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD

# define FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD 10000

#endif

enum

{

  _FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD = FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD

};

enum Fts_stat

{

  FTS_NO_STAT_REQUIRED = 1,

  FTS_STAT_REQUIRED = 2

};

#ifdef _LIBC

# undef close

# define close __close

# undef closedir

# define closedir __closedir

# undef fchdir

# define fchdir __fchdir

# undef open

# define open __open

# undef readdir

# define readdir __readdir

#else

# undef internal_function

# define internal_function /* empty */

#endif

#ifndef __set_errno

# define __set_errno(Val) errno = (Val)

#endif

/* If this host provides the openat function, then we can avoid

   attempting to open "." in some initialization code below.  */

#ifdef HAVE_OPENAT

# define HAVE_OPENAT_SUPPORT 1

#else

# define HAVE_OPENAT_SUPPORT 0

#endif

#ifdef NDEBUG

# define fts_assert(expr) ((void) (0 && (expr)))

#else

# define fts_assert(expr)       \

    do                          \

      {                         \

        if (!(expr))            \

          abort ();             \

      }                         \

    while (false)

#endif

#ifndef FALLTHROUGH

# if __GNUC__ < 7

#  define FALLTHROUGH ((void) 0)

# else

#  define FALLTHROUGH __attribute__ ((__fallthrough__))

# endif

#endif

static FTSENT   *fts_alloc (FTS *, const char *, size_t) internal_function;

static FTSENT   *fts_build (FTS *, int) internal_function;

static void      fts_lfree (FTSENT *) internal_function;

static void      fts_load (FTS *, FTSENT *) internal_function;

static size_t    fts_maxarglen (char * const *) internal_function;

static void      fts_padjust (FTS *, FTSENT *) internal_function;

static bool      fts_palloc (FTS *, size_t) internal_function;

static FTSENT   *fts_sort (FTS *, FTSENT *, size_t) internal_function;

static unsigned short int fts_stat (FTS *, FTSENT *, bool) internal_function;

static int      fts_safe_changedir (FTS *, FTSENT *, int, const char *)

     internal_function;

#include "fts-cycle.c"

#ifndef MAX

# define MAX(a,b) ((a) > (b) ? (a) : (b))

#endif

#ifndef SIZE_MAX

# define SIZE_MAX ((size_t) -1)

#endif

#define ISDOT(a)        (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))

#define STREQ(a, b)     (strcmp (a, b) == 0)

#define CLR(opt)        (sp->fts_options &= ~(opt))

#define ISSET(opt)      (sp->fts_options & (opt))

#define SET(opt)        (sp->fts_options |= (opt))

/* FIXME: FTS_NOCHDIR is now misnamed.

   Call it FTS_USE_FULL_RELATIVE_FILE_NAMES instead. */

#define FCHDIR(sp, fd)                                  \

  (!ISSET(FTS_NOCHDIR) && (ISSET(FTS_CWDFD)             \

                           ? (cwd_advance_fd ((sp), (fd), true), 0) \

                           : fchdir (fd)))

/* fts_build flags */

/* FIXME: make this an enum */

#define BCHILD          1               /* fts_children */

#define BNAMES          2               /* fts_children, names only */

#define BREAD           3               /* fts_read */

#if FTS_DEBUG

# include <inttypes.h>

# include <stdint.h>

# include <stdio.h>

# include "getcwdat.h"

bool fts_debug = false;

# define Dprintf(x) do { if (fts_debug) printf x; } while (false)

#else

# define Dprintf(x)

# define fd_ring_check(x)

# define fd_ring_print(a, b, c)

#endif

#define LEAVE_DIR(Fts, Ent, Tag)                                \

  do                                                            \

    {                                                           \

      Dprintf (("  %s-leaving: %s\n", Tag, (Ent)->fts_path));   \

      leave_dir (Fts, Ent);                                     \

      fd_ring_check (Fts);                                      \

    }                                                           \

  while (false)

static void

fd_ring_clear (I_ring *fd_ring)

{

  while ( ! i_ring_empty (fd_ring))

    {

      int fd = i_ring_pop (fd_ring);

      if (0 <= fd)

        close (fd);

    }

}

/* Overload the fts_statp->st_size member (otherwise unused, when

   fts_info is FTS_NSOK) to indicate whether fts_read should stat

   this entry or not.  */

static void

fts_set_stat_required (FTSENT *p, bool required)

{

  fts_assert (p->fts_info == FTS_NSOK);

  p->fts_statp->st_size = (required

                           ? FTS_STAT_REQUIRED

                           : FTS_NO_STAT_REQUIRED);

}

/* file-descriptor-relative opendir.  */

/* FIXME: if others need this function, move it into lib/openat.c */

static DIR *

internal_function

opendirat (int fd, char const *dir, int extra_flags, int *pdir_fd)

{

  int new_fd = openat (fd, dir,

                       (O_RDONLY | O_DIRECTORY | O_NOCTTY | O_NONBLOCK

                        | extra_flags));

  DIR *dirp;

  if (new_fd < 0)

    return NULL;

  set_cloexec_flag (new_fd, true);

  dirp = fdopendir (new_fd);

  if (dirp)

    *pdir_fd = new_fd;

  else

    {

      int saved_errno = errno;

      close (new_fd);

      errno = saved_errno;

    }

  return dirp;

}

/* Virtual fchdir.  Advance SP's working directory file descriptor,

   SP->fts_cwd_fd, to FD, and push the previous value onto the fd_ring.

   CHDIR_DOWN_ONE is true if FD corresponds to an entry in the directory

   open on sp->fts_cwd_fd; i.e., to move the working directory one level

   down.  */

static void

internal_function

cwd_advance_fd (FTS *sp, int fd, bool chdir_down_one)

{

  int old = sp->fts_cwd_fd;

  fts_assert (old != fd || old == AT_FDCWD);

  if (chdir_down_one)

    {

      /* Push "old" onto the ring.

         If the displaced file descriptor is non-negative, close it.  */

      int prev_fd_in_slot = i_ring_push (&sp->fts_fd_ring, old);

      fd_ring_print (sp, stderr, "post-push");

      if (0 <= prev_fd_in_slot)

        close (prev_fd_in_slot); /* ignore any close failure */

    }

  else if ( ! ISSET (FTS_NOCHDIR))

    {

      if (0 <= old)

        close (old); /* ignore any close failure */

    }

  sp->fts_cwd_fd = fd;

}

/* Restore the initial, pre-traversal, "working directory".

   In FTS_CWDFD mode, we merely call cwd_advance_fd, otherwise,

   we may actually change the working directory.

   Return 0 upon success. Upon failure, set errno and return nonzero.  */

static int

restore_initial_cwd (FTS *sp)

{

  int fail = FCHDIR (sp, ISSET (FTS_CWDFD) ? AT_FDCWD : sp->fts_rfd);

  fd_ring_clear (&(sp->fts_fd_ring));

  return fail;

}

/* Open the directory DIR if possible, and return a file

   descriptor.  Return -1 and set errno on failure.  It doesn't matter

   whether the file descriptor has read or write access.  */

static int

internal_function

diropen (FTS const *sp, char const *dir)

{

  int open_flags = (O_SEARCH | O_DIRECTORY | O_NOCTTY | O_NONBLOCK

                    | (ISSET (FTS_PHYSICAL) ? O_NOFOLLOW : 0)

                    | (ISSET (FTS_NOATIME) ? O_NOATIME : 0));

  int fd = (ISSET (FTS_CWDFD)

            ? openat (sp->fts_cwd_fd, dir, open_flags)

            : open (dir, open_flags));

  if (0 <= fd)

    set_cloexec_flag (fd, true);

  return fd;

}

FTS *

fts_open (char * const *argv,

          register int options,

          int (*compar) (FTSENT const **, FTSENT const **))

{

        register FTS *sp;

        register FTSENT *p, *root;

        register size_t nitems;

        FTSENT *parent = NULL;

        FTSENT *tmp = NULL;     /* pacify gcc */

        bool defer_stat;

        /* Options check. */

        if (options & ~FTS_OPTIONMASK) {

                __set_errno (EINVAL);

                return (NULL);

        }

        if ((options & FTS_NOCHDIR) && (options & FTS_CWDFD)) {

                __set_errno (EINVAL);

                return (NULL);

        }

        if ( ! (options & (FTS_LOGICAL | FTS_PHYSICAL))) {

                __set_errno (EINVAL);

                return (NULL);

        }

        /* Allocate/initialize the stream */

        if ((sp = malloc(sizeof(FTS))) == NULL)

                return (NULL);

        memset(sp, 0, sizeof(FTS));

        sp->fts_compar = compar;

        sp->fts_options = options;

        /* Logical walks turn on NOCHDIR; symbolic links are too hard. */

        if (ISSET(FTS_LOGICAL)) {

                SET(FTS_NOCHDIR);

                CLR(FTS_CWDFD);

        }

        /* Initialize fts_cwd_fd.  */

        sp->fts_cwd_fd = AT_FDCWD;

        if ( ISSET(FTS_CWDFD) && ! HAVE_OPENAT_SUPPORT)

          {

            /* While it isn't technically necessary to open "." this

               early, doing it here saves us the trouble of ensuring

               later (where it'd be messier) that "." can in fact

               be opened.  If not, revert to FTS_NOCHDIR mode.  */

            int fd = open (".",

                           O_SEARCH | (ISSET (FTS_NOATIME) ? O_NOATIME : 0));

            if (fd < 0)

              {

                /* Even if "." is unreadable, don't revert to FTS_NOCHDIR mode

                   on systems like Linux+PROC_FS, where our openat emulation

                   is good enough.  Note: on a system that emulates

                   openat via /proc, this technique can still fail, but

                   only in extreme conditions, e.g., when the working

                   directory cannot be saved (i.e. save_cwd fails) --

                   and that happens on Linux only when "." is unreadable

                   and the CWD would be longer than PATH_MAX.

                   FIXME: once Linux kernel openat support is well established,

                   replace the above open call and this entire if/else block

                   with the body of the if-block below.  */

                if ( openat_needs_fchdir ())

                  {

                    SET(FTS_NOCHDIR);

                    CLR(FTS_CWDFD);

                  }

              }

            else

              {

                close (fd);

              }

          }

        /*

         * Start out with 1K of file name space, and enough, in any case,

         * to hold the user's file names.

         */

#ifndef MAXPATHLEN

# define MAXPATHLEN 1024

#endif

        {

          size_t maxarglen = fts_maxarglen(argv);

          if (! fts_palloc(sp, MAX(maxarglen, MAXPATHLEN)))

                  goto mem1;

        }

        /* Allocate/initialize root's parent. */

        if (*argv != NULL) {

                if ((parent = fts_alloc(sp, "", 0)) == NULL)

                        goto mem2;

                parent->fts_level = FTS_ROOTPARENTLEVEL;

          }

        /* The classic fts implementation would call fts_stat with

           a new entry for each iteration of the loop below.

           If the comparison function is not specified or if the

           FTS_DEFER_STAT option is in effect, don't stat any entry

           in this loop.  This is an attempt to minimize the interval

           between the initial stat/lstat/fstatat and the point at which

           a directory argument is first opened.  This matters for any

           directory command line argument that resides on a file system

           without genuine i-nodes.  If you specify FTS_DEFER_STAT along

           with a comparison function, that function must not access any

           data via the fts_statp pointer.  */

        defer_stat = (compar == NULL || ISSET(FTS_DEFER_STAT));

        /* Allocate/initialize root(s). */

        for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {

                /* *Do* allow zero-length file names. */

                size_t len = strlen(*argv);

                if ( ! (options & FTS_VERBATIM))

                  {

                    /* If there are two or more trailing slashes, trim all but one,

                       but don't change "//" to "/", and do map "///" to "/".  */

                    char const *v = *argv;

                    if (2 < len && v[len - 1] == '/')

                      while (1 < len && v[len - 2] == '/')

                        --len;

                  }

                if ((p = fts_alloc(sp, *argv, len)) == NULL)

                        goto mem3;

                p->fts_level = FTS_ROOTLEVEL;

                p->fts_parent = parent;

                p->fts_accpath = p->fts_name;

                /* Even when defer_stat is true, be sure to stat the first

                   command line argument, since fts_read (at least with

                   FTS_XDEV) requires that.  */

                if (defer_stat && root != NULL) {

                        p->fts_info = FTS_NSOK;

                        fts_set_stat_required(p, true);

                } else {

                        p->fts_info = fts_stat(sp, p, false);

                }

                /*

                 * If comparison routine supplied, traverse in sorted

                 * order; otherwise traverse in the order specified.

                 */

                if (compar) {

                        p->fts_link = root;

                        root = p;

                } else {

                        p->fts_link = NULL;

                        if (root == NULL)

                                tmp = root = p;

                        else {

                                tmp->fts_link = p;

                                tmp = p;

                        }

                }

        }

        if (compar && nitems > 1)

                root = fts_sort(sp, root, nitems);

        /*

         * Allocate a dummy pointer and make fts_read think that we've just

         * finished the node before the root(s); set p->fts_info to FTS_INIT

         * so that everything about the "current" node is ignored.

         */

        if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)

                goto mem3;

        sp->fts_cur->fts_link = root;

        sp->fts_cur->fts_info = FTS_INIT;

        if (! setup_dir (sp))

                goto mem3;

        /*

         * If using chdir(2), grab a file descriptor pointing to dot to ensure

         * that we can get back here; this could be avoided for some file names,

         * but almost certainly not worth the effort.  Slashes, symbolic links,

         * and ".." are all fairly nasty problems.  Note, if we can't get the

         * descriptor we run anyway, just more slowly.

         */

        if (!ISSET(FTS_NOCHDIR) && !ISSET(FTS_CWDFD)

            && (sp->fts_rfd = diropen (sp, ".")) < 0)

                SET(FTS_NOCHDIR);

        i_ring_init (&sp->fts_fd_ring, -1);

        return (sp);

mem3:   fts_lfree(root);

        free(parent);

mem2:   free(sp->fts_path);

mem1:   free(sp);

        return (NULL);

}

static void

internal_function

fts_load (FTS *sp, register FTSENT *p)

{

        register size_t len;

        register char *cp;

        /*

         * Load the stream structure for the next traversal.  Since we don't

         * actually enter the directory until after the preorder visit, set

         * the fts_accpath field specially so the chdir gets done to the right

         * place and the user can access the first node.  From fts_open it's

         * known that the file name will fit.

         */

        len = p->fts_pathlen = p->fts_namelen;

        memmove(sp->fts_path, p->fts_name, len + 1);

        if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {

                len = strlen(++cp);

                memmove(p->fts_name, cp, len + 1);

                p->fts_namelen = len;

        }

        p->fts_accpath = p->fts_path = sp->fts_path;

}

int

fts_close (FTS *sp)

{

        register FTSENT *freep, *p;

        int saved_errno = 0;

        /*

         * This still works if we haven't read anything -- the dummy structure

         * points to the root list, so we step through to the end of the root

         * list which has a valid parent pointer.

         */

        if (sp->fts_cur) {

                for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {

                        freep = p;

                        p = p->fts_link != NULL ? p->fts_link : p->fts_parent;

                        free(freep);

                }

                free(p);

        }

        /* Free up child linked list, sort array, file name buffer. */

        if (sp->fts_child)

                fts_lfree(sp->fts_child);

        free(sp->fts_array);

        free(sp->fts_path);

        if (ISSET(FTS_CWDFD))

          {

            if (0 <= sp->fts_cwd_fd)

              if (close (sp->fts_cwd_fd))

                saved_errno = errno;

          }

        else if (!ISSET(FTS_NOCHDIR))

          {

            /* Return to original directory, save errno if necessary. */

            if (fchdir(sp->fts_rfd))

              saved_errno = errno;

            /* If close fails, record errno only if saved_errno is zero,

               so that we report the probably-more-meaningful fchdir errno.  */

            if (close (sp->fts_rfd))

              if (saved_errno == 0)

                saved_errno = errno;

          }

        fd_ring_clear (&sp->fts_fd_ring);

        if (sp->fts_leaf_optimization_works_ht)

          hash_free (sp->fts_leaf_optimization_works_ht);

        free_dir (sp);

        /* Free up the stream pointer. */

        free(sp);

        /* Set errno and return. */

        if (saved_errno) {

                __set_errno (saved_errno);

                return (-1);

        }

        return (0);

}

#if defined __linux__ \

  && HAVE_SYS_VFS_H && HAVE_FSTATFS && HAVE_STRUCT_STATFS_F_TYPE

# include <sys/vfs.h>

/* Linux-specific constants from coreutils' src/fs.h */

# define S_MAGIC_TMPFS 0x1021994

# define S_MAGIC_NFS 0x6969

# define S_MAGIC_REISERFS 0x52654973

# define S_MAGIC_XFS 0x58465342

# define S_MAGIC_PROC 0x9FA0

/* Return false if it is easy to determine the file system type of

   the directory on which DIR_FD is open, and sorting dirents on

   inode numbers is known not to improve traversal performance with

   that type of file system.  Otherwise, return true.  */

static bool

dirent_inode_sort_may_be_useful (int dir_fd)

{

  /* Skip the sort only if we can determine efficiently

     that skipping it is the right thing to do.

     The cost of performing an unnecessary sort is negligible,

     while the cost of *not* performing it can be O(N^2) with

     a very large constant.  */

  struct statfs fs_buf;

  /* If fstatfs fails, assume sorting would be useful.  */

  if (fstatfs (dir_fd, &fs_buf) != 0)

    return true;

  /* FIXME: what about when f_type is not an integral type?

     deal with that if/when it's encountered.  */

  switch (fs_buf.f_type)

    {

    case S_MAGIC_TMPFS:

    case S_MAGIC_NFS:

      /* On a file system of any of these types, sorting

         is unnecessary, and hence wasteful.  */

      return false;

    default:

      return true;

    }

}

/* Given a file descriptor DIR_FD open on a directory D,

   return true if it is valid to apply the leaf-optimization

   technique of counting directories in D via stat.st_nlink.  */

static bool

leaf_optimization_applies (int dir_fd)

{

  struct statfs fs_buf;

  /* If fstatfs fails, assume we can't use the optimization.  */

  if (fstatfs (dir_fd, &fs_buf) != 0)

    return false;

  /* FIXME: do we need to detect AFS mount points?  I doubt it,

     unless fstatfs can report S_MAGIC_REISERFS for such a directory.  */

  switch (fs_buf.f_type)

    {

      /* List here the file system types that lack usable dirent.d_type

         info, yet for which the optimization does apply.  */

    case S_MAGIC_REISERFS:

    case S_MAGIC_XFS:

      return true;

      /* Explicitly list here any other file system type for which the

         optimization is not applicable, but need documentation.  */

    case S_MAGIC_NFS:

      /* NFS provides usable dirent.d_type but not necessarily for all entries

         of large directories, so as per <https://bugzilla.redhat.com/1252549>

         NFS should return true.  However st_nlink values are not accurate on

         all implementations as per <https://bugzilla.redhat.com/1299169>.  */

      FALLTHROUGH;

    case S_MAGIC_PROC:

      /* Per <http://bugs.debian.org/143111> /proc may have

         bogus stat.st_nlink values.  */

      FALLTHROUGH;

    default:

      return false;

    }

}

#else

static bool

dirent_inode_sort_may_be_useful (int dir_fd _GL_UNUSED) { return true; }

static bool

leaf_optimization_applies (int dir_fd _GL_UNUSED) { return false; }

#endif

/* link-count-optimization entry:

   map a stat.st_dev number to a boolean: leaf_optimization_works */

struct LCO_ent

{

  dev_t st_dev;

  bool opt_ok;

};

/* Use a tiny initial size.  If a traversal encounters more than

   a few devices, the cost of growing/rehashing this table will be

   rendered negligible by the number of inodes processed.  */

enum { LCO_HT_INITIAL_SIZE = 13 };

static size_t

LCO_hash (void const *x, size_t table_size)

{

  struct LCO_ent const *ax = x;

  return (uintmax_t) ax->st_dev % table_size;

}

static bool

LCO_compare (void const *x, void const *y)

{

  struct LCO_ent const *ax = x;

  struct LCO_ent const *ay = y;

  return ax->st_dev == ay->st_dev;

}

/* Ask the same question as leaf_optimization_applies, but query

   the cache first (FTS.fts_leaf_optimization_works_ht), and if necessary,

   update that cache.  */

static bool

link_count_optimize_ok (FTSENT const *p)

{

  FTS *sp = p->fts_fts;

  Hash_table *h = sp->fts_leaf_optimization_works_ht;

  struct LCO_ent tmp;

  struct LCO_ent *ent;

  bool opt_ok;

  struct LCO_ent *t2;

  /* If we're not in CWDFD mode, don't bother with this optimization,

     since the caller is not serious about performance. */

  if (!ISSET(FTS_CWDFD))

    return false;

  /* map st_dev to the boolean, leaf_optimization_works */

  if (h == NULL)

    {

      h = sp->fts_leaf_optimization_works_ht

        = hash_initialize (LCO_HT_INITIAL_SIZE, NULL, LCO_hash,

                           LCO_compare, free);

      if (h == NULL)

        return false;

    }

  tmp.st_dev = p->fts_statp->st_dev;

  ent = hash_lookup (h, &tmp);

  if (ent)

    return ent->opt_ok;

  /* Look-up failed.  Query directly and cache the result.  */

  t2 = malloc (sizeof *t2);

  if (t2 == NULL)

    return false;

  /* Is it ok to perform the optimization in the dir, FTS_CWD_FD?  */

  opt_ok = leaf_optimization_applies (sp->fts_cwd_fd);

  t2->opt_ok = opt_ok;

  t2->st_dev = p->fts_statp->st_dev;

  ent = hash_insert (h, t2);

  if (ent == NULL)

    {

      /* insertion failed */

      free (t2);

      return false;

    }

  fts_assert (ent == t2);

  return opt_ok;

}

/*

 * Special case of "/" at the end of the file name so that slashes aren't

 * appended which would cause file names to be written as "....//foo".

 */

#define NAPPEND(p)                                                      \

        (p->fts_path[p->fts_pathlen - 1] == '/'                         \

            ? p->fts_pathlen - 1 : p->fts_pathlen)

FTSENT *

fts_read (register FTS *sp)

{

        register FTSENT *p, *tmp;

        register unsigned short int instr;

        register char *t;

        /* If finished or unrecoverable error, return NULL. */

        if (sp->fts_cur == NULL || ISSET(FTS_STOP))

                return (NULL);

        /* Set current node pointer. */

        p = sp->fts_cur;

        /* Save and zero out user instructions. */

        instr = p->fts_instr;

        p->fts_instr = FTS_NOINSTR;

        /* Any type of file may be re-visited; re-stat and re-turn. */

        if (instr == FTS_AGAIN) {

                p->fts_info = fts_stat(sp, p, false);

                return (p);

        }

        Dprintf (("fts_read: p=%s\n",

                  p->fts_info == FTS_INIT ? "" : p->fts_path));

        /*

         * Following a symlink -- SLNONE test allows application to see

         * SLNONE and recover.  If indirecting through a symlink, have

         * keep a pointer to current location.  If unable to get that

         * pointer, follow fails.