AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-08 14:20:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

support: Add <support/readdir.h>

Browse Source 
It allows to read directories using the six readdir variants
without writing type-specific code or using skeleton files
that are compiled four times.

The readdir_r subtest for support_readdir_expect_error revealed
bug 32124.

Reviewed-by: DJ Delorie <dj@redhat.com>
This commit is contained in:
Florian Weimer 2024-09-12 09:40:25 +02:00
parent c444cc1d83
commit 1251e9ea49
4 changed files with 475 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
support/Makefile
View File

@ -78,6 +78,7 @@ libsupport-routines = \
support_quote_blob \
support_quote_blob_wide \
support_quote_string \
support_readdir \
support_readdir_check \
support_readdir_r_check \
support_record_failure \
@ -332,6 +333,7 @@ tests = \
tst-support_quote_blob \
tst-support_quote_blob_wide \
tst-support_quote_string \
tst-support_readdir \
tst-support_record_failure \
tst-test_compare \
tst-test_compare_blob \

85
support/readdir.h Normal file
View File

@ -0,0 +1,85 @@
/* Type-generic wrapper for readdir functions.
Copyright (C) 2024 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/>. */
#ifndef SUPPORT_READDIR_H
#define SUPPORT_READDIR_H
#include <dirent.h>
#include <stdbool.h>
#include <stdint.h>
__BEGIN_DECLS
/* Definition independent of _FILE_OFFSET_BITS. */
struct support_dirent
{
uint64_t d_ino;
uint64_t d_off; /* 0 if d_off is not supported. */
uint32_t d_type;
char *d_name;
};
/* Operation to be performed by support_readdir below. */
enum support_readdir_op
{
SUPPORT_READDIR,
SUPPORT_READDIR64,
SUPPORT_READDIR_R,
SUPPORT_READDIR64_R,
SUPPORT_READDIR64_COMPAT,
SUPPORT_READDIR64_R_COMPAT,
};
/* Returns the last supported function. May exclude
SUPPORT_READDIR64_R_COMPAT if not implemented. */
enum support_readdir_op support_readdir_op_last (void);
/* Returns the name of the function that corresponds to the OP constant. */
const char *support_readdir_function (enum support_readdir_op op);
/* Returns the d_ino field width for OP, in bits. */
unsigned int support_readdir_inode_width (enum support_readdir_op op);
/* Returns the d_off field width for OP, in bits. Zero if not present. */
unsigned int support_readdir_offset_width (enum support_readdir_op op);
/* Returns true if OP is an _r variant with name length restrictions. */
bool support_readdir_r_variant (enum support_readdir_op op);
/* First, free E->d_name and set the field to NULL. Then call the
readdir variant as specified by OP. If successfully, copy fields
to E, make a copy of the entry name using strdup, and write its
addres sto E->d_name.
Return true if an entry was read, or false if the end of the
directory stream was reached. Terminates the process upon error.
The caller is expected to free E->d_name if the function is not
called again for this E.
Note that this function assumes that E->d_name has been initialized
to NULL or has been allocated by a previous call to this function. */
bool support_readdir (DIR *stream, enum support_readdir_op op,
struct support_dirent *e) __nonnull ((1, 3));
/* Checks that the readdir operation OP fails with errno value EXPECTED. */
void support_readdir_expect_error (DIR *stream, enum support_readdir_op op,
int expected) __nonnull ((1));
__END_DECLS
#endif /* SUPPORT_READDIR_H */

318
support/support_readdir.c Normal file
View File

