/* Copyright (C) 1991-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library 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

   Lesser General Public License for more details.

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

   License along with the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#include <errno.h>

#include <limits.h>

#include <stddef.h>

#include <string.h>

#include <dirent.h>

#include <unistd.h>

#include <sys/types.h>

#include <assert.h>

#include <dirstream.h>

#ifndef __READDIR_R

# define __READDIR_R __readdir_r

# define __GETDENTS __getdents

# define DIRENT_TYPE struct dirent

# define __READDIR_R_ALIAS

#endif

/* Read a directory entry from DIRP.  */

int

__READDIR_R (DIR *dirp, DIRENT_TYPE *entry, DIRENT_TYPE **result)

{

  DIRENT_TYPE *dp;

  size_t reclen;

  const int saved_errno = errno;

  int ret;

  __libc_lock_lock (dirp->lock);

  do

    {

      if (dirp->offset >= dirp->size)

	{

	  /* We've emptied out our buffer.  Refill it.  */

	  size_t maxread;

	  ssize_t bytes;

#ifndef _DIRENT_HAVE_D_RECLEN

	  /* Fixed-size struct; must read one at a time (see below).  */

	  maxread = sizeof *dp;

#else

	  maxread = dirp->allocation;

#endif

	  bytes = __GETDENTS (dirp->fd, dirp->data, maxread);

	  if (bytes <= 0)

	    {

	      /* On some systems getdents fails with ENOENT when the

		 open directory has been rmdir'd already.  POSIX.1

		 requires that we treat this condition like normal EOF.  */

	      if (bytes < 0 && errno == ENOENT)

		{

		  bytes = 0;

		  __set_errno (saved_errno);

		}

	      if (bytes < 0)

		dirp->errcode = errno;

	      dp = NULL;

	      break;

	    }

	  dirp->size = (size_t) bytes;

	  /* Reset the offset into the buffer.  */

	  dirp->offset = 0;

	}

      dp = (DIRENT_TYPE *) &dirp->data[dirp->offset];

#ifdef _DIRENT_HAVE_D_RECLEN

      reclen = dp->d_reclen;

#else

      /* The only version of `struct dirent*' that lacks `d_reclen'

	 is fixed-size.  */

      assert (sizeof dp->d_name > 1);

      reclen = sizeof *dp;

      /* The name is not terminated if it is the largest possible size.

	 Clobber the following byte to ensure proper null termination.  We

	 read just one entry at a time above so we know that byte will not

	 be used later.  */

      dp->d_name[sizeof dp->d_name] = '\0';

#endif

      dirp->offset += reclen;

#ifdef _DIRENT_HAVE_D_OFF

      dirp->filepos = dp->d_off;

#else

      dirp->filepos += reclen;

#endif

#ifdef NAME_MAX

      if (reclen > offsetof (DIRENT_TYPE, d_name) + NAME_MAX + 1)

	{

	  /* The record is very long.  It could still fit into the

	     caller-supplied buffer if we can skip padding at the

	     end.  */

	  size_t namelen = _D_EXACT_NAMLEN (dp);

	  if (namelen <= NAME_MAX)

	    reclen = offsetof (DIRENT_TYPE, d_name) + namelen + 1;

	  else

	    {

	      /* The name is too long.  Ignore this file.  */

	      dirp->errcode = ENAMETOOLONG;

	      dp->d_ino = 0;

	      continue;

	    }

	}

#endif

      /* Skip deleted and ignored files.  */

    }

  while (dp->d_ino == 0);

  if (dp != NULL)

    {

      *result = memcpy (entry, dp, reclen);

#ifdef _DIRENT_HAVE_D_RECLEN

      entry->d_reclen = reclen;

#endif

      ret = 0;

    }

  else

    {

      *result = NULL;

      ret = dirp->errcode;

    }

  __libc_lock_unlock (dirp->lock);

  return ret;

}

#ifdef __READDIR_R_ALIAS

weak_alias (__readdir_r, readdir_r)

#endif

#undef __READDIR_R

#undef __GETDENTS

#undef DIRENT_TYPE

#undef __READDIR_R_ALIAS