+++ /dev/null
-/* Copyright (C) 1991-2020 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
- <https://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
-# define __READDIR __readdir
-# define __GETDENTS __getdents
-# define DIRENT_TYPE struct dirent
-# define __READDIR_ALIAS
-#endif
-
-/* Read a directory entry from DIRP. */
-DIRENT_TYPE *
-__READDIR (DIR *dirp)
-{
- DIRENT_TYPE *dp;
- int saved_errno = errno;
-
-#if IS_IN (libc)
- __libc_lock_lock (dirp->lock);
-#endif
-
- do
- {
- size_t reclen;
-
- 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;
-
- /* Don't modifiy errno when reaching EOF. */
- if (bytes == 0)
- __set_errno (saved_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 jst 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
-
- /* Skip deleted files. */
- } while (dp->d_ino == 0);
-
-#if IS_IN (libc)
- __libc_lock_unlock (dirp->lock);
-#endif
-
- return dp;
-}
-
-#ifdef __READDIR_ALIAS
-weak_alias (__readdir, readdir)
-#endif
-
-#undef __READDIR
-#undef __GETDENTS
-#undef DIRENT_TYPE
-#undef __READDIR_ALIAS
+++ /dev/null
-/* Copyright (C) 1991-2020 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
- <https://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
#include <dirent.h>
#if !_DIRENT_MATCHES_DIRENT64
-# include <sysdeps/posix/readdir.c>
+#include <dirstream.h>
+
+/* Read a directory entry from DIRP. */
+struct dirent *
+__readdir (DIR *dirp)
+{
+ struct dirent *dp;
+ int saved_errno = errno;
+
+#if IS_IN (libc)
+ __libc_lock_lock (dirp->lock);
+#endif
+
+ do
+ {
+ size_t reclen;
+
+ if (dirp->offset >= dirp->size)
+ {
+ /* We've emptied out our buffer. Refill it. */
+
+ size_t maxread = dirp->allocation;
+ ssize_t bytes;
+
+ 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;
+
+ /* Don't modifiy errno when reaching EOF. */
+ if (bytes == 0)
+ __set_errno (saved_errno);
+ dp = NULL;
+ break;
+ }
+ dirp->size = (size_t) bytes;
+
+ /* Reset the offset into the buffer. */
+ dirp->offset = 0;
+ }
+
+ dp = (struct dirent *) &dirp->data[dirp->offset];
+
+ reclen = dp->d_reclen;
+
+ dirp->offset += reclen;
+
+ dirp->filepos = dp->d_off;
+
+ /* Skip deleted files. */
+ } while (dp->d_ino == 0);
+
+#if IS_IN (libc)
+ __libc_lock_unlock (dirp->lock);
+#endif
+
+ return dp;
+}
+weak_alias (__readdir, readdir)
+
#endif
#define readdir __no_readdir_decl
#define __readdir __no___readdir_decl
#include <dirent.h>
+#undef __readdir
+#undef readdir
-#define __READDIR __readdir64
-#define __GETDENTS __getdents64
-#define DIRENT_TYPE struct dirent64
+/* Read a directory entry from DIRP. */
+struct dirent64 *
+__readdir64 (DIR *dirp)
+{
+ struct dirent64 *dp;
+ int saved_errno = errno;
-#include <sysdeps/posix/readdir.c>
+#if IS_IN (libc)
+ __libc_lock_lock (dirp->lock);
+#endif
-#undef __readdir
-#undef readdir
+ do
+ {
+ size_t reclen;
+
+ if (dirp->offset >= dirp->size)
+ {
+ /* We've emptied out our buffer. Refill it. */
+
+ size_t maxread = dirp->allocation;
+ ssize_t bytes;
+
+ bytes = __getdents64 (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;
+
+ /* Don't modifiy errno when reaching EOF. */
+ if (bytes == 0)
+ __set_errno (saved_errno);
+ dp = NULL;
+ break;
+ }
+ dirp->size = (size_t) bytes;
+ /* Reset the offset into the buffer. */
+ dirp->offset = 0;
+ }
+
+ dp = (struct dirent64 *) &dirp->data[dirp->offset];
+
+ reclen = dp->d_reclen;
+
+ dirp->offset += reclen;
+
+ dirp->filepos = dp->d_off;
+
+ /* Skip deleted files. */
+ } while (dp->d_ino == 0);
+
+#if IS_IN (libc)
+ __libc_lock_unlock (dirp->lock);
+#endif
+
+ return dp;
+}
libc_hidden_def (__readdir64)
+
#if _DIRENT_MATCHES_DIRENT64
strong_alias (__readdir64, __readdir)
weak_alias (__readdir64, readdir64)
# endif
# if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2)
# include <olddirent.h>
-# define __READDIR attribute_compat_text_section __old_readdir64
-# define __GETDENTS __old_getdents64
-# define DIRENT_TYPE struct __old_dirent64
-# include <sysdeps/posix/readdir.c>
+
+attribute_compat_text_section
+struct __old_dirent64 *
+__old_readdir64 (DIR *dirp)
+{
+ struct __old_dirent64 *dp;
+ int saved_errno = errno;
+
+#if IS_IN (libc)
+ __libc_lock_lock (dirp->lock);
+#endif
+
+ do
+ {
+ size_t reclen;
+
+ if (dirp->offset >= dirp->size)
+ {
+ /* We've emptied out our buffer. Refill it. */
+
+ size_t maxread = dirp->allocation;
+ ssize_t bytes;
+
+ bytes = __old_getdents64 (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;
+
+ /* Don't modifiy errno when reaching EOF. */
+ if (bytes == 0)
+ __set_errno (saved_errno);
+ dp = NULL;
+ break;
+ }
+ dirp->size = (size_t) bytes;
+
+ /* Reset the offset into the buffer. */
+ dirp->offset = 0;
+ }
+
+ dp = (struct __old_dirent64 *) &dirp->data[dirp->offset];
+
+ reclen = dp->d_reclen;
+
+ dirp->offset += reclen;
+
+ dirp->filepos = dp->d_off;
+
+ /* Skip deleted files. */
+ } while (dp->d_ino == 0);
+
+#if IS_IN (libc)
+ __libc_lock_unlock (dirp->lock);
+#endif
+
+ return dp;
+}
libc_hidden_def (__old_readdir64)
compat_symbol (libc, __old_readdir64, readdir64, GLIBC_2_1);
# endif /* SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2) */
#define readdir_r __no_readdir_r_decl
#define __readdir_r __no___readdir_r_decl
#include <dirent.h>
+#undef __readdir_r
+#undef readdir_r
-#define __READDIR_R __readdir64_r
-#define __GETDENTS __getdents64
-#define DIRENT_TYPE struct dirent64
+/* Read a directory entry from DIRP. */
+int
+__readdir64_r (DIR *dirp, struct dirent64 *entry, struct dirent64 **result)
+{
+ struct dirent64 *dp;
+ size_t reclen;
+ const int saved_errno = errno;
+ int ret;
-#include <sysdeps/posix/readdir_r.c>
+ __libc_lock_lock (dirp->lock);
+
+ do
+ {
+ if (dirp->offset >= dirp->size)
+ {
+ /* We've emptied out our buffer. Refill it. */
+
+ size_t maxread = dirp->allocation;
+ ssize_t bytes;
+
+ maxread = dirp->allocation;
+
+ bytes = __getdents64 (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 = (struct dirent64 *) &dirp->data[dirp->offset];
+
+ reclen = dp->d_reclen;
+
+ dirp->offset += reclen;
+
+ dirp->filepos = dp->d_off;
+
+ if (reclen > offsetof (struct dirent64, 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 (struct dirent64, d_name) + namelen + 1;
+ else
+ {
+ /* The name is too long. Ignore this file. */
+ dirp->errcode = ENAMETOOLONG;
+ dp->d_ino = 0;
+ continue;
+ }
+ }
+
+ /* Skip deleted and ignored files. */
+ }
+ while (dp->d_ino == 0);
+
+ if (dp != NULL)
+ {
+ *result = memcpy (entry, dp, reclen);
+ entry->d_reclen = reclen;
+ ret = 0;
+ }
+ else
+ {
+ *result = NULL;
+ ret = dirp->errcode;
+ }
+
+ __libc_lock_unlock (dirp->lock);
+
+ return ret;
+}
-#undef __readdir_r
-#undef readdir_r
#if _DIRENT_MATCHES_DIRENT64
strong_alias (__readdir64_r, __readdir_r)
versioned_symbol (libc, __readdir64_r, readdir64_r, GLIBC_2_2);
# if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2)
# include <olddirent.h>
-# define __READDIR_R attribute_compat_text_section __old_readdir64_r
-# define __GETDENTS __old_getdents64
-# define DIRENT_TYPE struct __old_dirent64
-# include <sysdeps/posix/readdir_r.c>
+
+int
+attribute_compat_text_section
+__old_readdir64_r (DIR *dirp, struct __old_dirent64 *entry,
+ struct __old_dirent64 **result)
+{
+ struct __old_dirent64 *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 = dirp->allocation;
+ ssize_t bytes;
+
+ maxread = dirp->allocation;
+
+ bytes = __old_getdents64 (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 = (struct __old_dirent64 *) &dirp->data[dirp->offset];
+
+ reclen = dp->d_reclen;
+
+ dirp->offset += reclen;
+
+ dirp->filepos = dp->d_off;
+
+ if (reclen > offsetof (struct __old_dirent64, 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 (struct __old_dirent64, d_name) + namelen + 1;
+ else
+ {
+ /* The name is too long. Ignore this file. */
+ dirp->errcode = ENAMETOOLONG;
+ dp->d_ino = 0;
+ continue;
+ }
+ }
+
+ /* Skip deleted and ignored files. */
+ }
+ while (dp->d_ino == 0);
+
+ if (dp != NULL)
+ {
+ *result = memcpy (entry, dp, reclen);
+ entry->d_reclen = reclen;
+ ret = 0;
+ }
+ else
+ {
+ *result = NULL;
+ ret = dirp->errcode;
+ }
+
+ __libc_lock_unlock (dirp->lock);
+
+ return ret;
+}
+
compat_symbol (libc, __old_readdir64_r, readdir64_r, GLIBC_2_1);
# endif /* SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2) */
#endif /* _DIRENT_MATCHES_DIRENT64 */
#include <dirent.h>
#if !_DIRENT_MATCHES_DIRENT64
-# include <sysdeps/posix/readdir_r.c>
-#endif
+/* Read a directory entry from DIRP. */
+int
+__readdir_r (DIR *dirp, struct dirent *entry, struct dirent **result)
+{
+ struct dirent *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 = dirp->allocation;
+ ssize_t bytes;
+
+ maxread = dirp->allocation;
+
+ 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 = (struct dirent *) &dirp->data[dirp->offset];
+
+ reclen = dp->d_reclen;
+
+ dirp->offset += reclen;
+
+ dirp->filepos = dp->d_off;
+
+ if (reclen > offsetof (struct dirent, 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 (struct dirent, d_name) + namelen + 1;
+ else
+ {
+ /* The name is too long. Ignore this file. */
+ dirp->errcode = ENAMETOOLONG;
+ dp->d_ino = 0;
+ continue;
+ }
+ }
+
+ /* Skip deleted and ignored files. */
+ }
+ while (dp->d_ino == 0);
+
+ if (dp != NULL)
+ {
+ *result = memcpy (entry, dp, reclen);
+ entry->d_reclen = reclen;
+ ret = 0;
+ }
+ else
+ {
+ *result = NULL;
+ ret = dirp->errcode;
+ }
+
+ __libc_lock_unlock (dirp->lock);
+
+ return ret;
+}
+
+weak_alias (__readdir_r, readdir_r)
+#endif /* _DIRENT_MATCHES_DIRENT64 */
projects / platform / upstream / glibc.git / commitdiff