@ -0,0 +1,318 @@
/* Type-generic wrapper for readdir functions.
Copyright (C) 2024 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 <support/readdir.h>
#include <dlfcn.h>
#include <stddef.h>
#include <stdlib.h>
#include <support/check.h>
#include <support/support.h>
#include <support/xdirent.h>
/* Copied from <olddirent.h>. */
struct __old_dirent64
{
__ino_t d_ino;
__off64_t d_off;
unsigned short int d_reclen;
unsigned char d_type;
char d_name[256];
};
static struct __old_dirent64 *(*readdir64_compat) (DIR *);
static int (*readdir64_r_compat) (DIR *, struct __old_dirent64 *,
struct __old_dirent64 **);
static void __attribute__ ((constructor))
init (void)
{
/* These compat symbols exists on alpha, i386, m67k , powerpc, s390,
sparc. at the same GLIBC_2.1 version. */
readdir64_compat = dlvsym (RTLD_DEFAULT, "readdir64", "GLIBC_2.1");
readdir64_r_compat = dlvsym (RTLD_DEFAULT, "readdir64_r", "GLIBC_2.1");
}
enum support_readdir_op
support_readdir_op_last (void)
{
if (readdir64_r_compat != NULL)
{
TEST_VERIFY (readdir64_compat != NULL);
return SUPPORT_READDIR64_R_COMPAT;
}
else
return SUPPORT_READDIR64_R;
}
const char *
support_readdir_function (enum support_readdir_op op)
{
switch (op)
{
case SUPPORT_READDIR:
return "readdir";
case SUPPORT_READDIR64:
return "readdir64";
case SUPPORT_READDIR_R:
return "readdir_r";
case SUPPORT_READDIR64_R:
return "readdir64_r";
case SUPPORT_READDIR64_COMPAT:
return "readdir64@GBLIC_2.1";
case SUPPORT_READDIR64_R_COMPAT:
return "readdir64_r@GBLIC_2.1";
}
FAIL_EXIT1 ("invalid support_readdir_op constant: %d", op);
}
unsigned int
support_readdir_inode_width (enum support_readdir_op op)
{
switch (op)
{
case SUPPORT_READDIR:
case SUPPORT_READDIR_R:
return sizeof ((struct dirent) { 0, }.d_ino) * 8;
case SUPPORT_READDIR64:
case SUPPORT_READDIR64_R:
return sizeof ((struct dirent64) { 0, }.d_ino) * 8;
case SUPPORT_READDIR64_COMPAT:
case SUPPORT_READDIR64_R_COMPAT:
return sizeof ((struct __old_dirent64) { 0, }.d_ino) * 8;
}
FAIL_EXIT1 ("invalid support_readdir_op constant: %d", op);
}
unsigned int
support_readdir_offset_width (enum support_readdir_op op)
{
#ifdef _DIRENT_HAVE_D_OFF
switch (op)
{
case SUPPORT_READDIR:
case SUPPORT_READDIR_R:
return sizeof ((struct dirent) { 0, }.d_off) * 8;
case SUPPORT_READDIR64:
case SUPPORT_READDIR64_R:
return sizeof ((struct dirent64) { 0, }.d_off) * 8;
case SUPPORT_READDIR64_COMPAT:
case SUPPORT_READDIR64_R_COMPAT:
return sizeof ((struct __old_dirent64) { 0, }.d_off) * 8;
}
#else
switch (op)
{
case SUPPORT_READDIR:
case SUPPORT_READDIR_R:
case SUPPORT_READDIR64:
case SUPPORT_READDIR64_R:
case SUPPORT_READDIR64_COMPAT:
case SUPPORT_READDIR64_R_COMPAT:
return 0;
}
#endif
FAIL_EXIT1 ("invalid support_readdir_op constant: %d", op);
}
bool
support_readdir_r_variant (enum support_readdir_op op)
{
switch (op)
{
case SUPPORT_READDIR:
case SUPPORT_READDIR64:
case SUPPORT_READDIR64_COMPAT:
return false;
case SUPPORT_READDIR_R:
case SUPPORT_READDIR64_R:
case SUPPORT_READDIR64_R_COMPAT:
return true;
}
FAIL_EXIT1 ("invalid support_readdir_op constant: %d", op);
}
static bool
copy_dirent (struct support_dirent *dst, struct dirent *src)
{
if (src == NULL)
return false;
dst->d_ino = src->d_ino;
#ifdef _DIRENT_HAVE_D_OFF
dst->d_off = src->d_off;
#else
dst->d_off = 0;
#endif
dst->d_type = src->d_type;
dst->d_name = xstrdup (src->d_name);
return true;
}
static bool
copy_dirent64 (struct support_dirent *dst, struct dirent64 *src)
{
if (src == NULL)
return false;
dst->d_ino = src->d_ino;
#ifdef _DIRENT_HAVE_D_OFF
dst->d_off = src->d_off;
#else
dst->d_off = 0;
#endif
dst->d_type = src->d_type;
dst->d_name = xstrdup (src->d_name);
return true;
}
static bool
copy_old_dirent64 (struct support_dirent *dst, struct __old_dirent64 *src)
{
if (src == NULL)
return false;
dst->d_ino = src->d_ino;
#ifdef _DIRENT_HAVE_D_OFF
dst->d_off = src->d_off;
#else
dst->d_off = 0;
#endif
dst->d_type = src->d_type;
dst->d_name = xstrdup (src->d_name);
return true;
}
bool
support_readdir (DIR *stream, enum support_readdir_op op,
struct support_dirent *e)
{
free (e->d_name);
e->d_name = NULL;
switch (op)
{
case SUPPORT_READDIR:
return copy_dirent (e, xreaddir (stream));
case SUPPORT_READDIR64:
return copy_dirent64 (e, xreaddir64 (stream));
/* The functions readdir_r, readdir64_r were deprecated in glibc 2.24. */
DIAG_PUSH_NEEDS_COMMENT;
DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wdeprecated-declarations");
case SUPPORT_READDIR_R:
{
struct dirent buf;
if (!xreaddir_r (stream, &buf))
return false;
return copy_dirent (e, &buf);
}
case SUPPORT_READDIR64_R:
{
struct dirent64 buf;
if (!xreaddir64_r (stream, &buf))
return false;
return copy_dirent64 (e, &buf);
}
DIAG_POP_NEEDS_COMMENT;
case SUPPORT_READDIR64_COMPAT:
if (readdir64_compat == NULL)
FAIL_EXIT1 ("readdir64 compat function not implemented");
return copy_old_dirent64 (e, readdir64_compat (stream));
case SUPPORT_READDIR64_R_COMPAT:
{
if (readdir64_r_compat == NULL)
FAIL_EXIT1 ("readdir64_r compat function not implemented");
struct __old_dirent64 buf;
struct __old_dirent64 *e1;
int ret = readdir64_r_compat (stream, &buf, &e1);
if (ret != 0)
{
errno = ret;
FAIL ("readdir64_r@GLIBC_2.1: %m");
return false;
}
if (e1 == NULL)
return false;
return copy_old_dirent64 (e, e1);
}
}
FAIL_EXIT1 ("support_readdir: invalid op argument %d", (int) op);
}
void
support_readdir_expect_error (DIR *stream, enum support_readdir_op op,
int expected)
{
switch (op)
{
case SUPPORT_READDIR:
errno = 0;
TEST_VERIFY (readdir (stream) == NULL);
TEST_COMPARE (errno, expected);
return;
case SUPPORT_READDIR64:
errno = 0;
TEST_VERIFY (readdir64 (stream) == NULL);
TEST_COMPARE (errno, expected);
return;
/* The functions readdir_r, readdir64_r were deprecated in glibc 2.24. */
DIAG_PUSH_NEEDS_COMMENT;
DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wdeprecated-declarations");
case SUPPORT_READDIR_R:
{
struct dirent buf;
struct dirent *e;
errno = readdir_r (stream, &buf, &e);
TEST_COMPARE (errno, expected);;
}
return;
case SUPPORT_READDIR64_R:
{
struct dirent64 buf;
struct dirent64 *e;
errno = readdir64_r (stream, &buf, &e);
TEST_COMPARE (errno, expected);;
}
return;
DIAG_POP_NEEDS_COMMENT;
case SUPPORT_READDIR64_COMPAT:
if (readdir64_compat == NULL)
FAIL_EXIT1 ("readdir64_r compat function not implemented");
errno = 0;
TEST_VERIFY (readdir64_compat (stream) == NULL);
TEST_COMPARE (errno, expected);
return;
case SUPPORT_READDIR64_R_COMPAT:
{
if (readdir64_r_compat == NULL)
FAIL_EXIT1 ("readdir64_r compat function not implemented");
struct __old_dirent64 buf;
struct __old_dirent64 *e;
errno = readdir64_r_compat (stream, &buf, &e);
TEST_COMPARE (errno, expected);
}
return;
}
FAIL_EXIT1 ("support_readdir_expect_error: invalid op argument %d",
(int) op);
}

