Blob Blame History Raw
/* Get directory entries.  Linux LFS version.
   Copyright (C) 1997-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 <string.h>
#include <dirent.h>
#include <errno.h>

/* The kernel struct linux_dirent64 matches the 'struct getdents64' type.  */
ssize_t
__getdents64 (int fd, char *buf, size_t nbytes)
{
  return INLINE_SYSCALL_CALL (getdents64, fd, buf, nbytes);
}

#if _DIRENT_MATCHES_DIRENT64
strong_alias (__getdents64, __getdents)
#else
# include <shlib-compat.h>

# if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2)
#  include <olddirent.h>
#  include <unistd.h>

static ssize_t
handle_overflow (int fd, __off64_t offset, ssize_t count)
{
  /* If this is the first entry in the buffer, we can report the
     error.  */
  if (count == 0)
    {
      __set_errno (EOVERFLOW);
      return -1;
    }

  /* Otherwise, seek to the overflowing entry, so that the next call
     will report the error, and return the data read so far..  */
  if (__lseek64 (fd, offset, SEEK_SET) != 0)
    return -1;
  return count;
}

ssize_t
__old_getdents64 (int fd, char *buf, size_t nbytes)
{
  /* We do not move the individual directory entries.  This is only
     possible if the target type (struct __old_dirent64) is smaller
     than the source type.  */
  _Static_assert (offsetof (struct __old_dirent64, d_name)
		  <= offsetof (struct dirent64, d_name),
		  "__old_dirent64 is larger than dirent64");
  _Static_assert (__alignof__ (struct __old_dirent64)
		  <= __alignof__ (struct dirent64),
		  "alignment of __old_dirent64 is larger than dirent64");

  ssize_t retval = INLINE_SYSCALL_CALL (getdents64, fd, buf, nbytes);
  if (retval > 0)
    {
      char *p = buf;
      char *end = buf + retval;
      while (p < end)
	{
	  struct dirent64 *source = (struct dirent64 *) p;

	  /* Copy out the fixed-size data.  */
	  __ino_t ino = source->d_ino;
	  __off64_t offset = source->d_off;
	  unsigned int reclen = source->d_reclen;
	  unsigned char type = source->d_type;

	  /* Check for ino_t overflow.  */
	  if (__glibc_unlikely (ino != source->d_ino))
	    return handle_overflow (fd, offset, p - buf);

	  /* Convert to the target layout.  Use a separate struct and
	     memcpy to side-step aliasing issues.  */
	  struct __old_dirent64 result;
	  result.d_ino = ino;
	  result.d_off = offset;
	  result.d_reclen = reclen;
	  result.d_type = type;

	  /* Write the fixed-sized part of the result to the
	     buffer.  */
	  size_t result_name_offset = offsetof (struct __old_dirent64, d_name);
	  memcpy (p, &result, result_name_offset);

	  /* Adjust the position of the name if necessary.  Copy
	     everything until the end of the record, including the
	     terminating NUL byte.  */
	  if (result_name_offset != offsetof (struct dirent64, d_name))
	    memmove (p + result_name_offset, source->d_name,
		     reclen - offsetof (struct dirent64, d_name));

	  p += reclen;
	}
     }
  return retval;
}
# endif /* SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2)  */
#endif /* _DIRENT_MATCHES_DIRENT64  */