mirror of
https://sourceware.org/git/glibc.git
synced 2024-12-27 05:00:15 +00:00
ffa8d2a098
name of "", store a null pointer instead. * configure.in (elf): Set to yes for freebsd*, netbsd*. * configure: Regenerated. * locale/xlocale.c [! (USE_TLS && HAVE___THREAD)] (__libc_tsd_LOCALE): Initialize this instead of __libc_tsd_LOCALE_data. * sysdeps/unix/grantpt.c (pts_name): Convert ENOTTY return from ptsname_r to EINVAL. * sysdeps/generic/ptsname.c (__ptsname_r): Return ENOSYS instead of 0. * rt/Makefile: Revert last change, it was inappropriate to presume aio implementations depend on pthreads. * rt/tst-aio.c (do_test): Exit happy if first failure is ENOSYS. * rt/tst-aio64.c (do_test): Likewise. * rt/tst-aio2.c (do_test): Likewise. * rt/tst-aio3.c (do_test): Likewise. * rt/tst-aio4.c (do_test): Likewise. * rt/tst-aio5.c (do_test): Likewise. * rt/tst-aio6.c (do_test): Likewise. * rt/tst-aio7.c (do_test): Likewise. * sysdeps/generic/bits/libc-lock.h (__libc_setspecific): Use a cast to void so as to avoid compiler warnings. * libio/oldstdfiles.c [! _IO_MTSAFE_IO] (DEF_STDFILE): Don't define _IO_wide_data_FD, which is never used here. * libio/iofread.c [! _IO_MTSAFE_IO] (fread_unlocked): Add libc_hidden_ver defn. * libio/iofputs.c [! _IO_MTSAFE_IO] (fputs_unlocked): Likewise. * libio/iofgets.c [! _IO_MTSAFE_IO] (fgets_unlocked): Likewise. * include/resolv.h [! _LIBC_REENTRANT] (_res): #undef it before decl. * include/netdb.h [! _LIBC_REENTRANT] (h_errno): Declare normal extern. * misc/syslog.c (openlog): Conditionalize locking on [_LIBC_REENTRANT]. (closelog): Likewise. 2002-07-06 Bruno Haible <bruno@clisp.org> * sysdeps/alpha/fpu/fpu_control.h: Comment fix. * sysdeps/unix/sysv/linux/alpha/pipe.S: Moved to ... * sysdeps/unix/alpha/pipe.S: ... here. * sysdeps/unix/bsd/osf/alpha/pipe.S: File removed. * sysdeps/unix/i386/brk.S: Rename local label to '.Lhere' in ELF. * sysdeps/unix/i386/brk.S: Add PSEUDO_END invocation. * sysdeps/unix/i386/fork.S: Likewise. * sysdeps/unix/i386/pipe.S: Likewise. * sysdeps/unix/i386/wait.S: Likewise. * sysdeps/unix/fork.S: Fix PSEUDO_END argument. * sysdeps/unix/arm/fork.S: Likewise. * sysdeps/unix/sysv/linux/arm/sysdep.h (PSEUDO): Swap DO_CALL arguments. (DO_CALL): Swap argument order. * sysdeps/unix/sysv/linux/hppa/sysdep.h (PSEUDO): Swap DO_CALL arguments. (DO_CALL): Swap argument order. * sysdeps/unix/sysv/linux/i386/sysdep.h (PSEUDO): Swap DO_CALL arguments. (DO_CALL): Swap argument order. * sysdeps/unix/sysv/linux/s390/s390-32/sysdep.h (PSEUDO): Swap DO_CALL arguments. (DO_CALL): Swap argument order. * sysdeps/unix/sysv/linux/s390/s390-64/sysdep.h (PSEUDO): Swap DO_CALL arguments. (DO_CALL): Swap argument order. * sysdeps/unix/sysv/linux/sh/sysdep.h (PSEUDO): Swap DO_CALL arguments. (DO_CALL): Swap argument order. * sysdeps/unix/sysv/linux/x86_64/sysdep.h (PSEUDO): Swap DO_CALL arguments. (DO_CALL): Swap argument order. * sysdeps/i386/sysdep.h (PSEUDO): Fix syntax error. (L): Define right for ELF. * sysdeps/unix/sysv/linux/i386/sysdep.h (L): Remove definition. Now defined in sysdeps/i386/sysdep.h. * sysdeps/posix/readv.c: Ansify function definition. * sysdeps/posix/writev.c: Likewise. * stdio-common/tst-fseek.c (main): Don't assume that off_t and size_t have the same size. Avoid direct cast from size_t to off_t. * login/tst-utmp.c (simulate_login): Don't leave garbage after the nul byte in entry[n].ut_user. (simulate_logout): Likewise. * login/programs/utmpdump.c (print_entry): Test _HAVE_UT_TYPE, _HAVE_UT_PID, _HAVE_UT_ID, _HAVE_UT_HOST, instead of assuming the existence of corresponding members of 'struct utmp'. * login/tst-utmp.c: Trivialize the test if testing 'struct utmp' and !_HAVE_UT_TYPE. * sysdeps/unix/opendir.c (__opendir): If st_blksize is 0 or too small, allocate a buffer of at least BUFSIZ bytes, not just of sizeof (struct dirent). * sysdeps/generic/glob.c: Include <limits.h>. (NAME_MAX): Define a fallback. (glob_in_dir): Allocate enough room for a 'struct dirent64' on the stack. * posix/tst-dir.c: Include <stddef.h>, for offsetof. (main): Allocate enough room for a 'struct dirent64' on the stack. * posix/tst-gnuglob.c (my_DIR): Allocate enough room for a 'struct dirent'. * sysdeps/unix/sysv/linux/init-first.c: Don't include kernel-features.h. * inet/htontest.c: Include <sys/types.h>. * sysdeps/generic/sys/sysinfo.h: Surround with __{BEGIN,END}_DECLS. * include/sys/sysctl.h: Comment fix. * elf/rtld.c (_rtld_global) [! _LIBC_REENTRANT]: Don't initialize _dl_load_lock. * libio/fileno.c (fileno_unlocked): Define regardless of _IO_MTSAFE_IO. * sysdeps/unix/bsd/bsd4.4/syscalls.list (__sigaltstack): New alias. * sysdeps/unix/inet/syscalls.list (__connect_internal): New alias. (__getpeername): New alias. (__getsockname): New alias. (__socket): New alias. * sysdeps/unix/common/syscalls.list (getpgid): Remove. * sysdeps/unix/syscalls.list (__chown_internal): New alias. (__fcntl_internal): New alias. (__profil): New alias.
442 lines
9.9 KiB
C
442 lines
9.9 KiB
C
/* Test the GNU extensions in glob which allow the user to provide callbacks
|
|
for the filesystem access functions.
|
|
Copyright (C) 2001-2002 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Contributed by Ulrich Drepper <drepper@redhat.com>, 2001.
|
|
|
|
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, write to the Free
|
|
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307 USA. */
|
|
|
|
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <error.h>
|
|
#include <glob.h>
|
|
#include <mcheck.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
|
|
|
|
/* #define DEBUG */
|
|
#ifdef DEBUG
|
|
# define PRINTF(fmt, args...) printf (fmt, ##args)
|
|
#else
|
|
# define PRINTF(fmt, args...)
|
|
#endif
|
|
|
|
|
|
static struct
|
|
{
|
|
const char *name;
|
|
int level;
|
|
int type;
|
|
} filesystem[] =
|
|
{
|
|
{ ".", 1, DT_DIR },
|
|
{ "..", 1, DT_DIR },
|
|
{ "file1lev1", 1, DT_REG },
|
|
{ "file2lev1", 1, DT_UNKNOWN },
|
|
{ "dir1lev1", 1, DT_UNKNOWN },
|
|
{ ".", 2, DT_DIR },
|
|
{ "..", 2, DT_DIR },
|
|
{ "file1lev2", 2, DT_REG },
|
|
{ "dir1lev2", 2, DT_DIR },
|
|
{ ".", 3, DT_DIR },
|
|
{ "..", 3, DT_DIR },
|
|
{ "dir2lev2", 2, DT_DIR },
|
|
{ ".", 3, DT_DIR },
|
|
{ "..", 3, DT_DIR },
|
|
{ ".foo", 3, DT_REG },
|
|
{ "dir1lev3", 3, DT_DIR },
|
|
{ ".", 4, DT_DIR },
|
|
{ "..", 4, DT_DIR },
|
|
{ "file1lev4", 4, DT_REG },
|
|
{ "file1lev3", 3, DT_REG },
|
|
{ "file2lev3", 3, DT_REG },
|
|
{ "file2lev2", 2, DT_REG },
|
|
{ "file3lev2", 2, DT_REG },
|
|
{ "dir3lev2", 2, DT_DIR },
|
|
{ ".", 3, DT_DIR },
|
|
{ "..", 3, DT_DIR },
|
|
{ "file3lev3", 3, DT_REG },
|
|
{ "file4lev3", 3, DT_REG },
|
|
{ "dir2lev1", 1, DT_DIR },
|
|
{ ".", 2, DT_DIR },
|
|
{ "..", 2, DT_DIR },
|
|
{ "dir1lev2", 2, DT_UNKNOWN },
|
|
{ ".", 3, DT_DIR },
|
|
{ "..", 3, DT_DIR },
|
|
{ ".foo", 3, DT_REG },
|
|
{ ".dir", 3, DT_DIR },
|
|
{ ".", 4, DT_DIR },
|
|
{ "..", 4, DT_DIR },
|
|
{ "hidden", 4, DT_REG }
|
|
};
|
|
#define nfiles (sizeof (filesystem) / sizeof (filesystem[0]))
|
|
|
|
|
|
typedef struct
|
|
{
|
|
int level;
|
|
int idx;
|
|
struct dirent d;
|
|
char room_for_dirent[NAME_MAX];
|
|
} my_DIR;
|
|
|
|
|
|
static long int
|
|
find_file (const char *s)
|
|
{
|
|
int level = 1;
|
|
long int idx = 0;
|
|
|
|
if (strcmp (s, ".") == 0)
|
|
return 0;
|
|
|
|
while (*s != '\0')
|
|
{
|
|
char *endp = strchrnul (s, '/');
|
|
|
|
PRINTF ("looking for %.*s, level %d\n", (int) (endp - s), s, level);
|
|
|
|
while (idx < nfiles && filesystem[idx].level >= level)
|
|
{
|
|
if (filesystem[idx].level == level
|
|
&& memcmp (s, filesystem[idx].name, endp - s) == 0
|
|
&& filesystem[idx].name[endp - s] == '\0')
|
|
break;
|
|
++idx;
|
|
}
|
|
|
|
if (idx == nfiles || filesystem[idx].level < level)
|
|
{
|
|
errno = ENOENT;
|
|
return -1;
|
|
}
|
|
if (filesystem[idx].type != DT_DIR
|
|
&& (idx + 1 >= nfiles
|
|
|| filesystem[idx].level >= filesystem[idx + 1].level))
|
|
{
|
|
errno = ENOTDIR;
|
|
return -1;
|
|
}
|
|
|
|
++idx;
|
|
|
|
if (*endp == '\0')
|
|
return idx;
|
|
|
|
s = endp + 1;
|
|
++level;
|
|
}
|
|
|
|
errno = ENOENT;
|
|
return -1;
|
|
}
|
|
|
|
|
|
static void *
|
|
my_opendir (const char *s)
|
|
{
|
|
long int idx = find_file (s);
|
|
my_DIR *dir;
|
|
|
|
|
|
if (idx == -1)
|
|
{
|
|
PRINTF ("my_opendir(\"%s\") == NULL\n", s);
|
|
return NULL;
|
|
}
|
|
|
|
dir = (my_DIR *) malloc (sizeof (my_DIR));
|
|
if (dir == NULL)
|
|
error (EXIT_FAILURE, errno, "cannot allocate directory handle");
|
|
|
|
dir->level = filesystem[idx].level;
|
|
dir->idx = idx;
|
|
|
|
PRINTF ("my_opendir(\"%s\") == { level: %d, idx: %ld }\n",
|
|
s, filesystem[idx].level, idx);
|
|
|
|
return dir;
|
|
}
|
|
|
|
|
|
static struct dirent *
|
|
my_readdir (void *gdir)
|
|
{
|
|
my_DIR *dir = gdir;
|
|
|
|
if (dir->idx == -1)
|
|
{
|
|
PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n",
|
|
dir->level, (long int) dir->idx);
|
|
return NULL;
|
|
}
|
|
|
|
while (dir->idx < nfiles && filesystem[dir->idx].level > dir->level)
|
|
++dir->idx;
|
|
|
|
if (dir->idx == nfiles || filesystem[dir->idx].level < dir->level)
|
|
{
|
|
dir->idx = -1;
|
|
PRINTF ("my_readdir ({ level: %d, idx: %ld }) = NULL\n",
|
|
dir->level, (long int) dir->idx);
|
|
return NULL;
|
|
}
|
|
|
|
dir->d.d_ino = dir->idx;
|
|
|
|
#ifdef _DIRENT_HAVE_D_TYPE
|
|
dir->d.d_type = filesystem[dir->idx].type;
|
|
#endif
|
|
|
|
strcpy (dir->d.d_name, filesystem[dir->idx].name);
|
|
|
|
#ifdef _DIRENT_HAVE_D_TYPE
|
|
PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_type: %d, d_name: \"%s\" }\n",
|
|
dir->level, (long int) dir->idx, dir->d.d_ino, dir->d.d_type,
|
|
dir->d.d_name);
|
|
#else
|
|
PRINTF ("my_readdir ({ level: %d, idx: %ld }) = { d_ino: %ld, d_name: \"%s\" }\n",
|
|
dir->level, (long int) dir->idx, dir->d.d_ino,
|
|
dir->d.d_name);
|
|
#endif
|
|
|
|
++dir->idx;
|
|
|
|
return &dir->d;
|
|
}
|
|
|
|
|
|
static void
|
|
my_closedir (void *dir)
|
|
{
|
|
PRINTF ("my_closedir ()\n");
|
|
free (dir);
|
|
}
|
|
|
|
|
|
/* We use this function for lstat as well since we don't have any. */
|
|
static int
|
|
my_stat (const char *name, struct stat *st)
|
|
{
|
|
long int idx = find_file (name);
|
|
|
|
if (idx == -1)
|
|
{
|
|
PRINTF ("my_stat (\"%s\", ...) = -1 (%s)\n", name, strerror (errno));
|
|
return -1;
|
|
}
|
|
|
|
memset (st, '\0', sizeof (*st));
|
|
|
|
if (filesystem[idx].type == DT_UNKNOWN)
|
|
st->st_mode = DTTOIF (idx + 1 < nfiles
|
|
&& filesystem[idx].level < filesystem[idx + 1].level
|
|
? DT_DIR : DT_REG) | 0777;
|
|
else
|
|
st->st_mode = DTTOIF (filesystem[idx].type) | 0777;
|
|
|
|
PRINTF ("my_stat (\"%s\", { st_mode: %o }) = 0\n", name, st->st_mode);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static const char *glob_errstring[] =
|
|
{
|
|
[GLOB_NOSPACE] = "out of memory",
|
|
[GLOB_ABORTED] = "read error",
|
|
[GLOB_NOMATCH] = "no matches found"
|
|
};
|
|
#define nglob_errstring (sizeof (glob_errstring) / sizeof (glob_errstring[0]))
|
|
|
|
|
|
static const char *
|
|
flagstr (int flags)
|
|
{
|
|
const char *strs[] =
|
|
{
|
|
"GLOB_ERR", "GLOB_MARK", "GLOB_NOSORT", "GLOB_DOOFSS", "GLOB_NOCHECK",
|
|
"GLOB_APPEND", "GLOB_NOESCAPE", "GLOB_PERIOD", "GLOB_MAGCHAR",
|
|
"GLOB_ALTDIRFUNC", "GLOB_BRACE", "GLOB_NOMAGIC", "GLOB_TILDE",
|
|
"GLOB_ONLYDIR", "GLOB_TILDECHECK"
|
|
};
|
|
#define nstrs (sizeof (strs) / sizeof (strs[0]))
|
|
static char buf[100];
|
|
char *cp = buf;
|
|
int cnt;
|
|
|
|
for (cnt = 0; cnt < nstrs; ++cnt)
|
|
if (flags & (1 << cnt))
|
|
{
|
|
flags &= ~(1 << cnt);
|
|
if (cp != buf)
|
|
*cp++ = '|';
|
|
cp = stpcpy (cp, strs[cnt]);
|
|
}
|
|
|
|
if (flags != 0)
|
|
{
|
|
if (cp != buf)
|
|
*cp++ = '|';
|
|
sprintf (cp, "%#x", flags);
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
|
|
static int
|
|
test_result (const char *fmt, int flags, glob_t *gl, const char *str[])
|
|
{
|
|
size_t cnt;
|
|
int result = 0;
|
|
|
|
printf ("results for glob (\"%s\", %s)\n", fmt, flagstr (flags));
|
|
for (cnt = 0; cnt < gl->gl_pathc && str[cnt] != NULL; ++cnt)
|
|
{
|
|
int ok = strcmp (gl->gl_pathv[cnt], str[cnt]) == 0;
|
|
const char *errstr = "";
|
|
|
|
if (! ok)
|
|
{
|
|
size_t inner;
|
|
|
|
for (inner = 0; str[inner] != NULL; ++inner)
|
|
if (strcmp (gl->gl_pathv[cnt], str[inner]) == 0)
|
|
break;
|
|
|
|
if (str[inner] == NULL)
|
|
errstr = ok ? "" : " *** WRONG";
|
|
else
|
|
errstr = ok ? "" : " * wrong position";
|
|
|
|
result = 1;
|
|
}
|
|
|
|
printf (" %s%s\n", gl->gl_pathv[cnt], errstr);
|
|
}
|
|
puts ("");
|
|
|
|
if (str[cnt] != NULL || cnt < gl->gl_pathc)
|
|
{
|
|
puts (" *** incorrect number of entries");
|
|
result = 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
int
|
|
main (void)
|
|
{
|
|
glob_t gl;
|
|
int errval;
|
|
int result = 0;
|
|
const char *fmt;
|
|
int flags;
|
|
|
|
mtrace ();
|
|
|
|
memset (&gl, '\0', sizeof (gl));
|
|
|
|
gl.gl_closedir = my_closedir;
|
|
gl.gl_readdir = my_readdir;
|
|
gl.gl_opendir = my_opendir;
|
|
gl.gl_lstat = my_stat;
|
|
gl.gl_stat = my_stat;
|
|
|
|
#define test(a, b, c...) \
|
|
fmt = a; \
|
|
flags = b; \
|
|
errval = glob (fmt, flags, NULL, &gl); \
|
|
if (errval != 0) \
|
|
{ \
|
|
printf ("glob (\"%s\", %s) failed: %s\n", fmt, flagstr (flags), \
|
|
errval >= 0 && errval < nglob_errstring \
|
|
? glob_errstring[errval] : "???"); \
|
|
result = 1; \
|
|
} \
|
|
else \
|
|
result |= test_result (fmt, flags, &gl, (const char *[]) { c, NULL })
|
|
|
|
test ("*/*/*", GLOB_ALTDIRFUNC,
|
|
"dir1lev1/dir2lev2/dir1lev3",
|
|
"dir1lev1/dir2lev2/file1lev3",
|
|
"dir1lev1/dir2lev2/file2lev3",
|
|
"dir1lev1/dir3lev2/file3lev3",
|
|
"dir1lev1/dir3lev2/file4lev3");
|
|
|
|
test ("*/*/*", GLOB_ALTDIRFUNC | GLOB_PERIOD,
|
|
"dir1lev1/dir1lev2/.",
|
|
"dir1lev1/dir1lev2/..",
|
|
"dir1lev1/dir2lev2/.",
|
|
"dir1lev1/dir2lev2/..",
|
|
"dir1lev1/dir2lev2/.foo",
|
|
"dir1lev1/dir2lev2/dir1lev3",
|
|
"dir1lev1/dir2lev2/file1lev3",
|
|
"dir1lev1/dir2lev2/file2lev3",
|
|
"dir1lev1/dir3lev2/.",
|
|
"dir1lev1/dir3lev2/..",
|
|
"dir1lev1/dir3lev2/file3lev3",
|
|
"dir1lev1/dir3lev2/file4lev3",
|
|
"dir2lev1/dir1lev2/.",
|
|
"dir2lev1/dir1lev2/..",
|
|
"dir2lev1/dir1lev2/.dir",
|
|
"dir2lev1/dir1lev2/.foo");
|
|
|
|
test ("*/*/.*", GLOB_ALTDIRFUNC,
|
|
"dir1lev1/dir1lev2/.",
|
|
"dir1lev1/dir1lev2/..",
|
|
"dir1lev1/dir2lev2/.",
|
|
"dir1lev1/dir2lev2/..",
|
|
"dir1lev1/dir2lev2/.foo",
|
|
"dir1lev1/dir3lev2/.",
|
|
"dir1lev1/dir3lev2/..",
|
|
"dir2lev1/dir1lev2/.",
|
|
"dir2lev1/dir1lev2/..",
|
|
"dir2lev1/dir1lev2/.dir",
|
|
"dir2lev1/dir1lev2/.foo");
|
|
|
|
test ("*1*/*2*/.*", GLOB_ALTDIRFUNC,
|
|
"dir1lev1/dir1lev2/.",
|
|
"dir1lev1/dir1lev2/..",
|
|
"dir1lev1/dir2lev2/.",
|
|
"dir1lev1/dir2lev2/..",
|
|
"dir1lev1/dir2lev2/.foo",
|
|
"dir1lev1/dir3lev2/.",
|
|
"dir1lev1/dir3lev2/..",
|
|
"dir2lev1/dir1lev2/.",
|
|
"dir2lev1/dir1lev2/..",
|
|
"dir2lev1/dir1lev2/.dir",
|
|
"dir2lev1/dir1lev2/.foo");
|
|
|
|
test ("*1*/*1*/.*", GLOB_ALTDIRFUNC,
|
|
"dir1lev1/dir1lev2/.",
|
|
"dir1lev1/dir1lev2/..",
|
|
"dir2lev1/dir1lev2/.",
|
|
"dir2lev1/dir1lev2/..",
|
|
"dir2lev1/dir1lev2/.dir",
|
|
"dir2lev1/dir1lev2/.foo");
|
|
|
|
globfree (&gl);
|
|
|
|
return result;
|
|
}
|