70
support/tst-support_readdir.c Normal file
View File

@ -0,0 +1,70 @@
/* Test the support_readdir function.
Copyright (C) 2024 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 <support/readdir.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <support/check.h>
#include <support/xdirent.h>
#include <support/xunistd.h>
static int
do_test (void)
{
DIR *reference_stream = xopendir (".");
struct dirent64 *reference = xreaddir64 (reference_stream);
for (enum support_readdir_op op = 0; op <= support_readdir_op_last (); ++op)
{
DIR *stream = xopendir (".");
struct support_dirent e;
memset (&e, 0xcc, sizeof (e));
e.d_name = NULL;
TEST_VERIFY (support_readdir (stream, op, &e));
TEST_COMPARE (e.d_ino, reference->d_ino);
if (support_readdir_offset_width (op) != 0)
TEST_COMPARE (e.d_off, reference->d_off);
else
TEST_COMPARE (e.d_off, 0);
TEST_COMPARE (e.d_type, reference->d_type);
TEST_COMPARE_STRING (e.d_name, reference->d_name);
free (e.d_name);
xclosedir (stream);
}
xclosedir (reference_stream);
/* Error injection test. */
int devnull = xopen ("/dev/null", O_RDONLY, 0);
for (enum support_readdir_op op = 0; op <= support_readdir_op_last (); ++op)
{
DIR *stream = xopendir (".");
/* A descriptor incompatible with readdir. */
xdup2 (devnull, dirfd (stream));
errno = -1;
support_readdir_expect_error (stream, op, ENOTDIR);
xclosedir (stream);
}
xclose (devnull);
return 0;
}
#include <support/test-driver.c>