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

Update.

Browse Source 
1997-04-09 01:24  Ulrich Drepper  <drepper@cygnus.com>

	* rellns-sh: Rewrite to work also in presence of symlinks.

	* arpg/argp-fmtstream.c: Add casts to prevent warnings.
	* argp/argp-fmtstream.h: Likewise.
	* argp/argp-help.c: Likewise.

	* elf/dl-minimal.c: Add definition of calloc.
	* elf/version.c: Add casts to prevent warnings.
	(_dl_check_map_versions): Use calloc instead of malloc+memset.

	* locale/setlocale.c (_nl_current): Add element with index LC_ALL.
	Reported by Greg McGary <gkm@eng.ascend.com>.

	* manual/libc.texinfo: Update malloc documentation for new malloc.
	* manual/memory.texi: Likewise.
	Patch by Wolfram Gloger <wmglo@dent.med.uni-muenchen.de>.

	* math/libm-test.c (check_long): New function.
	(check_longlong): New function.
	(rinttol_test): New function.
	(rinttoll_test): New function.

	* nis/nss_compat/compat-grp.c (in_blacklist): Improve a bit.
	* nis/nss_compat/compat-pwd.c: Likewise.
	* nis/nss_compat/compat-spwd.c: Likewise.

	* stdlib/erand48_r.c (erand48_r): Build double value using
	ieee754_double union and use random bits in different order to
	increase effect of seed.
	Reported by David Mosberger-Tang <davidm@AZStarNet.com>.

	* sunrpc/svc_auth.c: Moved to ...
	* sysdeps/generic/svc_auth.c: ...here.

	* time/time.h: Pretty print.

1997-04-08 07:19  H.J. Lu  <hjl@gnu.ai.mit.edu>

	* libio/genops.c (_IO_flush_all_linebuffered): don't flush on
	a read-only stream.

1997-04-09 01:19  Ulrich Drepper  <drepper@cygnus.com>

	* malloc/malloc.c (mALLOC_STATs) [MALLOC_DEBUG>1]: Put declaration
	in correct place.
	Patch by Marcus G. Daniels <marcus@cathcart.sysc.pdx.edu>.

1997-04-07 15:34  Ulrich Drepper  <drepper@cygnus.com>

	* stdio-common/Makefile (tests): Add tst-ferror.
	* stdio-common/tst-ferror.c: New file.  Some tests for error
	indicator of streams.
	* stdio-common/tst-ferror.input: New file.

	* isomac.c: Let tests not fail because the compiler defines itself
	symbols which violate the name space rules.  gcc defines symbols
	for the architecture which are not protected by an underscore
	character.

	* math/Makefile (libm-support): Add s_rinttol and s_rinttoll.
	(libm-calls): Add s_clog.
	* sysdeps/libm-ieee754/s_clog.c: New file.  Implementation of
	logarithm of complex value.
	* sysdeps/libm-ieee754/s_clogf.c: New file.
	* sysdeps/libm-ieee754/s_clogl.c: New file.
	* math/libm-test.c (clog_test): Compile this function.  Fix a few
	typos.
	(main): Call clog_test.

	* sysdeps/libm-ieee754/s_rinttol.c: New file.  Round long double
	value to long int.
	* sysdeps/libm-i387/s_rinttol.S: New file.
	* sysdeps/libm-ieee754/s_rinttoll.c: new file.  Round long double
	value to long long int.
	* sysdeps/libm-i387/s_rinttoll.S: New file.

	* sysdeps/libm-ieee754/s_rintl.c: Many corrections.  The previous
	version was full of errors.

	* math/math.h (rinttol): Argument is of type `long double' not
	`double'.
	(rinttoll): Likewise.
	(roundtol): Likewise.
	(roundtoll): Likewise.

1997-04-06 11:32  H.J. Lu  <hjl@gnu.ai.mit.edu>

	* posix/getopt.c (_getopt_initialize): Preserve optind.
	(_getopt_internal): Set optind to 1 if optind == 0 before
	calling _getopt_initialize ().

1997-04-05 16:45  Thorsten Kukuk  <kukuk@vt.uni-paderborn.de>

	* nis/rpcsvc/nislib.h: Change const nis_name to new type
	const_nis_name.
	* nis/nis_intern.c: Likewise.
	* nis/nis_intern.h: Likewise.
	* nis/nis_server.c: Likewise.
	* nis/nis_subr.c: Likewise.
	* nis/nis_table.c: Likewise.
	* nis/nis_names.c: Likewise.  Fill out ns_request structure in
	nis_add().

	* nis/nss_compat/compat-pwd.c: Use reentrant netgroup functions.
	* nis/nss_compat/compat-spwd.c: Likewise.

1997-03-27 07:37  H.J. Lu  <hjl@gnu.ai.mit.edu>

	* libio/fileops.c (_IO_file_overflow): Set error when try to write
	on a read-only stream.

	* sysdeps/gnu/utmpbits.h (ut_xtime): New symbol.
	(ut_time): Define it only if _NO_UT_TIME is not defined.

1997-04-06 00:42  Ulrich Drepper  <drepper@cygnus.com>

	* misc/tst-tsearch.c: Include <string.h>.  Define _GNU_SOURCE only
	if not already defined.

1997-04-05 16:14  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/netatalk/at.h: Include <sys/socket.h> to
	get definition of sa_family_t for <linux/atalk.h>.
	Reported by a sun <asun@zoology.washington.edu>.

	* malloc/malloc.c (cALLOc): Little optimization.
This commit is contained in:
Ulrich Drepper 1997-04-08 23:42:08 +00:00
parent 26dee9c49c
commit c131718ccc
48 changed files with 1748 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.cvsignore
View File

@ -17,3 +17,4 @@ distinfo
crypt crypt
linuxthreads linuxthreads
localedata localedata
secure_rpc

129
ChangeLog
View File

@ -1,3 +1,132 @@
1997-04-09 01:24 Ulrich Drepper <drepper@cygnus.com>
* rellns-sh: Rewrite to work also in presence of symlinks.
* arpg/argp-fmtstream.c: Add casts to prevent warnings.
* argp/argp-fmtstream.h: Likewise.
* argp/argp-help.c: Likewise.
* elf/dl-minimal.c: Add definition of calloc.
* elf/version.c: Add casts to prevent warnings.
(_dl_check_map_versions): Use calloc instead of malloc+memset.
* locale/setlocale.c (_nl_current): Add element with index LC_ALL.
Reported by Greg McGary <gkm@eng.ascend.com>.
* manual/libc.texinfo: Update malloc documentation for new malloc.
* manual/memory.texi: Likewise.
Patch by Wolfram Gloger <wmglo@dent.med.uni-muenchen.de>.
* math/libm-test.c (check_long): New function.
(check_longlong): New function.
(rinttol_test): New function.
(rinttoll_test): New function.
* nis/nss_compat/compat-grp.c (in_blacklist): Improve a bit.
* nis/nss_compat/compat-pwd.c: Likewise.
* nis/nss_compat/compat-spwd.c: Likewise.
* stdlib/erand48_r.c (erand48_r): Build double value using
ieee754_double union and use random bits in different order to
increase effect of seed.
Reported by David Mosberger-Tang <davidm@AZStarNet.com>.
* sunrpc/svc_auth.c: Moved to ...
* sysdeps/generic/svc_auth.c: ...here.
* time/time.h: Pretty print.
1997-04-08 07:19 H.J. Lu <hjl@gnu.ai.mit.edu>
* libio/genops.c (_IO_flush_all_linebuffered): don't flush on
a read-only stream.
1997-04-09 01:19 Ulrich Drepper <drepper@cygnus.com>
* malloc/malloc.c (mALLOC_STATs) [MALLOC_DEBUG>1]: Put declaration
in correct place.
Patch by Marcus G. Daniels <marcus@cathcart.sysc.pdx.edu>.
1997-04-07 15:34 Ulrich Drepper <drepper@cygnus.com>
* stdio-common/Makefile (tests): Add tst-ferror.
* stdio-common/tst-ferror.c: New file. Some tests for error
indicator of streams.
* stdio-common/tst-ferror.input: New file.
* isomac.c: Let tests not fail because the compiler defines itself
symbols which violate the name space rules. gcc defines symbols
for the architecture which are not protected by an underscore
character.
* math/Makefile (libm-support): Add s_rinttol and s_rinttoll.
(libm-calls): Add s_clog.
* sysdeps/libm-ieee754/s_clog.c: New file. Implementation of
logarithm of complex value.
* sysdeps/libm-ieee754/s_clogf.c: New file.
* sysdeps/libm-ieee754/s_clogl.c: New file.
* math/libm-test.c (clog_test): Compile this function. Fix a few
typos.
(main): Call clog_test.
* sysdeps/libm-ieee754/s_rinttol.c: New file. Round long double
value to long int.
* sysdeps/libm-i387/s_rinttol.S: New file.
* sysdeps/libm-ieee754/s_rinttoll.c: new file. Round long double
value to long long int.
* sysdeps/libm-i387/s_rinttoll.S: New file.
* sysdeps/libm-ieee754/s_rintl.c: Many corrections. The previous
version was full of errors.
* math/math.h (rinttol): Argument is of type `long double' not
`double'.
(rinttoll): Likewise.
(roundtol): Likewise.
(roundtoll): Likewise.
1997-04-06 11:32 H.J. Lu <hjl@gnu.ai.mit.edu>
* posix/getopt.c (_getopt_initialize): Preserve optind.
(_getopt_internal): Set optind to 1 if optind == 0 before
calling _getopt_initialize ().
1997-04-05 16:45 Thorsten Kukuk <kukuk@vt.uni-paderborn.de>
* nis/rpcsvc/nislib.h: Change const nis_name to new type
const_nis_name.
* nis/nis_intern.c: Likewise.
* nis/nis_intern.h: Likewise.
* nis/nis_server.c: Likewise.
* nis/nis_subr.c: Likewise.
* nis/nis_table.c: Likewise.
* nis/nis_names.c: Likewise. Fill out ns_request structure in
nis_add().
* nis/nss_compat/compat-pwd.c: Use reentrant netgroup functions.
* nis/nss_compat/compat-spwd.c: Likewise.
1997-03-27 07:37 H.J. Lu <hjl@gnu.ai.mit.edu>
* libio/fileops.c (_IO_file_overflow): Set error when try to write
on a read-only stream.
* sysdeps/gnu/utmpbits.h (ut_xtime): New symbol.
(ut_time): Define it only if _NO_UT_TIME is not defined.
1997-04-06 00:42 Ulrich Drepper <drepper@cygnus.com>
* misc/tst-tsearch.c: Include <string.h>. Define _GNU_SOURCE only
if not already defined.
1997-04-05 16:14 Ulrich Drepper <drepper@cygnus.com>
* sysdeps/unix/sysv/linux/netatalk/at.h: Include <sys/socket.h> to
get definition of sa_family_t for <linux/atalk.h>.
Reported by a sun <asun@zoology.washington.edu>.
* malloc/malloc.c (cALLOc): Little optimization.
1997-04-05 03:11 Ulrich Drepper <drepper@cygnus.com> 1997-04-05 03:11 Ulrich Drepper <drepper@cygnus.com>
* inet/arpa/inet.h: Rewrite. Don't use the ugly BSD way to write * inet/arpa/inet.h: Rewrite. Don't use the ugly BSD way to write

3
PROJECTS
View File

@ -58,10 +58,7 @@ contact <bug-glibc@prep.ai.mit.edu>
- exp2 - exp2
- nearbyint - nearbyint
- ceil
- round - round
- rinttol
- rinttoll
- roundtol - roundtol
- roundtoll - roundtoll

8
argp/argp-fmtstream.c
View File

@ -157,7 +157,7 @@ __argp_fmtstream_update (argp_fmtstream_t fs)
the end of the buffer. */ the end of the buffer. */
nl = fs->p; nl = fs->p;
} }
else if (fs->point_col + (nl - buf) < fs->rmargin) else if (fs->point_col + (nl - buf) < (ssize_t) fs->rmargin)
{ {
/* The buffer contains a full line that fits within the maximum /* The buffer contains a full line that fits within the maximum
line width. Reset point and scan the next line. */ line width. Reset point and scan the next line. */
@ -309,7 +309,7 @@ __argp_fmtstream_update (argp_fmtstream_t fs)
int int
__argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount) __argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
{ {
if (fs->end - fs->p < amount) if ((size_t) (fs->end - fs->p) < amount)
{ {
ssize_t wrote; ssize_t wrote;
@ -330,7 +330,7 @@ __argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
return 0; return 0;
} }
if (fs->end - fs->buf < amount) if ((size_t) (fs->end - fs->buf) < amount)
/* Gotta grow the buffer. */ /* Gotta grow the buffer. */
{ {
size_t new_size = fs->end - fs->buf + amount; size_t new_size = fs->end - fs->buf + amount;
@ -354,7 +354,7 @@ __argp_fmtstream_ensure (struct argp_fmtstream *fs, size_t amount)
ssize_t ssize_t
__argp_fmtstream_printf (struct argp_fmtstream *fs, const char *fmt, ...) __argp_fmtstream_printf (struct argp_fmtstream *fs, const char *fmt, ...)
{ {
size_t out; int out;
size_t size_guess = PRINTF_SIZE_GUESS; /* How much space to reserve. */ size_t size_guess = PRINTF_SIZE_GUESS; /* How much space to reserve. */
do do

8
argp/argp-fmtstream.h
View File

@ -238,7 +238,7 @@ ARGP_FS_EI size_t
__argp_fmtstream_set_lmargin (argp_fmtstream_t __fs, size_t __lmargin) __argp_fmtstream_set_lmargin (argp_fmtstream_t __fs, size_t __lmargin)
{ {
size_t __old; size_t __old;
if (__fs->p - __fs->buf > __fs->point_offs) if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
__argp_fmtstream_update (__fs); __argp_fmtstream_update (__fs);
__old = __fs->lmargin; __old = __fs->lmargin;
__fs->lmargin = __lmargin; __fs->lmargin = __lmargin;
@ -250,7 +250,7 @@ ARGP_FS_EI size_t
__argp_fmtstream_set_rmargin (argp_fmtstream_t __fs, size_t __rmargin) __argp_fmtstream_set_rmargin (argp_fmtstream_t __fs, size_t __rmargin)
{ {
size_t __old; size_t __old;
if (__fs->p - __fs->buf > __fs->point_offs) if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
__argp_fmtstream_update (__fs); __argp_fmtstream_update (__fs);
__old = __fs->rmargin; __old = __fs->rmargin;
__fs->rmargin = __rmargin; __fs->rmargin = __rmargin;
@ -262,7 +262,7 @@ ARGP_FS_EI size_t
__argp_fmtstream_set_wmargin (argp_fmtstream_t __fs, size_t __wmargin) __argp_fmtstream_set_wmargin (argp_fmtstream_t __fs, size_t __wmargin)
{ {
size_t __old; size_t __old;
if (__fs->p - __fs->buf > __fs->point_offs) if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
__argp_fmtstream_update (__fs); __argp_fmtstream_update (__fs);
__old = __fs->wmargin; __old = __fs->wmargin;
__fs->wmargin = __wmargin; __fs->wmargin = __wmargin;
@ -273,7 +273,7 @@ __argp_fmtstream_set_wmargin (argp_fmtstream_t __fs, size_t __wmargin)
ARGP_FS_EI size_t ARGP_FS_EI size_t
__argp_fmtstream_point (argp_fmtstream_t __fs) __argp_fmtstream_point (argp_fmtstream_t __fs)
{ {
if (__fs->p - __fs->buf > __fs->point_offs) if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
__argp_fmtstream_update (__fs); __argp_fmtstream_update (__fs);
return __fs->point_col >= 0 ? __fs->point_col : 0; return __fs->point_col >= 0 ? __fs->point_col : 0;
} }

6
argp/argp-help.c
View File

@ -1086,14 +1086,14 @@ hol_entry_help (struct hol_entry *entry, const struct argp_state *state,
const char *fstr = filter_doc (tstr, real->key, entry->argp, state); const char *fstr = filter_doc (tstr, real->key, entry->argp, state);
if (fstr && *fstr) if (fstr && *fstr)
{ {
unsigned col = __argp_fmtstream_point (stream); unsigned int col = __argp_fmtstream_point (stream);
__argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col); __argp_fmtstream_set_lmargin (stream, uparams.opt_doc_col);
__argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col); __argp_fmtstream_set_wmargin (stream, uparams.opt_doc_col);
if (col > uparams.opt_doc_col + 3) if (col > (unsigned int) (uparams.opt_doc_col + 3))
__argp_fmtstream_putc (stream, '\n'); __argp_fmtstream_putc (stream, '\n');
else if (col >= uparams.opt_doc_col) else if (col >= (unsigned int) uparams.opt_doc_col)
__argp_fmtstream_puts (stream, " "); __argp_fmtstream_puts (stream, " ");
else else
indent_to (stream, uparams.opt_doc_col); indent_to (stream, uparams.opt_doc_col);

13
elf/dl-minimal.c
View File

@ -1,5 +1,5 @@
/* Minimal replacements for basic facilities used in the dynamic linker. /* Minimal replacements for basic facilities used in the dynamic linker.
Copyright (C) 1995, 1996 Free Software Foundation, Inc. Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or The GNU C Library is free software; you can redistribute it and/or
@ -77,6 +77,17 @@ malloc (size_t n)
return alloc_last_block; return alloc_last_block;
} }
/* We use this function occasionally since the real implementation may
be optimized when it can assume the memory it returns already is
set to NUL. */
void * weak_function
calloc (size_t nmemb, size_t size)
{
size_t total = nmemb * size;
void *result = malloc (total);
return memset (result, '\0', total);
}
/* This will rarely be called. */ /* This will rarely be called. */
void weak_function void weak_function
free (void *ptr) free (void *ptr)

8
elf/dl-version.c
View File

@ -199,7 +199,7 @@ _dl_check_map_versions (struct link_map *map, int verbose)
aux->vna_flags & VER_FLG_WEAK); aux->vna_flags & VER_FLG_WEAK);
/* Compare the version index. */ /* Compare the version index. */
if ((aux->vna_other & 0x7fff) > ndx_high) if ((unsigned int) (aux->vna_other & 0x7fff) > ndx_high)
ndx_high = aux->vna_other & 0x7fff; ndx_high = aux->vna_other & 0x7fff;
if (aux->vna_next == 0) if (aux->vna_next == 0)
@ -230,7 +230,7 @@ _dl_check_map_versions (struct link_map *map, int verbose)
ent = (ElfW(Verdef) *) (map->l_addr + def->d_un.d_ptr); ent = (ElfW(Verdef) *) (map->l_addr + def->d_un.d_ptr);
while (1) while (1)
{ {
if ((ent->vd_ndx & 0x7fff) > ndx_high) if ((unsigned int) (ent->vd_ndx & 0x7fff) > ndx_high)
ndx_high = ent->vd_ndx & 0x7fff; ndx_high = ent->vd_ndx & 0x7fff;
if (ent->vd_next == 0) if (ent->vd_next == 0)
@ -247,9 +247,7 @@ _dl_check_map_versions (struct link_map *map, int verbose)
which can be indexed by the version index in the VERSYM which can be indexed by the version index in the VERSYM
section. */ section. */
map->l_versions = (struct r_found_version *) map->l_versions = (struct r_found_version *)
malloc ((ndx_high + 1) * sizeof (*map->l_versions)); calloc (ndx_high + 1, sizeof (*map->l_versions));
memset (map->l_versions, '\0',
(ndx_high + 1) * sizeof (*map->l_versions));
if (map->l_versions == NULL) if (map->l_versions == NULL)
{ {
_dl_signal_error (ENOMEM, (*map->l_name ? map->l_name : _dl_argv[0]), _dl_signal_error (ENOMEM, (*map->l_name ? map->l_name : _dl_argv[0]),

138
isomac.c
View File

@ -67,6 +67,10 @@
will see messages about iso646.h, wctype.h and wchar.h not being will see messages about iso646.h, wctype.h and wchar.h not being
found. */ found. */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -168,18 +172,28 @@ static char *macros[] =
#define NUMBER_OF_SUFFIXES (sizeof suffix / sizeof *suffix) #define NUMBER_OF_SUFFIXES (sizeof suffix / sizeof *suffix)
#define NUMBER_OF_MACROS (sizeof macros / sizeof *macros) #define NUMBER_OF_MACROS (sizeof macros / sizeof *macros)
/* Format string to build command to invoke compiler. */
static const char fmt[] = "\
echo \"#include <%s>\" |\
%s -E -dM -ansi -pedantic %s -D_LIBC -I. -I `%s --print-prog-name=include` -\
> %s";
/* The compiler we use (given on the command line). */ /* The compiler we use (given on the command line). */
char *CC; char *CC;
/* The -I parameters for CC to find all headers. */ /* The -I parameters for CC to find all headers. */
char *INC; char *INC;
static int check_header (const char *); static const char **get_null_defines (void);
static int check_header (const char *, const char **);
int int
main (int argc, char *argv[]) main (int argc, char *argv[])
{ {
int h; int h;
int result = 0; int result = 0;
const char **ignore_list;
CC = argc > 1 ? argv[1] : "gcc"; CC = argc > 1 ? argv[1] : "gcc";
INC = argc > 2 ? argv[2] : ""; INC = argc > 2 ? argv[2] : "";
@ -190,44 +204,107 @@ main (int argc, char *argv[])
return EXIT_FAILURE; return EXIT_FAILURE;
} }
/* First get list of symbols which are defined by the compiler. */
ignore_list = get_null_defines ();
for (h = 0; h < NUMBER_OF_HEADERS; ++h) for (h = 0; h < NUMBER_OF_HEADERS; ++h)
{ {
char file_name[HEADER_MAX]; char file_name[HEADER_MAX];
sprintf (file_name, "%s.h", header[h]); sprintf (file_name, "%s.h", header[h]);
result |= check_header (file_name); result |= check_header (file_name, ignore_list);
} }
#if 0
/* The test suite should return errors but for now this is not /* The test suite should return errors but for now this is not
practical. Give a warning and ask the user to correct the bugs. */ practical. Give a warning and ask the user to correct the bugs. */
return result; return result;
#else
if (result)
fputs ("\
##########################################################################\n\
# The test suite found some problems with your system (see the generated #\n\
# isomac.out file). These are all violations of the ISO C rules and #\n\
# should be corrected. If the problem is in the libc, report it using #\n\
# the glibcbug script to <bugs@gnu.ai.mit.edu>. If it is a problem with #\n\
# your compiler, contact the compiler manufacturer. #\n\
##########################################################################\n",
stderr);
return 0;
#endif
} }
static const char **
get_null_defines (void)
{
char line[BUFSIZ], *command;
char **result = NULL;
size_t result_len = 0;
size_t result_max = 0;
FILE *input;
int first = 1;
command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
+ strlen (INC) + strlen (TMPFILE));
if (command == NULL)
{
puts ("No more memory.");
exit (1);
}
sprintf (command, fmt, "/dev/null", CC, INC, CC, TMPFILE);
if (system (command))
{
puts ("system() returned nonzero");
return NULL;
}
free (command);
input = fopen (TMPFILE, "r");
if (input == NULL)
{
printf ("Could not read %s: ", TMPFILE);
perror (NULL);
return NULL;
}
while (fgets (line, sizeof line, input) != NULL)
{
int i, okay = 0;
size_t endmac;
char *start, *end;
if (strlen (line) < 9 || line[7] != ' ')
{ /* "#define A" */
printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
line);
continue;
}
if (line[8] == '_')
/* It's a safe identifier. */
continue;
if (result_len == result_max)
{
result_max += 10;
result = realloc (result, result_max * sizeof (char **));
if (result == NULL)
{
puts ("No more memory.");
exit (1);
}
}
start = &line[8];
for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
;
result[result_len++] = strndup (start, end - start);
if (first)
{
fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
first = 0;
}
puts (result[result_len - 1]);
}
fclose (input);
remove (TMPFILE);
return (const char **) result;
}
static int static int
check_header (const char *file_name) check_header (const char *file_name, const char **except)
{ {
char line[BUFSIZ], *command; char line[BUFSIZ], *command;
FILE *input; FILE *input;
int result = 0; int result = 0;
static const char fmt[] = "\
echo \"#include <%s>\" |\
%s -E -dM -ansi -pedantic %s -D_LIBC -I. -I `%s --print-prog-name=include` -\
> %s";
command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC) command = malloc (sizeof fmt + strlen (file_name) + 2 * strlen (CC)
+ strlen (INC) + strlen (TMPFILE)); + strlen (INC) + strlen (TMPFILE));
@ -260,6 +337,7 @@ echo \"#include <%s>\" |\
{ {
int i, okay = 0; int i, okay = 0;
size_t endmac; size_t endmac;
const char **cpp;
if (strlen (line) < 9 || line[7] != ' ') if (strlen (line) < 9 || line[7] != ' ')
{ /* "#define A" */ { /* "#define A" */
printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n", printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
@ -278,7 +356,7 @@ echo \"#include <%s>\" |\
continue; continue;
for (i = 0; i < NUMBER_OF_MACROS; ++i) for (i = 0; i < NUMBER_OF_MACROS; ++i)
{ {
if (!strncmp (line+8, macros[i], strlen (macros[i]))) if (!strncmp (line + 8, macros[i], strlen (macros[i])))
{ {
++okay; ++okay;
break; break;
@ -305,6 +383,18 @@ echo \"#include <%s>\" |\
break; break;
} }
} }
if (okay)
continue;
if (except != NULL)
for (cpp = except; *cpp != NULL; ++cpp)
{
size_t len = strlen (*cpp);
if (!strncmp (line + 8, *cpp, len) && isspace (line[8 + len]))
{
++okay;
break;
}
}
if (!okay) if (!okay)
{ {
fputs (line, stdout); fputs (line, stdout);

1
libio/fileops.c
View File

@ -317,6 +317,7 @@ DEFUN(_IO_file_overflow, (f, ch),
{ {
if (f->_flags & _IO_NO_WRITES) /* SET ERROR */ if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
{ {
f->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF); __set_errno (EBADF);
return EOF; return EOF;
} }

3
locale/setlocale.c
View File

@ -49,6 +49,9 @@ static struct locale_data * *const _nl_current[] =
[category] = &_nl_current_##category, [category] = &_nl_current_##category,
#include "categories.def" #include "categories.def"
#undef DEFINE_CATEGORY #undef DEFINE_CATEGORY
/* We need this additional element to simplify the code. It must
simply be != NULL. */
[LC_ALL] = (struct locale_data **) ~0ul
}; };
/* Array indexed by category of pointers to _nl_C_CATEGORY slots. /* Array indexed by category of pointers to _nl_C_CATEGORY slots.

7
malloc/malloc.c
View File

@ -3306,11 +3306,11 @@ Void_t* cALLOc(n, elem_size) size_t n; size_t elem_size;
if(mem == 0) if(mem == 0)
return 0; return 0;
#ifdef HAVE_MEMCPY #ifdef HAVE_MEMCPY
memset(mem, 0, sz); return memset(mem, 0, sz);
#else #else
while(sz > 0) ((char*)mem)[--sz] = 0; /* rather inefficient */ while(sz > 0) ((char*)mem)[--sz] = 0; /* rather inefficient */
#endif
return mem; return mem;
#endif
} }
#endif #endif
@ -3692,8 +3692,9 @@ void mALLOC_STATs()
#endif #endif
#if !defined(NO_THREADS) && MALLOC_DEBUG > 1 #if !defined(NO_THREADS) && MALLOC_DEBUG > 1
if(ar_ptr != &main_arena) { if(ar_ptr != &main_arena) {
heap_info *heap;
(void)mutex_lock(&ar_ptr->mutex); (void)mutex_lock(&ar_ptr->mutex);
heap_info *heap = heap_for_ptr(top(ar_ptr)); heap = heap_for_ptr(top(ar_ptr));
while(heap) { dump_heap(heap); heap = heap->prev; } while(heap) { dump_heap(heap); heap = heap->prev; }
(void)mutex_unlock(&ar_ptr->mutex); (void)mutex_unlock(&ar_ptr->mutex);
} }

1
manual/libc.texinfo
View File

@ -210,7 +210,6 @@ Memory Allocation
calling function returns. calling function returns.
* Relocating Allocator:: Waste less memory, if you can tolerate * Relocating Allocator:: Waste less memory, if you can tolerate
automatic relocation of the blocks you get. automatic relocation of the blocks you get.
* Memory Warnings:: Getting warnings when memory is nearly full.
Unconstrained Allocation Unconstrained Allocation

175
manual/memory.texi
View File

@ -38,7 +38,6 @@ will be freed automatically. @xref{Variable Size Automatic}.
calling function returns. calling function returns.
* Relocating Allocator:: Waste less memory, if you can tolerate * Relocating Allocator:: Waste less memory, if you can tolerate
automatic relocation of the blocks you get. automatic relocation of the blocks you get.
* Memory Warnings:: Getting warnings when memory is nearly full.
@end menu @end menu
@node Memory Concepts @node Memory Concepts
@ -140,6 +139,8 @@ any time (or never).
these functions. these functions.
* Aligned Memory Blocks:: Allocating specially aligned memory: * Aligned Memory Blocks:: Allocating specially aligned memory:
@code{memalign} and @code{valloc}. @code{memalign} and @code{valloc}.
* Malloc Tunable Parameters:: Use @code{mallopt} to adjust allocation
parameters.
* Heap Consistency Checking:: Automatic checking for errors. * Heap Consistency Checking:: Automatic checking for errors.
* Hooks for Malloc:: You can use these hooks for debugging * Hooks for Malloc:: You can use these hooks for debugging
programs that use @code{malloc}. programs that use @code{malloc}.
@ -238,10 +239,10 @@ savestring (const char *ptr, size_t len)
The block that @code{malloc} gives you is guaranteed to be aligned so The block that @code{malloc} gives you is guaranteed to be aligned so
that it can hold any type of data. In the GNU system, the address is that it can hold any type of data. In the GNU system, the address is
always a multiple of eight; if the size of block is 16 or more, then the always a multiple of eight on most systems, and a multiple of 16 on
address is always a multiple of 16. Only rarely is any higher boundary 64-bit systems. Only rarely is any higher boundary (such as a page
(such as a page boundary) necessary; for those cases, use boundary) necessary; for those cases, use @code{memalign} or
@code{memalign} or @code{valloc} (@pxref{Aligned Memory Blocks}). @code{valloc} (@pxref{Aligned Memory Blocks}).
Note that the memory located after the end of the block is likely to be Note that the memory located after the end of the block is likely to be
in use for something else; perhaps a block already allocated by another in use for something else; perhaps a block already allocated by another
@ -368,9 +369,11 @@ xrealloc (void *ptr, size_t size)
@end smallexample @end smallexample
You can also use @code{realloc} to make a block smaller. The reason you You can also use @code{realloc} to make a block smaller. The reason you
would do this is to avoid tying up a lot of memory space when only a little is needed.
is needed. Making a block smaller sometimes necessitates copying it, so it @comment The following is no longer true with the new malloc.
can fail if no other space is available. @comment But it seems wise to keep the warning for other implementations.
In several allocation implementations, making a block smaller sometimes
necessitates copying it, so it can fail if no other space is available.
If the new size you specify is the same as the old size, @code{realloc} If the new size you specify is the same as the old size, @code{realloc}
is guaranteed to change nothing and return the same address that you gave. is guaranteed to change nothing and return the same address that you gave.
@ -404,10 +407,18 @@ calloc (size_t count, size_t eltsize)
@} @}
@end smallexample @end smallexample
But in general, it is not guaranteed that @code{calloc} calls
@code{malloc} internally. Therefore, if an application provides its own
@code{malloc}/@code{realloc}/@code{free} outside the C library, it
should always define @code{calloc}, too.
@node Efficiency and Malloc @node Efficiency and Malloc
@subsection Efficiency Considerations for @code{malloc} @subsection Efficiency Considerations for @code{malloc}
@cindex efficiency and @code{malloc} @cindex efficiency and @code{malloc}
@ignore
@c No longer true, see below instead.
To make the best use of @code{malloc}, it helps to know that the GNU To make the best use of @code{malloc}, it helps to know that the GNU
version of @code{malloc} always dispenses small amounts of memory in version of @code{malloc} always dispenses small amounts of memory in
blocks whose sizes are powers of two. It keeps separate pools for each blocks whose sizes are powers of two. It keeps separate pools for each
@ -433,6 +444,24 @@ time using it. Also, large blocks are normally fewer in number.
Therefore, for large blocks, it makes sense to use a method which takes Therefore, for large blocks, it makes sense to use a method which takes
more time to minimize the wasted space. more time to minimize the wasted space.
@end ignore
As apposed to other versions, the @code{malloc} in GNU libc does not
round up block sizes to powers of two, neither for large nor for small
sizes. Neighboring chunks can be coalesced on a @code{free} no matter
what their size is. This makes the implementation suitable for all
kinds of allocation patterns without generally incurring high memory
waste through fragmentation.
Very large blocks (much larger than a page) are allocated with
@code{mmap} (anonymous or via @code{/dev/zero}) by this implementation.
This has the great advantage that these chunks are returned to the
system immediately when they are freed. Therefore, it cannot happen
that a large chunk becomes ``locked'' in between smaller ones and even
after calling @code{free} wastes memory. The size threshold for
@code{mmap} to be used can be adjusted with @code{mallopt}. The use of
@code{mmap} can also be disabled completely.
@node Aligned Memory Blocks @node Aligned Memory Blocks
@subsection Allocating Aligned Memory Blocks @subsection Allocating Aligned Memory Blocks
@ -440,10 +469,10 @@ more time to minimize the wasted space.
@cindex alignment (with @code{malloc}) @cindex alignment (with @code{malloc})
@pindex stdlib.h @pindex stdlib.h
The address of a block returned by @code{malloc} or @code{realloc} in The address of a block returned by @code{malloc} or @code{realloc} in
the GNU system is always a multiple of eight. If you need a block whose the GNU system is always a multiple of eight (or sixteen on 64-bit
address is a multiple of a higher power of two than that, use systems). If you need a block whose address is a multiple of a higher
@code{memalign} or @code{valloc}. These functions are declared in power of two than that, use @code{memalign} or @code{valloc}. These
@file{stdlib.h}. functions are declared in @file{stdlib.h}.
With the GNU library, you can use @code{free} to free the blocks that With the GNU library, you can use @code{free} to free the blocks that
@code{memalign} and @code{valloc} return. That does not work in BSD, @code{memalign} and @code{valloc} return. That does not work in BSD,
@ -454,9 +483,9 @@ however---BSD does not provide any way to free such blocks.
@deftypefun {void *} memalign (size_t @var{boundary}, size_t @var{size}) @deftypefun {void *} memalign (size_t @var{boundary}, size_t @var{size})
The @code{memalign} function allocates a block of @var{size} bytes whose The @code{memalign} function allocates a block of @var{size} bytes whose
address is a multiple of @var{boundary}. The @var{boundary} must be a address is a multiple of @var{boundary}. The @var{boundary} must be a
power of two! The function @code{memalign} works by calling power of two! The function @code{memalign} works by allocating a
@code{malloc} to allocate a somewhat larger block, and then returning an somewhat larger block, and then returning an address within the block
address within the block that is on the specified boundary. that is on the specified boundary.
@end deftypefun @end deftypefun
@comment malloc.h stdlib.h @comment malloc.h stdlib.h
@ -475,6 +504,42 @@ valloc (size_t size)
@c !!! xref getpagesize @c !!! xref getpagesize
@end deftypefun @end deftypefun
@node Malloc Tunable Parameters
@subsection Malloc Tunable Parameters
You can adjust some parameters for dynamic memory allocation with the
@code{mallopt} function. This function is the general SVID/XPG
interface, defined in @file{malloc.h}.
@pindex malloc.h
@deftypefun int mallopt (int @var{param}, int @var{value})
When calling @code{mallopt}, the @var{param} argument specifies the
parameter to be set, and @var{value} the new value to be set. Possible
choices for @var{param}, as defined in @file{malloc.h}, are:
@table @code
@item M_TRIM_THRESHOLD
This is the minimum size (in bytes) of the top-most, releaseable chunk
that will cause @code{sbrk} to be called with a negative argument in
order to return memory to the system.
@item M_TOP_PAD
This parameter determines the amount of extra memory to obtain from the
system when a call to @code{sbrk} is required. It also specifies the
number of bytes to retain when shrinking the heap by calling @code{sbrk}
with a negative argument. This provides the necessary hysteresis in
heap size such that excessive amounts of system calls can be avoided.
@item M_MMAP_THRESHOLD
All chunks larger than this value are allocated outside the normal
heap, using the @code{mmap} system call. This way it is guaranteed
that the memory for these chunks can be returned to the system on
@code{free}.
@item M_MMAP_MAX
The maximum number of chunks to allocate with @code{mmap}. Setting this
to zero disables all use of @code{mmap}.
@end table
@end deftypefun
@node Heap Consistency Checking @node Heap Consistency Checking
@subsection Heap Consistency Checking @subsection Heap Consistency Checking
@ -636,44 +701,62 @@ installing such hooks.
@cindex allocation statistics @cindex allocation statistics
You can get information about dynamic storage allocation by calling the You can get information about dynamic storage allocation by calling the
@code{mstats} function. This function and its associated data type are @code{mallinfo} function. This function and its associated data type
declared in @file{malloc.h}; they are a GNU extension. are declared in @file{malloc.h}; they are an extension of the standard
SVID/XPG version.
@pindex malloc.h @pindex malloc.h
@comment malloc.h @comment malloc.h
@comment GNU @comment GNU
@deftp {Data Type} {struct mstats} @deftp {Data Type} {struct mallinfo}
This structure type is used to return information about the dynamic This structure type is used to return information about the dynamic
storage allocator. It contains the following members: storage allocator. It contains the following members:
@table @code @table @code
@item size_t bytes_total @item int arena
This is the total size of memory managed by @code{malloc}, in bytes. This is the total size of memory allocated with @code{sbrk} by
@code{malloc}, in bytes.
@item size_t chunks_used @item int ordblks
This is the number of chunks in use. (The storage allocator internally This is the number of chunks not in use. (The storage allocator
gets chunks of memory from the operating system, and then carves them up internally gets chunks of memory from the operating system, and then
to satisfy individual @code{malloc} requests; see @ref{Efficiency and carves them up to satisfy individual @code{malloc} requests; see
Malloc}.) @ref{Efficiency and Malloc}.)
@item size_t bytes_used @item int smblks
This is the number of bytes in use. This field is unused.
@item size_t chunks_free @item int hblks
This is the number of chunks which are free -- that is, that have been This is the total number of chunks allocated with @code{mmap}.
allocated by the operating system to your program, but which are not
now being used. @item int hblkhd
This is the total size of memory allocated with @code{mmap}, in bytes.
@item int usmblks
This field is unused.
@item int fsmblks
This field is unused.
@item int uordblks
This is the total size of memory occupied by chunks handed out by
@code{malloc}.
@item int fordblks
This is the total size of memory occupied by free (not in use) chunks.
@item int keepcost
This is the size of the top-most, releaseable chunk that normally
borders the end of the heap (i.e. the ``brk'' of the process).
@item size_t bytes_free
This is the number of bytes which are free.
@end table @end table
@end deftp @end deftp
@comment malloc.h @comment malloc.h
@comment GNU @comment SVID
@deftypefun {struct mstats} mstats (void) @deftypefun {struct mallinfo} mallinfo (void)
This function returns information about the current dynamic memory usage This function returns information about the current dynamic memory usage
in a structure of type @code{struct mstats}. in a structure of type @code{struct mallinfo}.
@end deftypefun @end deftypefun
@node Summary of Malloc @node Summary of Malloc
@ -706,6 +789,9 @@ Allocate a block of @var{size} bytes, starting on a page boundary.
Allocate a block of @var{size} bytes, starting on an address that is a Allocate a block of @var{size} bytes, starting on an address that is a
multiple of @var{boundary}. @xref{Aligned Memory Blocks}. multiple of @var{boundary}. @xref{Aligned Memory Blocks}.
@item int mallopt (int @var{param}, int @var{value})
Adjust a tunable parameter. @xref{Malloc Tunable Parameters}
@item int mcheck (void (*@var{abortfn}) (void)) @item int mcheck (void (*@var{abortfn}) (void))
Tell @code{malloc} to perform occasional consistency checks on Tell @code{malloc} to perform occasional consistency checks on
dynamically allocated memory, and to call @var{abortfn} when an dynamically allocated memory, and to call @var{abortfn} when an
@ -720,7 +806,7 @@ A pointer to a function that @code{realloc} uses whenever it is called.
@item void (*__free_hook) (void *@var{ptr}) @item void (*__free_hook) (void *@var{ptr})
A pointer to a function that @code{free} uses whenever it is called. A pointer to a function that @code{free} uses whenever it is called.
@item struct mstats mstats (void) @item struct mallinfo mallinfo (void)
Return information about the current dynamic memory usage. Return information about the current dynamic memory usage.
@xref{Statistics of Malloc}. @xref{Statistics of Malloc}.
@end table @end table
@ -1744,10 +1830,13 @@ If enough memory is not available, this function returns a null pointer
and does not modify @code{*@var{handleptr}}. and does not modify @code{*@var{handleptr}}.
@end deftypefun @end deftypefun
@node Memory Warnings @ignore
@section Memory Usage Warnings @comment No longer available...
@cindex memory usage warnings
@cindex warnings of memory almost full @comment @node Memory Warnings
@comment @section Memory Usage Warnings
@comment @cindex memory usage warnings
@comment @cindex warnings of memory almost full
@pindex malloc.c @pindex malloc.c
You can ask for warnings as the program approaches running out of memory You can ask for warnings as the program approaches running out of memory
@ -1757,7 +1846,7 @@ system. This is a GNU extension declared in @file{malloc.h}.
@comment malloc.h @comment malloc.h
@comment GNU @comment GNU
@deftypefun void memory_warnings (void *@var{start}, void (*@var{warn-func}) (const char *)) @comment @deftypefun void memory_warnings (void *@var{start}, void (*@var{warn-func}) (const char *))
Call this function to request warnings for nearing exhaustion of virtual Call this function to request warnings for nearing exhaustion of virtual
memory. memory.
@ -1775,3 +1864,5 @@ Normally it ought to display the string for the user to read.
The warnings come when memory becomes 75% full, when it becomes 85% The warnings come when memory becomes 75% full, when it becomes 85%
full, and when it becomes 95% full. Above 95% you get another warning full, and when it becomes 95% full. Above 95% you get another warning
each time memory usage increases. each time memory usage increases.
@end ignore

5
math/Makefile
View File

@ -35,7 +35,8 @@ aux := fpu_control setfpucw
extra-libs := libm extra-libs := libm
extra-libs-others = $(extra-libs) extra-libs-others = $(extra-libs)
libm-support = k_standard s_lib_version s_matherr s_signgam libm-support = k_standard s_lib_version s_matherr s_signgam \
s_rinttol s_rinttoll
libm-calls = e_acos e_acosh e_asin e_atan2 e_atanh e_cosh e_exp e_fmod \ libm-calls = e_acos e_acosh e_asin e_atan2 e_atanh e_cosh e_exp e_fmod \
e_hypot e_j0 e_j1 e_jn e_lgamma_r e_log e_log10 e_pow \ e_hypot e_j0 e_j1 e_jn e_lgamma_r e_log e_log10 e_pow \
e_rem_pio2 e_remainder e_scalb e_sinh e_sqrt k_cos \ e_rem_pio2 e_remainder e_scalb e_sinh e_sqrt k_cos \
@ -49,7 +50,7 @@ libm-calls = e_acos e_acosh e_asin e_atan2 e_atanh e_cosh e_exp e_fmod \
w_log w_log10 w_pow w_remainder w_scalb w_sinh w_sqrt \ w_log w_log10 w_pow w_remainder w_scalb w_sinh w_sqrt \
s_signbit s_fpclassify s_fmax s_fmin s_fdim s_nan s_trunc \ s_signbit s_fpclassify s_fmax s_fmin s_fdim s_nan s_trunc \
s_remquo s_log2 s_exp2 \ s_remquo s_log2 s_exp2 \
conj cimag creal cabs carg s_cexp s_csinh s_ccosh conj cimag creal cabs carg s_cexp s_csinh s_ccosh s_clog
libm-routines = $(libm-support) $(libm-calls) \ libm-routines = $(libm-support) $(libm-calls) \
$(patsubst %_rf,%f_r,$(libm-calls:=f)) \ $(patsubst %_rf,%f_r,$(libm-calls:=f)) \
$(long-m-$(long-double-fcts)) $(long-m-$(long-double-fcts))

109
math/libm-test.c
View File

@ -366,6 +366,63 @@ check_bool (const char *test_name, int computed)
} }
static void
check_long (const char *test_name, long int computed, long int expected)
{
long int diff = computed - expected;
int result = diff == 0;
if (result)
{
if (verbose > 2)
printf ("Pass: %s\n", test_name);
}
else
{
if (verbose)
printf ("Fail: %s\n", test_name);
if (verbose > 1)
{
printf ("Result:\n");
printf (" is: %ld\n", computed);
printf (" should be: %ld\n", expected);
}
noErrors++;
}
fpstack_test (test_name);
}
static void
check_longlong (const char *test_name, long long int computed,
long long int expected)
{
long long int diff = computed - expected;
int result = diff == 0;
if (result)
{
if (verbose > 2)
printf ("Pass: %s\n", test_name);
}
else
{
if (verbose)
printf ("Fail: %s\n", test_name);
if (verbose > 1)
{
printf ("Result:\n");
printf (" is: %lld\n", computed);
printf (" should be: %lld\n", expected);
}
noErrors++;
}
fpstack_test (test_name);
}
static void static void
check_isnan (const char *test_name, MATHTYPE computed) check_isnan (const char *test_name, MATHTYPE computed)
{ {
@ -2485,6 +2542,7 @@ ctanh_test (void)
check_isnan ("real(ctanh(NaN + i NaN)) = NaN", __real__ result); check_isnan ("real(ctanh(NaN + i NaN)) = NaN", __real__ result);
check_isnan ("imag(ctanh(NaN + i NaN)) = NaN", __imag__ result); check_isnan ("imag(ctanh(NaN + i NaN)) = NaN", __imag__ result);
} }
#endif
static void static void
@ -2504,7 +2562,7 @@ clog_test (void)
check ("imag(clog(0 + i0)) = 0", __imag__ result, 0); check ("imag(clog(0 + i0)) = 0", __imag__ result, 0);
result = FUNC(clog) (BUILD_COMPLEX (0, minus_zero)); result = FUNC(clog) (BUILD_COMPLEX (0, minus_zero));
check_isinfn ("real(clog(0 - i0)) = -Inf", __real__ result); check_isinfn ("real(clog(0 - i0)) = -Inf", __real__ result);
check ("imag(clog(0 - i0)) = -0", __imag__ result, -minus_zero); check ("imag(clog(0 - i0)) = -0", __imag__ result, minus_zero);
result = FUNC(clog) (BUILD_COMPLEX (minus_infty, plus_infty)); result = FUNC(clog) (BUILD_COMPLEX (minus_infty, plus_infty));
check_isinfp ("real(clog(-Inf + i Inf)) = +Inf", __real__ result); check_isinfp ("real(clog(-Inf + i Inf)) = +Inf", __real__ result);
@ -2566,10 +2624,10 @@ clog_test (void)
check ("imag(clog(+Inf + i1)) = 0", __imag__ result, 0); check ("imag(clog(+Inf + i1)) = 0", __imag__ result, 0);
result = FUNC(clog) (BUILD_COMPLEX (plus_infty, minus_zero)); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, minus_zero));
check_isinfp ("real(clog(+Inf - i0)) = +Inf", __real__ result); check_isinfp ("real(clog(+Inf - i0)) = +Inf", __real__ result);
check ("imag(clog(+Inf - i0)) = -0", __imag__ result, -0); check ("imag(clog(+Inf - i0)) = -0", __imag__ result, minus_zero);
result = FUNC(clog) (BUILD_COMPLEX (plus_infty, -1)); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, -1));
check_isinfp ("real(clog(+Inf - i1)) = +Inf", __real__ result); check_isinfp ("real(clog(+Inf - i1)) = +Inf", __real__ result);
check ("imag(clog(+Inf - i1)) = -0", __imag__ result, -0); check ("imag(clog(+Inf - i1)) = -0", __imag__ result, minus_zero);
result = FUNC(clog) (BUILD_COMPLEX (plus_infty, nan_value)); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, nan_value));
check_isinfp ("real(clog(+Inf + i NaN)) = +Inf", __real__ result); check_isinfp ("real(clog(+Inf + i NaN)) = +Inf", __real__ result);
@ -2617,6 +2675,7 @@ clog_test (void)
} }
#if 0
static void static void
csqrt_test (void) csqrt_test (void)
{ {
@ -2740,6 +2799,46 @@ csqrt_test (void)
#endif #endif
static void
rinttol_test (void)
{
/* XXX this test is incomplete. We need to have a way to specifiy
the rounding method and test the critical cases. So far, only
unproblematic numbers are tested. */
check_long ("rinttol(0) = 0", 0.0, 0);
check_long ("rinttol(-0) = 0", minus_zero, 0);
check_long ("rinttol(0.2) = 0", 0.2, 0);
check_long ("rinttol(-0.2) = 0", -0.2, 0);
check_long ("rinttol(1.4) = 1", 1.4, 1);
check_long ("rinttol(-1.4) = -1", -1.4, -1);
check_long ("rinttol(8388600.3) = 8388600", 8388600.3, 8388600);
check_long ("rinttol(-8388600.3) = -8388600", -8388600.3, -8388600);
}
static void
rinttoll_test (void)
{
/* XXX this test is incomplete. We need to have a way to specifiy
the rounding method and test the critical cases. So far, only
unproblematic numbers are tested. */
check_longlong ("rinttoll(0) = 0", 0.0, 0);
check_longlong ("rinttoll(-0) = 0", minus_zero, 0);
check_longlong ("rinttoll(0.2) = 0", 0.2, 0);
check_longlong ("rinttoll(-0.2) = 0", -0.2, 0);
check_longlong ("rinttoll(1.4) = 1", 1.4, 1);
check_longlong ("rinttoll(-1.4) = -1", -1.4, -1);
check_longlong ("rinttoll(8388600.3) = 8388600", 8388600.3, 8388600);
check_longlong ("rinttoll(-8388600.3) = -8388600", -8388600.3, -8388600);
}
static void static void
inverse_func_pair_test (const char *test_name, inverse_func_pair_test (const char *test_name,
mathfunc f1, mathfunc inverse, mathfunc f1, mathfunc inverse,
@ -3070,6 +3169,10 @@ main (int argc, char *argv[])
cexp_test (); cexp_test ();
csinh_test (); csinh_test ();
ccosh_test (); ccosh_test ();
clog_test ();
rinttol_test ();
rinttoll_test ();
identities (); identities ();
inverse_functions (); inverse_functions ();

8
math/math.h
View File

@ -163,13 +163,13 @@ enum
/* Round X to nearest integral value according to current rounding /* Round X to nearest integral value according to current rounding
direction. */ direction. */
extern long int rinttol __P ((double __x)); extern long int rinttol __P ((long double __x));
extern long long int rinttoll __P ((double __x)); extern long long int rinttoll __P ((long double __x));
/* Round X to nearest integral value, rounding halfway cases away from /* Round X to nearest integral value, rounding halfway cases away from
zero. */ zero. */
extern long int roundtol __P ((double __x)); extern long int roundtol __P ((long double __x));
extern long long int roundtoll __P ((double __x)); extern long long int roundtoll __P ((long double __x));
/* Comparison macros. */ /* Comparison macros. */

5
misc/tst-tsearch.c
View File

@ -17,10 +17,13 @@
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */ Boston, MA 02111-1307, USA. */
#define _GNU_SOURCE 1 #ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <search.h> #include <search.h>
#define SEED 0 #define SEED 0

8
nis/nis_intern.c
View File

@ -25,7 +25,7 @@
/* Nearly the same as nis_getnames, but nis_getnames stopped /* Nearly the same as nis_getnames, but nis_getnames stopped
when 2 points left */ when 2 points left */
nis_name * nis_name *
__nis_expandname (const nis_name name) __nis_expandname (const char *name)
{ {
nis_name *getnames = NULL; nis_name *getnames = NULL;
char local_domain[NIS_MAXNAMELEN + 1]; char local_domain[NIS_MAXNAMELEN + 1];
@ -145,13 +145,13 @@ __nis_expandname (const nis_name name)
} }
fd_result * fd_result *
__nis_finddirectoy (nis_name dir_name) __nis_finddirectoy (const_nis_name name)
{ {
fd_args args; fd_args args;
nis_error status; nis_error status;
fd_result *res; fd_result *res;
args.dir_name = dir_name; args.dir_name = (char *) name;
args.requester = nis_local_principal (); args.requester = nis_local_principal ();
res = calloc (1, sizeof (fd_result)); res = calloc (1, sizeof (fd_result));
@ -160,7 +160,7 @@ __nis_finddirectoy (nis_name dir_name)
if ((status = __do_niscall (NULL, 0, NIS_FINDDIRECTORY, if ((status = __do_niscall (NULL, 0, NIS_FINDDIRECTORY,
(xdrproc_t) xdr_fd_args, (xdrproc_t) xdr_fd_args,
(caddr_t) & args, (caddr_t) &args,
(xdrproc_t) xdr_fd_result, (xdrproc_t) xdr_fd_result,
(caddr_t) res, 0)) != RPC_SUCCESS) (caddr_t) res, 0)) != RPC_SUCCESS)
res->status = status; res->status = status;

2
nis/nis_intern.h
View File

@ -31,7 +31,7 @@ extern nis_error __do_niscall (__const nis_server *server, int server_len,
extern AUTH *authdes_pk_create (const char *, const netobj *, u_int, extern AUTH *authdes_pk_create (const char *, const netobj *, u_int,
struct sockaddr *, des_block *); struct sockaddr *, des_block *);
#endif #endif
extern nis_name *__nis_expandname (__const nis_name); extern nis_name *__nis_expandname (const char *);
__END_DECLS __END_DECLS

44
nis/nis_names.c
View File

@ -25,7 +25,7 @@
#include "nis_intern.h" #include "nis_intern.h"
nis_result * nis_result *
nis_lookup (const nis_name name, const u_long flags) nis_lookup (const_nis_name name, const u_long flags)
{ {
nis_result *res; nis_result *res;
struct ns_request req; struct ns_request req;
@ -106,7 +106,7 @@ nis_lookup (const nis_name name, const u_long flags)
} }
else else
{ {
req.ns_name = name; req.ns_name = (char *)name;
while (is_link) while (is_link)
{ {
@ -116,7 +116,7 @@ nis_lookup (const nis_name name, const u_long flags)
if ((status = __do_niscall (NULL, 0, NIS_LOOKUP, if ((status = __do_niscall (NULL, 0, NIS_LOOKUP,
(xdrproc_t) xdr_ns_request, (xdrproc_t) xdr_ns_request,
(caddr_t) & req, (caddr_t) &req,
(xdrproc_t) xdr_nis_result, (xdrproc_t) xdr_nis_result,
(caddr_t) res, flags)) != RPC_SUCCESS) (caddr_t) res, flags)) != RPC_SUCCESS)
{ {
@ -158,31 +158,55 @@ nis_lookup (const nis_name name, const u_long flags)
} }
nis_result * nis_result *
nis_add (const nis_name name, const nis_object *obj) nis_add (const_nis_name name, const nis_object *obj)
{ {
nis_result *res; nis_result *res;
nis_error status; nis_error status;
struct ns_request req; struct ns_request req;
char *p1, *p2, *p3, *p4;
char buf1 [strlen (name) + 20];
char buf4 [strlen (name) + 20];
res = calloc (1, sizeof (nis_result)); res = calloc (1, sizeof (nis_result));
req.ns_name = name; req.ns_name = (char *)name;
req.ns_object.ns_object_len = 1; req.ns_object.ns_object_len = 1;
req.ns_object.ns_object_val = nis_clone_object (obj, NULL); req.ns_object.ns_object_val = nis_clone_object (obj, NULL);
p1 = req.ns_object.ns_object_val[0].zo_name;
req.ns_object.ns_object_val[0].zo_name =
nis_name_of_r (name, buf1, sizeof (buf1));
p2 = req.ns_object.ns_object_val[0].zo_owner;
if (p2 == NULL || strlen (p2) == 0)
req.ns_object.ns_object_val[0].zo_owner = nis_local_principal ();
p3 = req.ns_object.ns_object_val[0].zo_group;
if (p3 == NULL || strlen (p3) == 0)
req.ns_object.ns_object_val[0].zo_group = nis_local_group ();
p4 = req.ns_object.ns_object_val[0].zo_domain;
req.ns_object.ns_object_val[0].zo_domain =
nis_domain_of_r (name, buf4, sizeof (buf4));
if ((status = __do_niscall (NULL, 0, NIS_ADD, (xdrproc_t) xdr_ns_request, if ((status = __do_niscall (NULL, 0, NIS_ADD, (xdrproc_t) xdr_ns_request,
(caddr_t) & req, (xdrproc_t) xdr_nis_result, (caddr_t) &req, (xdrproc_t) xdr_nis_result,
(caddr_t) res, 0)) != RPC_SUCCESS) (caddr_t) res, 0)) != RPC_SUCCESS)
res->status = status; res->status = status;
req.ns_object.ns_object_val[0].zo_name = p1;
req.ns_object.ns_object_val[0].zo_owner = p2;
req.ns_object.ns_object_val[0].zo_group = p3;
req.ns_object.ns_object_val[0].zo_domain = p4;
nis_destroy_object (req.ns_object.ns_object_val); nis_destroy_object (req.ns_object.ns_object_val);
return res; return res;
} }
nis_result * nis_result *
nis_remove (const nis_name name, const nis_object *obj) nis_remove (const_nis_name name, const nis_object *obj)
{ {
nis_result *res; nis_result *res;
nis_error status; nis_error status;
@ -190,7 +214,7 @@ nis_remove (const nis_name name, const nis_object *obj)
res = calloc (1, sizeof (nis_result)); res = calloc (1, sizeof (nis_result));
req.ns_name = name; req.ns_name = (char *)name;
if (obj != NULL) if (obj != NULL)
{ {
@ -214,7 +238,7 @@ nis_remove (const nis_name name, const nis_object *obj)
} }
nis_result * nis_result *
nis_modify (const nis_name name, const nis_object *obj) nis_modify (const_nis_name name, const nis_object *obj)
{ {
nis_result *res; nis_result *res;
nis_error status; nis_error status;
@ -222,7 +246,7 @@ nis_modify (const nis_name name, const nis_object *obj)
res = calloc (1, sizeof (nis_result)); res = calloc (1, sizeof (nis_result));
req.ns_name = name; req.ns_name = (char *)name;
req.ns_object.ns_object_len = 1; req.ns_object.ns_object_len = 1;
req.ns_object.ns_object_val = nis_clone_object (obj, NULL); req.ns_object.ns_object_val = nis_clone_object (obj, NULL);

6
nis/nis_server.c
View File

@ -22,7 +22,7 @@
#include "nis_intern.h" #include "nis_intern.h"
nis_error nis_error
nis_mkdir (const nis_name dir, const nis_server *server) nis_mkdir (const_nis_name dir, const nis_server *server)
{ {
nis_error res; nis_error res;
@ -54,7 +54,7 @@ nis_mkdir (const nis_name dir, const nis_server *server)
} }
nis_error nis_error
nis_rmdir (const nis_name dir, const nis_server *server) nis_rmdir (const_nis_name dir, const nis_server *server)
{ {
nis_error res; nis_error res;
@ -116,7 +116,7 @@ nis_freetags (nis_tag *tags, const int numtags)
} }
nis_server ** nis_server **
nis_getservlist (const nis_name dir) nis_getservlist (const_nis_name dir)
{ {
nis_server **serv; nis_server **serv;

18
nis/nis_subr.c
View File

@ -23,7 +23,7 @@
#include <rpcsvc/nislib.h> #include <rpcsvc/nislib.h>
nis_name nis_name
nis_leaf_of (const nis_name name) nis_leaf_of (const_nis_name name)
{ {
static char result[NIS_MAXNAMELEN + 1]; static char result[NIS_MAXNAMELEN + 1];
@ -31,7 +31,7 @@ nis_leaf_of (const nis_name name)
} }
nis_name nis_name
nis_leaf_of_r (const nis_name name, char *buffer, size_t buflen) nis_leaf_of_r (const_nis_name name, char *buffer, size_t buflen)
{ {
size_t i = 0; size_t i = 0;
@ -53,7 +53,7 @@ nis_leaf_of_r (const nis_name name, char *buffer, size_t buflen)
} }
nis_name nis_name
nis_name_of (const nis_name name) nis_name_of (const_nis_name name)
{ {
static char result[NIS_MAXNAMELEN + 1]; static char result[NIS_MAXNAMELEN + 1];
@ -61,7 +61,7 @@ nis_name_of (const nis_name name)
} }
nis_name nis_name
nis_name_of_r (const nis_name name, char *buffer, size_t buflen) nis_name_of_r (const_nis_name name, char *buffer, size_t buflen)
{ {
char *local_domain; char *local_domain;
int diff; int diff;
@ -90,7 +90,7 @@ nis_name_of_r (const nis_name name, char *buffer, size_t buflen)
} }
nis_name nis_name
nis_domain_of (const nis_name name) nis_domain_of (const_nis_name name)
{ {
static char result[NIS_MAXNAMELEN + 1]; static char result[NIS_MAXNAMELEN + 1];
@ -98,7 +98,7 @@ nis_domain_of (const nis_name name)
} }
nis_name nis_name
nis_domain_of_r (const nis_name name, char *buffer, size_t buflen) nis_domain_of_r (const_nis_name name, char *buffer, size_t buflen)
{ {
char *cptr; char *cptr;
size_t cptr_len; size_t cptr_len;
@ -122,7 +122,7 @@ nis_domain_of_r (const nis_name name, char *buffer, size_t buflen)
} }
static int static int
count_dots (const nis_name str) count_dots (const_nis_name str)
{ {
int count = 0; int count = 0;
size_t i; size_t i;
@ -135,7 +135,7 @@ count_dots (const nis_name str)
} }
nis_name * nis_name *
nis_getnames (const nis_name name) nis_getnames (const_nis_name name)
{ {
nis_name *getnames = NULL; nis_name *getnames = NULL;
char local_domain[NIS_MAXNAMELEN + 1]; char local_domain[NIS_MAXNAMELEN + 1];
@ -267,7 +267,7 @@ nis_freenames (nis_name *names)
} }
name_pos name_pos
nis_dir_cmp (const nis_name n1, const nis_name n2) nis_dir_cmp (const_nis_name n1, const_nis_name n2)
{ {
int len1, len2; int len1, len2;

24
nis/nis_table.c
View File

@ -23,7 +23,7 @@
#include "nis_intern.h" #include "nis_intern.h"
static void static void
splitname (const nis_name name, nis_name *ibr_name, int *srch_len, splitname (const_nis_name name, nis_name *ibr_name, int *srch_len,
nis_attr **srch_val) nis_attr **srch_val)
{ {
char *cptr, *key, *val, *next; char *cptr, *key, *val, *next;
@ -138,7 +138,7 @@ splitname (const nis_name name, nis_name *ibr_name, int *srch_len,
} }
static struct ib_request * static struct ib_request *
__create_ib_request (const nis_name name, struct ib_request *ibreq, __create_ib_request (const_nis_name name, struct ib_request *ibreq,
u_long flags) u_long flags)
{ {
splitname (name, &ibreq->ibr_name, &ibreq->ibr_srch.ibr_srch_len, splitname (name, &ibreq->ibr_name, &ibreq->ibr_srch.ibr_srch_len,
@ -173,8 +173,8 @@ __create_ib_request (const nis_name name, struct ib_request *ibreq,
} }
nis_result * nis_result *
nis_list (const nis_name name, const u_long flags, nis_list (const_nis_name name, u_long flags,
int (*callback) (const nis_name name, int (*callback) (const_nis_name name,
const nis_object *object, const nis_object *object,
const void *userdata), const void *userdata),
const void *userdata) const void *userdata)
@ -257,8 +257,8 @@ nis_list (const nis_name name, const u_long flags,
} }
nis_result * nis_result *
nis_add_entry (const nis_name name, const nis_object *obj, nis_add_entry (const_nis_name name, const nis_object *obj,
const u_long flags) u_long flags)
{ {
nis_result *res; nis_result *res;
struct ib_request ibreq; struct ib_request ibreq;
@ -289,8 +289,8 @@ nis_add_entry (const nis_name name, const nis_object *obj,
} }
nis_result * nis_result *
nis_modify_entry (const nis_name name, const nis_object *obj, nis_modify_entry (const_nis_name name, const nis_object *obj,
const u_long flags) u_long flags)
{ {
nis_result *res; nis_result *res;
struct ib_request ibreq; struct ib_request ibreq;
@ -320,8 +320,8 @@ nis_modify_entry (const nis_name name, const nis_object *obj,
} }
nis_result * nis_result *
nis_remove_entry (const nis_name name, const nis_object *obj, nis_remove_entry (const_nis_name name, const nis_object *obj,
const u_long flags) u_long flags)
{ {
nis_result *res; nis_result *res;
struct ib_request ibreq; struct ib_request ibreq;
@ -354,7 +354,7 @@ nis_remove_entry (const nis_name name, const nis_object *obj,
} }
nis_result * nis_result *
nis_first_entry (const nis_name name) nis_first_entry (const_nis_name name)
{ {
nis_result *res; nis_result *res;
struct ib_request ibreq; struct ib_request ibreq;
@ -379,7 +379,7 @@ nis_first_entry (const nis_name name)
} }
nis_result * nis_result *
nis_next_entry (const nis_name name, const netobj *cookie) nis_next_entry (const_nis_name name, const netobj *cookie)
{ {
nis_result *res; nis_result *res;
struct ib_request ibreq; struct ib_request ibreq;

54
nis/nss_compat/compat-grp.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 1996 Free Software Foundation, Inc. /* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library. This file is part of the GNU C Library.
Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1996. Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1996.
@ -88,13 +88,13 @@ internal_setgrent (ent_t *ent)
ent->oldkey = NULL; ent->oldkey = NULL;
ent->oldkeylen = 0; ent->oldkeylen = 0;
} }
if (ent->result != NULL) if (ent->result != NULL)
{ {
nis_freeresult (ent->result); nis_freeresult (ent->result);
ent->result = NULL; ent->result = NULL;
} }
if (ent->names != NULL) if (ent->names != NULL)
{ {
nis_freenames (ent->names); nis_freenames (ent->names);
@ -104,11 +104,11 @@ internal_setgrent (ent_t *ent)
ent->blacklist.current = 0; ent->blacklist.current = 0;
if (ent->blacklist.data != NULL) if (ent->blacklist.data != NULL)
ent->blacklist.data[0] = '\0'; ent->blacklist.data[0] = '\0';
if (ent->stream == NULL) if (ent->stream == NULL)
{ {
ent->stream = fopen ("/etc/group", "r"); ent->stream = fopen ("/etc/group", "r");
if (ent->stream == NULL) if (ent->stream == NULL)
status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL; status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
} }
@ -163,7 +163,7 @@ internal_endgrent (ent_t *ent)
nis_freeresult (ent->result); nis_freeresult (ent->result);
ent->result = NULL; ent->result = NULL;
} }
if (ent->names != NULL) if (ent->names != NULL)
{ {
nis_freenames (ent->names); nis_freenames (ent->names);
@ -245,15 +245,15 @@ getgrent_next_nis (struct group *result, ent_t *ent, char *buffer,
while (isspace (*p)) while (isspace (*p))
++p; ++p;
parse_res = _nss_files_parse_grent (p, result, data, buflen); parse_res = _nss_files_parse_grent (p, result, data, buflen);
if (parse_res && if (parse_res &&
in_blacklist (result->gr_name, strlen (result->gr_name), ent)) in_blacklist (result->gr_name, strlen (result->gr_name), ent))
parse_res = 0; /* if result->gr_name in blacklist,search next entry */ parse_res = 0; /* if result->gr_name in blacklist,search next entry */
} }
while (!parse_res); while (!parse_res);
return NSS_STATUS_SUCCESS; return NSS_STATUS_SUCCESS;
} }
@ -262,7 +262,7 @@ getgrent_next_nisplus (struct group *result, ent_t *ent, char *buffer,
size_t buflen) size_t buflen)
{ {
int parse_res; int parse_res;
if (ent->names == NULL) if (ent->names == NULL)
{ {
ent->names = nis_getnames ("group.org_dir"); ent->names = nis_getnames ("group.org_dir");
@ -272,7 +272,7 @@ getgrent_next_nisplus (struct group *result, ent_t *ent, char *buffer,
return NSS_STATUS_UNAVAIL; return NSS_STATUS_UNAVAIL;
} }
} }
do do
{ {
if (ent->nis_first) if (ent->nis_first)
@ -289,8 +289,8 @@ getgrent_next_nisplus (struct group *result, ent_t *ent, char *buffer,
else else
{ {
nis_result *res; nis_result *res;
res = nis_next_entry(ent->names[ent->names_nr], res = nis_next_entry(ent->names[ent->names_nr],
&ent->result->cookie); &ent->result->cookie);
nis_freeresult (ent->result); nis_freeresult (ent->result);
ent->result = res; ent->result = res;
@ -310,14 +310,14 @@ getgrent_next_nisplus (struct group *result, ent_t *ent, char *buffer,
} }
} }
} }
parse_res = _nss_nisplus_parse_grent (ent->result, result, buffer, parse_res = _nss_nisplus_parse_grent (ent->result, result, buffer,
buflen); buflen);
if (parse_res && if (parse_res &&
in_blacklist (result->gr_name, strlen (result->gr_name), ent)) in_blacklist (result->gr_name, strlen (result->gr_name), ent))
parse_res = 0; /* if result->gr_name in blacklist,search next entry */ parse_res = 0; /* if result->gr_name in blacklist,search next entry */
} }
while (!parse_res); while (!parse_res);
return NSS_STATUS_SUCCESS; return NSS_STATUS_SUCCESS;
} }
@ -328,7 +328,7 @@ getgrent_next_file_plusgroup (struct group *result, char *buffer,
{ {
struct parser_data *data = (void *) buffer; struct parser_data *data = (void *) buffer;
int parse_res; int parse_res;
if (use_nisplus) /* Do the NIS+ query here */ if (use_nisplus) /* Do the NIS+ query here */
{ {
nis_result *res; nis_result *res;
@ -340,7 +340,7 @@ getgrent_next_file_plusgroup (struct group *result, char *buffer,
if (niserr2nss (res->status) != NSS_STATUS_SUCCESS) if (niserr2nss (res->status) != NSS_STATUS_SUCCESS)
{ {
enum nss_status status = niserr2nss (res->status); enum nss_status status = niserr2nss (res->status);
nis_freeresult (res); nis_freeresult (res);
return status; return status;
} }
@ -354,7 +354,7 @@ getgrent_next_file_plusgroup (struct group *result, char *buffer,
if (yp_get_default_domain (&domain) != YPERR_SUCCESS) if (yp_get_default_domain (&domain) != YPERR_SUCCESS)
return NSS_STATUS_TRYAGAIN; return NSS_STATUS_TRYAGAIN;
if (yp_match (domain, "group.byname", &result->gr_name[1], if (yp_match (domain, "group.byname", &result->gr_name[1],
strlen (result->gr_name) - 1, &outval, &outvallen) strlen (result->gr_name) - 1, &outval, &outvallen)
!= YPERR_SUCCESS) != YPERR_SUCCESS)
@ -420,7 +420,7 @@ getgrent_next_file (struct group *result, ent_t *ent,
&& result->gr_name[1] != '@') && result->gr_name[1] != '@')
{ {
enum nss_status status; enum nss_status status;
status = getgrent_next_file_plusgroup (result, buffer, buflen); status = getgrent_next_file_plusgroup (result, buffer, buflen);
if (status == NSS_STATUS_SUCCESS) /* We found the entry. */ if (status == NSS_STATUS_SUCCESS) /* We found the entry. */
break; break;
@ -506,7 +506,7 @@ _nss_compat_getgrnam_r (const char *name, struct group *grp,
__nss_database_lookup ("group_compat", NULL, "nis", &ni); __nss_database_lookup ("group_compat", NULL, "nis", &ni);
use_nisplus = (strcmp (ni->name, "nisplus") == 0); use_nisplus = (strcmp (ni->name, "nisplus") == 0);
} }
__libc_lock_unlock (lock); __libc_lock_unlock (lock);
status = internal_setgrent (&ent); status = internal_setgrent (&ent);
@ -531,13 +531,13 @@ _nss_compat_getgrgid_r (gid_t gid, struct group *grp,
enum nss_status status; enum nss_status status;
__libc_lock_lock (lock); __libc_lock_lock (lock);
if (ni == NULL) if (ni == NULL)
{ {
__nss_database_lookup ("group_compat", NULL, "nis", &ni); __nss_database_lookup ("group_compat", NULL, "nis", &ni);
use_nisplus = (strcmp (ni->name, "nisplus") == 0); use_nisplus = (strcmp (ni->name, "nisplus") == 0);
} }
__libc_lock_unlock (lock); __libc_lock_unlock (lock);
status = internal_setgrent (&ent); status = internal_setgrent (&ent);
@ -605,10 +605,14 @@ static bool_t
in_blacklist (const char *name, int namelen, ent_t *ent) in_blacklist (const char *name, int namelen, ent_t *ent)
{ {
char buf[namelen + 3]; char buf[namelen + 3];
char *cp;
if (ent->blacklist.data == NULL) if (ent->blacklist.data == NULL)
return FALSE; return FALSE;
stpcpy (stpcpy (stpcpy (buf, "|"), name), "|"); buf[0] = '|';
cp = stpcpy (&buf[1], name);
*cp++= '|';
*cp = '\0';
return strstr (ent->blacklist.data, buf) != NULL; return strstr (ent->blacklist.data, buf) != NULL;
} }

74
nis/nss_compat/compat-pwd.c
View File

@ -321,7 +321,7 @@ getpwent_next_nis_netgr (struct passwd *result, ent_t *ent, char *group,
char *ypdomain, *host, *user, *domain, *outval, *p, *p2; char *ypdomain, *host, *user, *domain, *outval, *p, *p2;
int status, outvallen; int status, outvallen;
size_t p2len; size_t p2len;
if (yp_get_default_domain (&ypdomain) != YPERR_SUCCESS) if (yp_get_default_domain (&ypdomain) != YPERR_SUCCESS)
{ {
ent->netgroup = 0; ent->netgroup = 0;
@ -390,8 +390,8 @@ getpwent_next_nisplus_netgr (struct passwd *result, ent_t *ent, char *group,
int status, parse_res; int status, parse_res;
size_t p2len; size_t p2len;
nis_result *nisres; nis_result *nisres;
/* Maybe we should use domainname here ? We need the current /* Maybe we should use domainname here ? We need the current
domainname for the domain field in netgroups */ domainname for the domain field in netgroups */
if (yp_get_default_domain (&ypdomain) != YPERR_SUCCESS) if (yp_get_default_domain (&ypdomain) != YPERR_SUCCESS)
{ {
@ -434,7 +434,7 @@ getpwent_next_nisplus_netgr (struct passwd *result, ent_t *ent, char *group,
} }
p2 = buffer + (buflen - p2len); p2 = buffer + (buflen - p2len);
buflen -= p2len; buflen -= p2len;
{ {
char buf[strlen (user) + 30]; char buf[strlen (user) + 30];
sprintf(buf, "[name=%s],passwd.org_dir", user); sprintf(buf, "[name=%s],passwd.org_dir", user);
nisres = nis_list(buf, EXPAND_NAME, NULL, NULL); nisres = nis_list(buf, EXPAND_NAME, NULL, NULL);
@ -446,7 +446,7 @@ getpwent_next_nisplus_netgr (struct passwd *result, ent_t *ent, char *group,
} }
parse_res = _nss_nisplus_parse_pwent (nisres, result, buffer, buflen); parse_res = _nss_nisplus_parse_pwent (nisres, result, buffer, buflen);
nis_freeresult (nisres); nis_freeresult (nisres);
if (parse_res) if (parse_res)
{ {
copy_pwd_changes (result, &ent->pwd, p2, p2len); copy_pwd_changes (result, &ent->pwd, p2, p2len);
@ -484,7 +484,7 @@ getpwent_next_nisplus (struct passwd *result, ent_t *ent, char *buffer,
return NSS_STATUS_UNAVAIL; return NSS_STATUS_UNAVAIL;
} }
} }
p2len = pwd_need_buflen (&ent->pwd); p2len = pwd_need_buflen (&ent->pwd);
if (p2len > buflen) if (p2len > buflen)
{ {
@ -510,8 +510,8 @@ getpwent_next_nisplus (struct passwd *result, ent_t *ent, char *buffer,
else else
{ {
nis_result *res; nis_result *res;
res = nis_next_entry(ent->names[ent->names_nr], res = nis_next_entry(ent->names[ent->names_nr],
&ent->result->cookie); &ent->result->cookie);
nis_freeresult (ent->result); nis_freeresult (ent->result);
ent->result = res; ent->result = res;
@ -532,16 +532,16 @@ getpwent_next_nisplus (struct passwd *result, ent_t *ent, char *buffer,
} }
} }
} }
parse_res = _nss_nisplus_parse_pwent (ent->result, result, buffer, parse_res = _nss_nisplus_parse_pwent (ent->result, result, buffer,
buflen); buflen);
if (parse_res && if (parse_res &&
in_blacklist (result->pw_name, strlen (result->pw_name), ent)) in_blacklist (result->pw_name, strlen (result->pw_name), ent))
parse_res = 0; /* if result->pw_name in blacklist,search next entry */ parse_res = 0; /* if result->pw_name in blacklist,search next entry */
} }
while (!parse_res); while (!parse_res);
copy_pwd_changes (result, &ent->pwd, p2, p2len); copy_pwd_changes (result, &ent->pwd, p2, p2len);
return NSS_STATUS_SUCCESS; return NSS_STATUS_SUCCESS;
} }
@ -623,7 +623,7 @@ getpwent_next_nis (struct passwd *result, ent_t *ent, char *buffer,
/* This function handle the +user entrys in /etc/passwd */ /* This function handle the +user entrys in /etc/passwd */
static enum nss_status static enum nss_status
getpwent_next_file_plususer (struct passwd *result, char *buffer, getpwent_next_file_plususer (struct passwd *result, char *buffer,
size_t buflen) size_t buflen)
{ {
struct parser_data *data = (void *) buffer; struct parser_data *data = (void *) buffer;
@ -631,11 +631,11 @@ getpwent_next_file_plususer (struct passwd *result, char *buffer,
int parse_res; int parse_res;
char *p; char *p;
size_t plen; size_t plen;
memset (&pwd, '\0', sizeof (struct passwd)); memset (&pwd, '\0', sizeof (struct passwd));
copy_pwd_changes (&pwd, result, NULL, 0); copy_pwd_changes (&pwd, result, NULL, 0);
plen = pwd_need_buflen (&pwd); plen = pwd_need_buflen (&pwd);
if (plen > buflen) if (plen > buflen)
{ {
@ -644,19 +644,19 @@ getpwent_next_file_plususer (struct passwd *result, char *buffer,
} }
p = buffer + (buflen - plen); p = buffer + (buflen - plen);
buflen -= plen; buflen -= plen;
if (use_nisplus) /* Do the NIS+ query here */ if (use_nisplus) /* Do the NIS+ query here */
{ {
nis_result *res; nis_result *res;
char buf[strlen (result->pw_name) + 24]; char buf[strlen (result->pw_name) + 24];
sprintf(buf, "[name=%s],passwd.org_dir", sprintf(buf, "[name=%s],passwd.org_dir",
&result->pw_name[1]); &result->pw_name[1]);
res = nis_list(buf, EXPAND_NAME, NULL, NULL); res = nis_list(buf, EXPAND_NAME, NULL, NULL);
if (niserr2nss (res->status) != NSS_STATUS_SUCCESS) if (niserr2nss (res->status) != NSS_STATUS_SUCCESS)
{ {
enum nss_status status = niserr2nss (res->status); enum nss_status status = niserr2nss (res->status);
nis_freeresult (res); nis_freeresult (res);
return status; return status;
} }
@ -668,22 +668,22 @@ getpwent_next_file_plususer (struct passwd *result, char *buffer,
char *domain; char *domain;
char *outval; char *outval;
int outvallen; int outvallen;
if (yp_get_default_domain (&domain) != YPERR_SUCCESS) if (yp_get_default_domain (&domain) != YPERR_SUCCESS)
return NSS_STATUS_TRYAGAIN; return NSS_STATUS_TRYAGAIN;
if (yp_match (domain, "passwd.byname", &result->pw_name[1], if (yp_match (domain, "passwd.byname", &result->pw_name[1],
strlen (result->pw_name) - 1, &outval, &outvallen) strlen (result->pw_name) - 1, &outval, &outvallen)
!= YPERR_SUCCESS) != YPERR_SUCCESS)
return NSS_STATUS_TRYAGAIN; return NSS_STATUS_TRYAGAIN;
p = strncpy (buffer, outval, p = strncpy (buffer, outval,
buflen < outvallen ? buflen : outvallen); buflen < outvallen ? buflen : outvallen);
free (outval); free (outval);
while (isspace (*p)) while (isspace (*p))
p++; p++;
parse_res = _nss_files_parse_pwent (p, result, data, buflen); parse_res = _nss_files_parse_pwent (p, result, data, buflen);
} }
if (parse_res) if (parse_res)
{ {
copy_pwd_changes (result, &pwd, p, plen); copy_pwd_changes (result, &pwd, p, plen);
@ -735,15 +735,19 @@ getpwent_next_file (struct passwd *result, ent_t *ent,
if (result->pw_name[0] == '-' && result->pw_name[1] == '@' if (result->pw_name[0] == '-' && result->pw_name[1] == '@'
&& result->pw_name[2] != '\0') && result->pw_name[2] != '\0')
{ {
char buf2[1024];
char *user, *host, *domain; char *user, *host, *domain;
struct __netgrent netgrdata;
setnetgrent (&result->pw_name[2]); bzero (&netgrdata, sizeof (struct __netgrent));
while (getnetgrent (&host, &user, &domain)) __internal_setnetgrent (&result->pw_name[2], &netgrdata);
while (__internal_getnetgrent_r (&host, &user, &domain,
&netgrdata, buf2, sizeof (buf2)))
{ {
if (user != NULL && user[0] != '-') if (user != NULL && user[0] != '-')
blacklist_store_name (user, ent); blacklist_store_name (user, ent);
} }
endnetgrent (); __internal_endnetgrent (&netgrdata);
continue; continue;
} }
@ -778,7 +782,7 @@ getpwent_next_file (struct passwd *result, ent_t *ent,
&& result->pw_name[1] != '@') && result->pw_name[1] != '@')
{ {
enum nss_status status; enum nss_status status;
status = getpwent_next_file_plususer (result, buffer, buflen); status = getpwent_next_file_plususer (result, buffer, buflen);
if (status == NSS_STATUS_SUCCESS) /* We found the entry. */ if (status == NSS_STATUS_SUCCESS) /* We found the entry. */
break; break;
@ -879,7 +883,7 @@ _nss_compat_getpwnam_r (const char *name, struct passwd *pwd,
__nss_database_lookup ("passwd_compat", NULL, "nis", &ni); __nss_database_lookup ("passwd_compat", NULL, "nis", &ni);
use_nisplus = (strcmp (ni->name, "nisplus") == 0); use_nisplus = (strcmp (ni->name, "nisplus") == 0);
} }
__libc_lock_unlock (lock); __libc_lock_unlock (lock);
status = internal_setpwent (&ent); status = internal_setpwent (&ent);
@ -903,17 +907,17 @@ _nss_compat_getpwuid_r (uid_t uid, struct passwd *pwd,
ent_t ent = {0, 0, 0, NULL, 0, NULL, NULL, 0, NULL, {NULL, 0, 0}, ent_t ent = {0, 0, 0, NULL, 0, NULL, NULL, 0, NULL, {NULL, 0, 0},
{NULL, NULL, 0, 0, NULL, NULL, NULL}}; {NULL, NULL, 0, 0, NULL, NULL, NULL}};
enum nss_status status; enum nss_status status;
__libc_lock_lock (lock); __libc_lock_lock (lock);
if (ni == NULL) if (ni == NULL)
{ {
__nss_database_lookup ("passwd_compat", NULL, "nis", &ni); __nss_database_lookup ("passwd_compat", NULL, "nis", &ni);
use_nisplus = (strcmp (ni->name, "nisplus") == 0); use_nisplus = (strcmp (ni->name, "nisplus") == 0);
} }
__libc_lock_unlock (lock); __libc_lock_unlock (lock);
status = internal_setpwent (&ent); status = internal_setpwent (&ent);
if (status != NSS_STATUS_SUCCESS) if (status != NSS_STATUS_SUCCESS)
return status; return status;
@ -979,10 +983,14 @@ static bool_t
in_blacklist (const char *name, int namelen, ent_t *ent) in_blacklist (const char *name, int namelen, ent_t *ent)
{ {
char buf[namelen + 3]; char buf[namelen + 3];
char *cp;
if (ent->blacklist.data == NULL) if (ent->blacklist.data == NULL)
return FALSE; return FALSE;
stpcpy (stpcpy (stpcpy (buf, "|"), name), "|"); buf[0] = '|';
cp = stpcpy (&buf[1], name);
*cp++= '|';
*cp = '\0';
return strstr (ent->blacklist.data, buf) != NULL; return strstr (ent->blacklist.data, buf) != NULL;
} }

94
nis/nss_compat/compat-spwd.c
View File

@ -147,7 +147,7 @@ internal_setspent (ent_t *ent)
/* If something was left over free it. */ /* If something was left over free it. */
if (ent->netgroup) if (ent->netgroup)
__internal_endnetgrent (&ent->netgrdata); __internal_endnetgrent (&ent->netgrdata);
if (ent->oldkey != NULL) if (ent->oldkey != NULL)
{ {
free (ent->oldkey); free (ent->oldkey);
@ -166,7 +166,7 @@ internal_setspent (ent_t *ent)
ent->names = NULL; ent->names = NULL;
} }
ent->names_nr = 0; ent->names_nr = 0;
ent->blacklist.current = 0; ent->blacklist.current = 0;
if (ent->blacklist.data != NULL) if (ent->blacklist.data != NULL)
ent->blacklist.data[0] = '\0'; ent->blacklist.data[0] = '\0';
@ -199,7 +199,7 @@ _nss_compat_setspent (void)
__nss_database_lookup ("shadow_compat", "passwd_compat", "nis", &ni); __nss_database_lookup ("shadow_compat", "passwd_compat", "nis", &ni);
use_nisplus = (strcmp (ni->name, "nisplus") == 0); use_nisplus = (strcmp (ni->name, "nisplus") == 0);
} }
result = internal_setspent (&ext_ent); result = internal_setspent (&ext_ent);
__libc_lock_unlock (lock); __libc_lock_unlock (lock);
@ -240,11 +240,11 @@ internal_endspent (ent_t *ent)
ent->names = NULL; ent->names = NULL;
} }
ent->names_nr = 0; ent->names_nr = 0;
ent->blacklist.current = 0; ent->blacklist.current = 0;
if (ent->blacklist.data != NULL) if (ent->blacklist.data != NULL)
ent->blacklist.data[0] = '\0'; ent->blacklist.data[0] = '\0';
give_spwd_free (&ent->pwd); give_spwd_free (&ent->pwd);
return NSS_STATUS_SUCCESS; return NSS_STATUS_SUCCESS;
@ -342,8 +342,8 @@ getspent_next_nisplus_netgr (struct spwd *result, ent_t *ent, char *group,
int status, parse_res; int status, parse_res;
size_t p2len; size_t p2len;
nis_result *nisres; nis_result *nisres;
/* Maybe we should use domainname here ? We need the current /* Maybe we should use domainname here ? We need the current
domainname for the domain field in netgroups */ domainname for the domain field in netgroups */
if (yp_get_default_domain (&ypdomain) != YPERR_SUCCESS) if (yp_get_default_domain (&ypdomain) != YPERR_SUCCESS)
{ {
@ -386,7 +386,7 @@ getspent_next_nisplus_netgr (struct spwd *result, ent_t *ent, char *group,
} }
p2 = buffer + (buflen - p2len); p2 = buffer + (buflen - p2len);
buflen -= p2len; buflen -= p2len;
{ {
char buf[strlen (user) + 30]; char buf[strlen (user) + 30];
sprintf(buf, "[name=%s],passwd.org_dir", user); sprintf(buf, "[name=%s],passwd.org_dir", user);
nisres = nis_list(buf, EXPAND_NAME, NULL, NULL); nisres = nis_list(buf, EXPAND_NAME, NULL, NULL);
@ -398,7 +398,7 @@ getspent_next_nisplus_netgr (struct spwd *result, ent_t *ent, char *group,
} }
parse_res = _nss_nisplus_parse_spent (nisres, result, buffer, buflen); parse_res = _nss_nisplus_parse_spent (nisres, result, buffer, buflen);
nis_freeresult (nisres); nis_freeresult (nisres);
if (parse_res) if (parse_res)
{ {
copy_spwd_changes (result, &ent->pwd, p2, p2len); copy_spwd_changes (result, &ent->pwd, p2, p2len);
@ -414,9 +414,9 @@ getspent_next_netgr (struct spwd *result, ent_t *ent, char *group,
char *buffer, size_t buflen) char *buffer, size_t buflen)
{ {
if (use_nisplus) if (use_nisplus)
return getpwent_next_nisplus_netgr (result, ent, group, buffer, buflen); return getspent_next_nisplus_netgr (result, ent, group, buffer, buflen);
else else
return getpwent_next_nis_netgr (result, ent, group, buffer, buflen); return getspent_next_nis_netgr (result, ent, group, buffer, buflen);
} }
static enum nss_status static enum nss_status
@ -426,7 +426,7 @@ getspent_next_nisplus (struct spwd *result, ent_t *ent, char *buffer,
int parse_res; int parse_res;
size_t p2len; size_t p2len;
char *p2; char *p2;
if (ent->names == NULL) if (ent->names == NULL)
{ {
ent->names = nis_getnames ("passwd.org_dir"); ent->names = nis_getnames ("passwd.org_dir");
@ -436,7 +436,7 @@ getspent_next_nisplus (struct spwd *result, ent_t *ent, char *buffer,
return NSS_STATUS_UNAVAIL; return NSS_STATUS_UNAVAIL;
} }
} }
p2len = spwd_need_buflen (&ent->pwd); p2len = spwd_need_buflen (&ent->pwd);
if (p2len > buflen) if (p2len > buflen)
{ {
@ -462,8 +462,8 @@ getspent_next_nisplus (struct spwd *result, ent_t *ent, char *buffer,
else else
{ {
nis_result *res; nis_result *res;
res = nis_next_entry(ent->names[ent->names_nr], res = nis_next_entry(ent->names[ent->names_nr],
&ent->result->cookie); &ent->result->cookie);
nis_freeresult (ent->result); nis_freeresult (ent->result);
ent->result = res; ent->result = res;
@ -484,16 +484,16 @@ getspent_next_nisplus (struct spwd *result, ent_t *ent, char *buffer,
} }
} }
} }
parse_res = _nss_nisplus_parse_spent (ent->result, result, buffer, parse_res = _nss_nisplus_parse_spent (ent->result, result, buffer,
buflen); buflen);
if (parse_res && if (parse_res &&
in_blacklist (result->sp_namp, strlen (result->sp_namp), ent)) in_blacklist (result->sp_namp, strlen (result->sp_namp), ent))
parse_res = 0; /* if result->pw_name in blacklist,search next entry */ parse_res = 0; /* if result->pw_name in blacklist,search next entry */
} }
while (!parse_res); while (!parse_res);
copy_spwd_changes (result, &ent->pwd, p2, p2len); copy_spwd_changes (result, &ent->pwd, p2, p2len);
return NSS_STATUS_SUCCESS; return NSS_STATUS_SUCCESS;
} }
@ -576,7 +576,7 @@ getspent_next_nis (struct spwd *result, ent_t *ent,
/* This function handle the +user entrys in /etc/shadow */ /* This function handle the +user entrys in /etc/shadow */
static enum nss_status static enum nss_status
getspent_next_file_plususer (struct spwd *result, char *buffer, getspent_next_file_plususer (struct spwd *result, char *buffer,
size_t buflen) size_t buflen)
{ {
struct parser_data *data = (void *) buffer; struct parser_data *data = (void *) buffer;
@ -584,11 +584,11 @@ getspent_next_file_plususer (struct spwd *result, char *buffer,
int parse_res; int parse_res;
char *p; char *p;
size_t plen; size_t plen;
memset (&pwd, '\0', sizeof (struct spwd)); memset (&pwd, '\0', sizeof (struct spwd));
copy_spwd_changes (&pwd, result, NULL, 0); copy_spwd_changes (&pwd, result, NULL, 0);
plen = spwd_need_buflen (&pwd); plen = spwd_need_buflen (&pwd);
if (plen > buflen) if (plen > buflen)
{ {
@ -597,19 +597,19 @@ getspent_next_file_plususer (struct spwd *result, char *buffer,
} }
p = buffer + (buflen - plen); p = buffer + (buflen - plen);
buflen -= plen; buflen -= plen;
if (use_nisplus) /* Do the NIS+ query here */ if (use_nisplus) /* Do the NIS+ query here */
{ {
nis_result *res; nis_result *res;
char buf[strlen (result->sp_namp) + 24]; char buf[strlen (result->sp_namp) + 24];
sprintf(buf, "[name=%s],passwd.org_dir", sprintf(buf, "[name=%s],passwd.org_dir",
&result->sp_namp[1]); &result->sp_namp[1]);
res = nis_list(buf, EXPAND_NAME, NULL, NULL); res = nis_list(buf, EXPAND_NAME, NULL, NULL);
if (niserr2nss (res->status) != NSS_STATUS_SUCCESS) if (niserr2nss (res->status) != NSS_STATUS_SUCCESS)
{ {
enum nss_status status = niserr2nss (res->status); enum nss_status status = niserr2nss (res->status);
nis_freeresult (res); nis_freeresult (res);
return status; return status;
} }
@ -621,22 +621,22 @@ getspent_next_file_plususer (struct spwd *result, char *buffer,
char *domain; char *domain;
char *outval; char *outval;
int outvallen; int outvallen;
if (yp_get_default_domain (&domain) != YPERR_SUCCESS) if (yp_get_default_domain (&domain) != YPERR_SUCCESS)
return NSS_STATUS_TRYAGAIN; return NSS_STATUS_TRYAGAIN;
if (yp_match (domain, "passwd.byname", &result->sp_namp[1], if (yp_match (domain, "passwd.byname", &result->sp_namp[1],
strlen (result->sp_namp) - 1, &outval, &outvallen) strlen (result->sp_namp) - 1, &outval, &outvallen)
!= YPERR_SUCCESS) != YPERR_SUCCESS)
return NSS_STATUS_TRYAGAIN; return NSS_STATUS_TRYAGAIN;
p = strncpy (buffer, outval, p = strncpy (buffer, outval,
buflen < outvallen ? buflen : outvallen); buflen < outvallen ? buflen : outvallen);
free (outval); free (outval);
while (isspace (*p)) while (isspace (*p))
p++; p++;
parse_res = _nss_files_parse_spent (p, result, data, buflen); parse_res = _nss_files_parse_spent (p, result, data, buflen);
} }
if (parse_res) if (parse_res)
{ {
copy_spwd_changes (result, &pwd, p, plen); copy_spwd_changes (result, &pwd, p, plen);
@ -660,8 +660,7 @@ getspent_next_file (struct spwd *result, ent_t *ent,
struct parser_data *data = (void *) buffer; struct parser_data *data = (void *) buffer;
while (1) while (1)
{ {
char *p, *p2; char *p;
size_t p2len;
do do
{ {
@ -676,10 +675,10 @@ getspent_next_file (struct spwd *result, ent_t *ent,
while (isspace (*p)) while (isspace (*p))
++p; ++p;
} }
while (*p == '\0' || *p == '#' || /* Ignore empty and comment lines. */ while (*p == '\0' || *p == '#' /* Ignore empty and comment lines. */
/* Parse the line. If it is invalid, loop to /* Parse the line. If it is invalid, loop to
get the next line of the file to parse. */ get the next line of the file to parse. */
!_nss_files_parse_spent (p, result, data, buflen)); || !_nss_files_parse_spent (p, result, data, buflen));
if (result->sp_namp[0] != '+' && result->sp_namp[0] != '-') if (result->sp_namp[0] != '+' && result->sp_namp[0] != '-')
/* This is a real entry. */ /* This is a real entry. */
@ -689,15 +688,19 @@ getspent_next_file (struct spwd *result, ent_t *ent,
if (result->sp_namp[0] == '-' && result->sp_namp[1] == '@' if (result->sp_namp[0] == '-' && result->sp_namp[1] == '@'
&& result->sp_namp[2] != '\0') && result->sp_namp[2] != '\0')
{ {
char *user, *host, *domain; char buf2[1024];
char *user, *host, *domain;
struct __netgrent netgrdata;
setnetgrent (&result->sp_namp[2]); bzero (&netgrdata, sizeof (struct __netgrent));
while (getnetgrent (&host, &user, &domain)) __internal_setnetgrent (&result->sp_namp[2], &netgrdata);
while (__internal_getnetgrent_r (&host, &user, &domain,
&netgrdata, buf2, sizeof (buf2)))
{ {
if (user != NULL && user[0] != '-') if (user != NULL && user[0] != '-')
blacklist_store_name (user, ent); blacklist_store_name (user, ent);
} }
endnetgrent (); __internal_endnetgrent (&netgrdata);
continue; continue;
} }
@ -732,7 +735,7 @@ getspent_next_file (struct spwd *result, ent_t *ent,
&& result->sp_namp[1] != '@') && result->sp_namp[1] != '@')
{ {
enum nss_status status; enum nss_status status;
status = getspent_next_file_plususer (result, buffer, buflen); status = getspent_next_file_plususer (result, buffer, buflen);
if (status == NSS_STATUS_SUCCESS) /* We found the entry. */ if (status == NSS_STATUS_SUCCESS) /* We found the entry. */
break; break;
@ -800,7 +803,7 @@ _nss_compat_getspent_r (struct spwd *pwd, char *buffer, size_t buflen)
__nss_database_lookup ("shadow_compat", "passwd_compat", "nis", &ni); __nss_database_lookup ("shadow_compat", "passwd_compat", "nis", &ni);
use_nisplus = (strcmp (ni->name, "nisplus") == 0); use_nisplus = (strcmp (ni->name, "nisplus") == 0);
} }
/* Be prepared that the setspent function was not called before. */ /* Be prepared that the setspent function was not called before. */
if (ext_ent.stream == NULL) if (ext_ent.stream == NULL)
status = internal_setspent (&ext_ent); status = internal_setspent (&ext_ent);
@ -830,7 +833,7 @@ _nss_compat_getspnam_r (const char *name, struct spwd *pwd,
__nss_database_lookup ("shadow_compat", "passwd_compat", "nis", &ni); __nss_database_lookup ("shadow_compat", "passwd_compat", "nis", &ni);
use_nisplus = (strcmp (ni->name, "nisplus") == 0); use_nisplus = (strcmp (ni->name, "nisplus") == 0);
} }
status = internal_setspent (&ent); status = internal_setspent (&ent);
if (status != NSS_STATUS_SUCCESS) if (status != NSS_STATUS_SUCCESS)
return status; return status;
@ -890,16 +893,19 @@ blacklist_store_name (const char *name, ent_t *ent)
return; return;
} }
/* returns TRUE if ent->blacklist contains name, else FALSE */ /* Returns TRUE if ent->blacklist contains name, else FALSE. */
static bool_t static bool_t
in_blacklist (const char *name, int namelen, ent_t *ent) in_blacklist (const char *name, int namelen, ent_t *ent)
{ {
char buf[namelen + 3]; char buf[namelen + 3];
char *cp;
if (ent->blacklist.data == NULL) if (ent->blacklist.data == NULL)
return FALSE; return FALSE;
stpcpy (stpcpy (stpcpy (buf, "|"), name), "|"); buf[0] = '|';
cp = stpcpy (&buf[1], name);
*cp++= '|';
*cp = '\0';
return strstr (ent->blacklist.data, buf) != NULL; return strstr (ent->blacklist.data, buf) != NULL;
} }

282
nis/rpcsvc/nislib.h
View File

@ -24,57 +24,144 @@
__BEGIN_DECLS __BEGIN_DECLS
/* typedef const char *const_nis_name;
** nis_names
*/ /* nis_names: These functions are used to locate and manipulate all NIS+
extern nis_result *nis_lookup __P ((__const nis_name, const u_long)); * objects except the NIS+ entry objects.
extern nis_result *nis_add __P ((__const nis_name, const nis_object *)); *
extern nis_result *nis_remove __P ((__const nis_name, const nis_object *)); * nis_lookup (name, flags) resolves a NIS+ name and returns a copy of
extern nis_result *nis_modify __P ((__const nis_name, const nis_object *)); * that object from a NIS+ server.
/* * const nis_name name: name of the object to be resolved
** nis_table * u_long flags: logically ORing zero or more flags (FOLLOW_LINKS,
*/ * HARD_LOOKUP, [NO_CACHE], MASTER_ONLY, EXPAND_NAME)
extern nis_result *nis_list __P ((__const nis_name, const u_long, *
int (*)(__const nis_name, * nis_add (name, obj) adds objects to the NIS+ namespace.
__const nis_object *, * const nis_name name: fully qualified NIS+ name.
__const void *), __const void *)); * const nis_object *obj: object members zo_name and zo_domain will be
extern nis_result *nis_add_entry __P ((__const nis_name, __const nis_object *, * constructed from name.
__const u_long)); *
extern nis_result *nis_modify_entry __P ((__const nis_name, * nis_remove (name, obj) removes objects from the NIS+ namespace.
__const nis_object *, * const nis_name name: fully qualified NIS+ name.
__const u_long)); * const nis_object *obj: if not NULL, it is assumed to point to a copy
extern nis_result *nis_remove_entry __P ((__const nis_name, * of the object being removed. In this case, if
__const nis_object *, * the object on the server does not have the same
__const u_long)); * object identifier as the object being passed,
extern nis_result *nis_first_entry __P ((__const nis_name)); * the operation will fail with the NIS_NOTSAMEOBJ
extern nis_result *nis_next_entry __P ((__const nis_name, __const netobj *)); * error.
*
* nis_modify (name, obj) can change specific attributes of an object
* that already exists in the namespace.
*/
extern nis_result *nis_lookup __P ((const_nis_name name, u_long flags));
extern nis_result *nis_add __P ((const_nis_name name, const nis_object *obj));
extern nis_result *nis_remove __P ((const_nis_name name,
const nis_object *obj));
extern nis_result *nis_modify __P ((const_nis_name name,
const nis_object *obj));
/* nis_tables: These functions are used to search and modify NIS+ tables.
*
* nis_list (table_name, flags, callback(table_name, obj, userdata), userdata)
* search a table in the NIS+ namespace.
* const nis_name table_name: indexed name ([xx=yy],table.dir)
* u_long flags: logically ORing one or more flags (FOLLOW_LINKS,
* [FOLLOW_PATH], HARD_LOOKUP, [ALL_RESULTS], [NO_CACHE],
* MASTER_ONLY, EXPAND_NAME, RETURN_RESULT)
* callback(): callback is an optional pointer to a function that will
* process the ENTRY type objects that are returned from the
* search. If this pointer is NULL, then all entries that match
* the search criteria are returned in the nis_result structure,
* otherwise this function will be called once for each
* entry returned.
* void *userdata: passed to callback function along with the returned
* entry object.
*
* nis_add_entry (table_name, obj, flags) will add the NIS+ object to the
* NIS+ table_name.
* const nis_name table_name
* const nis_object *obj
* u_long flags: 0, ADD_OVERWRITE, RETURN_RESULT
*
* nis_modify_entry (name, obj, flags) modifies an object identified by name.
* const nis_name name: object identifier
* const nis_object *obj: should point to an entry with the EN_MODIFIED
* flag set in each column that contains new
* information.
* u_long flags: 0, MOD_SAMEOBJ, RETURN_RESULT
*
* nis_remove_entry (table_name, obj, flags) removes a set of entries
* identified by table_name from the table.
* const nis_name table_name: indexed NIS+ name
* const nis_object *obj: if obj is non-null, it is presumed to point to
* a cached copy of the entry. When the removal is
* attempted, and the object that would be removed
* is not the same as the cached object pointed to
* by object then the operation will fail with an
* NIS_NOTSAMEOBJ error
* u_long flags: 0, REM_MULTIPLE
*
* nis_first_entry (table_name) fetches entries from a table one at a time.
* const nis_name table_name
*
* nis_next_entry (table_name, cookie) retrieves the "next" entry from a
* table specified by table_name.
* const nis_name table_name:
* const netobj *cookie: The value of cookie from the nis_result structure
* form the previous call.
*/
extern nis_result *nis_list __P ((const_nis_name name, u_long flags,
int (*callback)(const_nis_name table_name,
const nis_object *obj,
const void *userdata),
const void *userdata));
extern nis_result *nis_add_entry __P ((const_nis_name table_name,
const nis_object *obj, u_long flags));
extern nis_result *nis_modify_entry __P ((const_nis_name name,
const nis_object *obj,
u_long flags));
extern nis_result *nis_remove_entry __P ((const_nis_name table_name,
const nis_object *obj,
u_long flags));
extern nis_result *nis_first_entry __P ((const_nis_name table_name));
extern nis_result *nis_next_entry __P ((const_nis_name table_name,
const netobj *cookie));
/* /*
** nis_server ** nis_server
*/ */
extern nis_error nis_mkdir __P ((__const nis_name, __const nis_server *)); extern nis_error nis_mkdir __P ((const_nis_name dirname,
extern nis_error nis_rmdir __P ((__const nis_name, __const nis_server *)); const nis_server *machine));
extern nis_error nis_servstate __P ((__const nis_server *, __const nis_tag *, extern nis_error nis_rmdir __P ((const_nis_name dirname,
__const int, nis_tag **)); const nis_server *machine));
extern nis_error nis_stats __P ((__const nis_server *, __const nis_tag *, extern nis_error nis_servstate __P ((const nis_server *machine,
__const int, nis_tag **)); const nis_tag *tags, int numtags,
extern void nis_freetags __P ((nis_tag *, __const int)); nis_tag **result));
extern nis_server **nis_getservlist __P ((__const nis_name)); extern nis_error nis_stats __P ((const nis_server *machine,
extern void nis_freeservlist __P ((nis_server **)); const nis_tag *tags, int numtags,
nis_tag **result));
extern void nis_freetags __P ((nis_tag *tags, int numtags));
extern nis_server **nis_getservlist __P ((const_nis_name dirname));
extern void nis_freeservlist __P ((nis_server **machines));
/* /*
** nis_subr ** nis_subr
*/ */
extern nis_name nis_leaf_of __P ((__const nis_name)); extern nis_name nis_leaf_of __P ((const_nis_name name));
extern nis_name nis_leaf_of_r __P ((__const nis_name, char *, size_t)); extern nis_name nis_leaf_of_r __P ((const_nis_name name, char *buffer,
extern nis_name nis_name_of __P ((__const nis_name)); size_t buflen));
extern nis_name nis_name_of_r __P ((__const nis_name, char *, size_t)); extern nis_name nis_name_of __P ((const_nis_name name));
extern nis_name nis_domain_of __P ((__const nis_name)); extern nis_name nis_name_of_r __P ((const_nis_name name, char *buffer,
extern nis_name nis_domain_of_r __P ((__const nis_name, char *, size_t)); size_t buflen));
extern nis_name *nis_getnames __P ((__const nis_name)); extern nis_name nis_domain_of __P ((const_nis_name name));
extern void nis_freenames __P ((nis_name *)); extern nis_name nis_domain_of_r __P ((const_nis_name name, char *buffer,
extern name_pos nis_dir_cmp __P ((nis_name, nis_name)); size_t buflen));
extern nis_object *nis_clone_object __P ((__const nis_object *, nis_object *)); extern nis_name *nis_getnames __P ((const_nis_name name));
extern void nis_destroy_object __P ((nis_object *)); extern void nis_freenames __P ((nis_name *namelist));
extern void nis_print_object __P ((__const nis_object *)); extern name_pos nis_dir_cmp __P ((const_nis_name n1, const_nis_name n2));
extern nis_object *nis_clone_object __P ((const nis_object *src,
nis_object *dest));
extern void nis_destroy_object __P ((nis_object *obj));
extern void nis_print_object __P ((const nis_object *obj));
/* /*
** nis_local_names ** nis_local_names
*/ */
@ -82,81 +169,92 @@ extern nis_name nis_local_group __P ((void));
extern nis_name nis_local_directory __P ((void)); extern nis_name nis_local_directory __P ((void));
extern nis_name nis_local_principal __P ((void)); extern nis_name nis_local_principal __P ((void));
extern nis_name nis_local_host __P ((void)); extern nis_name nis_local_host __P ((void));
/* /*
** nis_error ** nis_error
*/ */
extern const char *nis_sperrno __P ((__const nis_error)); extern const char *nis_sperrno __P ((const nis_error status));
extern void nis_perror __P ((__const nis_error, __const char *)); extern void nis_perror __P ((const nis_error status, const char *label));
extern void nis_lerror __P ((__const nis_error, __const char *)); extern void nis_lerror __P ((const nis_error status, const char *label));
extern char *nis_sperror __P ((__const nis_error, __const char *)); extern char *nis_sperror __P ((const nis_error status, const char *label));
extern char *nis_sperror_r __P ((__const nis_error, __const char *, extern char *nis_sperror_r __P ((const nis_error status, const char *label,
char *, size_t)); char *buffer, size_t buflen));
/* /*
** nis_groups ** nis_groups
*/ */
extern bool_t nis_ismember __P ((__const nis_name, __const nis_name)); extern bool_t nis_ismember __P ((const_nis_name principal,
extern nis_error nis_addmember __P ((__const nis_name, __const nis_name)); const_nis_name group));
extern nis_error nis_removemember __P ((__const nis_name, __const nis_name)); extern nis_error nis_addmember __P ((const_nis_name member,
extern nis_error nis_creategroup __P ((__const nis_name, __const u_long)); const_nis_name group));
extern nis_error nis_destroygroup __P ((__const nis_name)); extern nis_error nis_removemember __P ((const_nis_name member,
extern void nis_print_group_entry __P ((__const nis_name)); const_nis_name group));
extern nis_error nis_verifygroup __P ((__const nis_name)); extern nis_error nis_creategroup __P ((const_nis_name group, u_long flags));
extern nis_error nis_destroygroup __P ((const_nis_name group));
extern void nis_print_group_entry __P ((const_nis_name group));
extern nis_error nis_verifygroup __P ((const_nis_name group));
/* /*
** nis_ping ** nis_ping
*/ */
extern void nis_ping __P ((__const nis_name, __const u_long, extern void nis_ping __P ((const_nis_name dirname, u_long utime,
__const nis_object *)); const nis_object *dirobj));
extern nis_result *nis_checkpoint __P ((__const nis_name)); extern nis_result *nis_checkpoint __P ((const_nis_name dirname));
/* /*
** nis_print (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) ** nis_print (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!)
*/ */
extern void nis_print_result __P ((__const nis_result *)); extern void nis_print_result __P ((const nis_result *result));
extern void nis_print_rights __P ((__const u_long)); extern void nis_print_rights __P ((u_long rights));
extern void nis_print_directory __P ((__const directory_obj *)); extern void nis_print_directory __P ((const directory_obj *dirobj));
extern void nis_print_group __P ((__const group_obj *)); extern void nis_print_group __P ((const group_obj *grpobj));
extern void nis_print_table __P ((__const table_obj *)); extern void nis_print_table __P ((const table_obj *tblobj));
extern void nis_print_link __P ((__const link_obj *)); extern void nis_print_link __P ((const link_obj *lnkobj));
extern void nis_print_entry __P ((__const entry_obj *)); extern void nis_print_entry __P ((const entry_obj *enobj));
/* /*
** nis_file (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) ** nis_file (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!)
*/ */
extern directory_obj *readColdStartFile __P ((void)); extern directory_obj *readColdStartFile __P ((void));
extern bool_t writeColdStartFile __P ((__const directory_obj *)); extern bool_t writeColdStartFile __P ((const directory_obj *dirobj));
extern nis_object *nis_read_obj __P ((__const char *)); extern nis_object *nis_read_obj __P ((const char *obj));
extern bool_t nis_write_obj __P ((__const char *, __const nis_object *)); extern bool_t nis_write_obj __P ((const char *file, const nis_object *obj));
/* /*
** nis_clone - (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) ** nis_clone - (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!)
*/ */
extern directory_obj *nis_clone_directory __P ((const directory_obj *src,
directory_obj *dest));
extern group_obj *nis_clone_group __P ((const group_obj *src,
group_obj *dest));
extern table_obj *nis_clone_table __P ((const table_obj *src,
table_obj *dest));
extern entry_obj *nis_clone_entry __P ((const entry_obj *src,
entry_obj *dest));
extern link_obj *nis_clone_link __P ((const link_obj *src, link_obj *dest));
extern objdata *nis_clone_objdata __P ((const objdata *src, objdata *dest));
extern nis_result *nis_clone_result __P ((const nis_result *src,
nis_result *dest));
extern directory_obj *nis_clone_directory __P ((__const directory_obj *,
directory_obj *));
extern group_obj *nis_clone_group __P ((__const group_obj *, group_obj *));
extern table_obj *nis_clone_table __P ((__const table_obj *, table_obj *));
extern entry_obj *nis_clone_entry __P ((__const entry_obj *, entry_obj *));
extern link_obj *nis_clone_link __P ((__const link_obj *, link_obj *));
extern objdata *nis_clone_objdata __P ((__const objdata *, objdata *));
extern nis_result *nis_clone_result __P ((__const nis_result *, nis_result *));
/* /*
** nis_free - nis_freeresult ** nis_free - nis_freeresult
*/ */
extern void nis_freeresult __P ((nis_result *)); extern void nis_freeresult __P ((nis_result *result));
/* (XXX INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) */ /* (XXX THE FOLLOWING ARE INTERNAL FUNCTIONS, SHOULD NOT BE USED !!) */
extern void nis_free_attr __P ((nis_attr *)); extern void nis_free_attr __P ((nis_attr *attr));
extern void nis_free_request __P ((ib_request *)); extern void nis_free_request __P ((ib_request *req));
extern void nis_free_endpoints __P ((endpoint *, unsigned int)); extern void nis_free_endpoints __P ((endpoint *ep, unsigned int count));
extern void nis_free_servers __P ((nis_server *, unsigned int)); extern void nis_free_servers __P ((nis_server *machine, unsigned int count));
extern void nis_free_directory __P ((directory_obj *)); extern void nis_free_directory __P ((directory_obj *dirobj));
extern void nis_free_group __P ((group_obj *)); extern void nis_free_group __P ((group_obj *grpobj));
extern void nis_free_table __P ((table_obj *)); extern void nis_free_table __P ((table_obj *tblobj));
extern void nis_free_entry __P ((entry_obj *)); extern void nis_free_entry __P ((entry_obj *enobj));
extern void nis_free_link __P ((link_obj *)); extern void nis_free_link __P ((link_obj *lnkobj));
extern void nis_free_object __P ((nis_object *)); extern void nis_free_object __P ((nis_object *obj));
/* This is the SUN definition, but I don't know for what we need /* This is the SUN definition, but I don't know for what we need
the directory_obj parameter */ the directory_obj parameter */
/* extern fd_result *nis_finddirectory __P ((directory_obj *, nis_name)); */ /* extern fd_result *nis_finddirectory __P ((directory_obj *, nis_name)); */
extern fd_result *__nis_finddirectory __P ((nis_name)); extern fd_result *__nis_finddirectory __P ((const_nis_name name));
extern int __start_clock(int); extern int __start_clock(int);
extern u_long __stop_clock(int); extern u_long __stop_clock(int);

7
posix/getopt.c
View File

@ -397,7 +397,7 @@ _getopt_initialize (argc, argv, optstring)
is the program name); the sequence of previously skipped is the program name); the sequence of previously skipped
non-option ARGV-elements is empty. */ non-option ARGV-elements is empty. */
first_nonopt = last_nonopt = optind = 1; first_nonopt = last_nonopt = optind;
nextchar = NULL; nextchar = NULL;
@ -523,10 +523,11 @@ _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
{ {
optarg = NULL; optarg = NULL;
if (!__getopt_initialized || optind == 0) if (optind == 0 || !__getopt_initialized)
{ {
if (optind == 0)
optind = 1; /* Don't scan ARGV[0], the program name. */
optstring = _getopt_initialize (argc, argv, optstring); optstring = _getopt_initialize (argc, argv, optstring);
optind = 1; /* Don't scan ARGV[0], the program name. */
__getopt_initialized = 1; __getopt_initialized = 1;
} }

59
rellns-sh
View File

@ -22,33 +22,44 @@ if test $# -ne 2; then
exit 1 exit 1
fi fi
case $1 in # A problem with this script is that we must be able to handle symbolic
/*) # links somewhere in the paths of either path. To resolve symlinks we use
# Make both paths absolute. # the `pwd' program. But some `pwd' programs are no real programs but
to=`echo $1 | sed 's%^/%%'` # instead aliases (defined by the user) or builtins (as in bash-2). Both
# kinds have in common that they might not give the correct result. E.g.,
# the builtin in bash-2 returns the path which was used to change to the
# directory and not the real path.
#
# To prevent this problem we make sure the real `pwd' somewhere in the
# path is used. Currently there is only support for bash-2 available.
# If other shells also have problems we have to add more code here.
if test -d $2; then if test "$BASH_VERSINFO" = "2"; then
from=`echo $2 | sed 's%/*$%%'` unalias pwd
else unset pwd
from=`echo $2 | sed 's%/*[^/]*$%%'` enable -n pwd
fi fi
case "$from" in # Make both paths absolute.
/*) from=`echo $from | sed 's%^/*%%'` ;; if test -d $1; then
?*) from=`cd $from && pwd | sed 's%^/%%'` ;; to=`cd $1 && pwd`
*) from=`pwd | sed 's%^/%%'` ;; else
esac temp=`echo $1 | sed 's%/*[^/]*$%%'`
;; to=`cd $temp && pwd`
*) to="$to/`echo $1 | sed 's%.*/\([^/][^/]*\)$%\1%'`"
to=$1 fi
to=`echo $to | sed 's%^/%%'`
if test -d $2; then if test -d $2; then
from=`echo $2 | sed 's%/*$%%'` from=`echo $2 | sed 's%/*$%%'`
else else
from=`echo $2 | sed 's%/*[^/]*$%%'` from=`echo $2 | sed 's%/*[^/]*$%%'`
fi fi
;;
esac if test -z "$from"; then
from=`pwd`;
fi
from=`cd $from && pwd | sed 's%^/%%'`
while test -n "$to" && test -n "$from"; do while test -n "$to" && test -n "$from"; do
preto=`echo $to | sed 's%^\([^/]*\)/.*%\1%'` preto=`echo $to | sed 's%^\([^/]*\)/.*%\1%'`

2
stdio-common/Makefile
View File

@ -39,7 +39,7 @@ aux := errlist siglist
distribute := _itoa.h printf-parse.h distribute := _itoa.h printf-parse.h
tests := tst-printf tstscanf test_rdwr test-popen tstgetln test-fseek \ tests := tst-printf tstscanf test_rdwr test-popen tstgetln test-fseek \
temptest tst-fileno test-fwrite tst-ungetc \ temptest tst-fileno test-fwrite tst-ungetc tst-ferror \
xbug errnobug \ xbug errnobug \
bug1 bug2 bug3 bug4 bug5 bug6 bug7 bug8 bug9 bug10 bug11 \ bug1 bug2 bug3 bug4 bug5 bug6 bug7 bug8 bug9 bug10 bug11 \
tfformat tiformat tstdiomisc \ tfformat tiformat tstdiomisc \

41
stdio-common/tst-ferror.c Normal file
View File

@ -0,0 +1,41 @@
#include <stdio.h>
int
main (int argc, char *argv[])
{
char buf[100];
int result = 0;
if (ferror (stdin) != 0)
{
fputs ("error bit set for stdin at startup\n", stdout);
result = 1;
}
if (fgets (buf, sizeof buf, stdin) != buf)
{
fputs ("fgets with existing input has problem\n", stdout);
result = 1;
}
if (ferror (stdin) != 0)
{
fputs ("error bit set for stdin after setup\n", stdout);
result = 1;
}
if (fputc ('a', stdin) != EOF)
{
fputs ("fputc to stdin does not terminate with an error\n", stdout);
result = 1;
}
if (ferror (stdin) == 0)
{
fputs ("error bit not set for stdin after fputc\n", stdout);
result = 1;
}
clearerr (stdin);
if (ferror (stdin) != 0)
{
fputs ("error bit set for stdin after clearerr\n", stdout);
result = 1;
}
return result;
}

1
stdio-common/tst-ferror.input Normal file
View File

@ -0,0 +1 @@
This is a test.

12
stdlib/erand48_r.c
View File

@ -17,6 +17,7 @@
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */ Boston, MA 02111-1307, USA. */
#include <ieee754.h>
#include <stdlib.h> #include <stdlib.h>
#include <limits.h> #include <limits.h>
@ -27,6 +28,8 @@ erand48_r (xsubi, buffer, result)
struct drand48_data *buffer; struct drand48_data *buffer;
double *result; double *result;
{ {
union ieee754_double temp;
/* Compute next state. */ /* Compute next state. */
if (__drand48_iterate (xsubi, buffer) < 0) if (__drand48_iterate (xsubi, buffer) < 0)
return -1; return -1;
@ -35,9 +38,12 @@ erand48_r (xsubi, buffer, result)
its fractional part so the resulting FP number is [0.0,1.0). */ its fractional part so the resulting FP number is [0.0,1.0). */
#if USHRT_MAX == 65535 #if USHRT_MAX == 65535
*result = ((double) xsubi[2] / (1ULL << 48) + temp.ieee.negative = 0;
(double) xsubi[1] / (1ULL << 32) + temp.ieee.exponent = IEEE754_DOUBLE_BIAS - 1;
(double) xsubi[0] / (1ULL << 16)); temp.ieee.mantissa0 = (xsubi[2] << 4) | (xsubi[1] >> 12);
temp.ieee.mantissa1 = ((xsubi[1] & 0xfff) << 20) | (xsubi[0] << 4);
/* Please note the lower 4 bits of mantissa1 are always 0. */
*result = temp.d;
#else #else
# error Unsupported size of short int # error Unsupported size of short int
#endif #endif

5
sysdeps/generic/signame.c
View File

@ -1,5 +1,5 @@
/* Convert between signal names and numbers. /* Convert between signal names and numbers.
Copyright (C) 1990, 1992, 1993, 1995, 1996 Free Software Foundation, Inc. Copyright (C) 1990, 92, 93, 95, 96, 97 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -231,6 +231,9 @@ signame_init ()
#if defined (SIGINFO) #if defined (SIGINFO)
init_sig (SIGINFO, "INFO", "Information request"); init_sig (SIGINFO, "INFO", "Information request");
#endif #endif
#if defined (SIGNOFP)
init_sig (SIGNOFP, "NOFP", "Floating point co-processor not available");
#endif
} }
/* Return the abbreviation for signal NUMBER. */ /* Return the abbreviation for signal NUMBER. */

0
sunrpc/svc_auth.c → sysdeps/generic/svc_auth.c
View File

11
sysdeps/gnu/utmpbits.h
View File

@ -1,5 +1,5 @@
/* The `struct utmp' type, describing entries in the utmp file. GNU version. /* The `struct utmp' type, describing entries in the utmp file. GNU version.
Copyright (C) 1993, 1996 Free Software Foundation, Inc. Copyright (C) 1993, 1996, 1997 Free Software Foundation, Inc.
The GNU C Library is free software; you can redistribute it and/or The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as modify it under the terms of the GNU Library General Public License as
@ -100,8 +100,13 @@ struct utmp
}; };
/* Backwards compatibility hacks. */ /* Backwards compatibility hacks. */
#define ut_time ut_tv.tv_sec #ifndef _NO_UT_TIME
#define ut_addr ut_addr_v6[0] /* We have a problem here: `ut_time' is also used otherwise. Define
_NO_UT_TIME if the compiler complains. */
# define ut_time ut_tv.tv_sec
#endif
#define ut_xtime ut_tv.tv_sec
#define ut_addr ut_addr_v6[0]
/* Tell the user that we have a modern system with UT_HOST, UT_PID, /* Tell the user that we have a modern system with UT_HOST, UT_PID,
UT_TYPE, UT_ID and UT_TV fields. */ UT_TYPE, UT_ID and UT_TV fields. */

32
sysdeps/libm-i387/s_rinttol.S Normal file
View File

@ -0,0 +1,32 @@
/* Round argument to nearest integral value according to current rounding
direction.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <sysdep.h>
.text
ENTRY(__rinttol)
fldt 4(%esp)
subl $4, %esp
fistpl (%esp)
popl %eax
ret
END(__rinttol)
weak_alias (__rinttol, rinttol)

33
sysdeps/libm-i387/s_rinttoll.S Normal file
View File

@ -0,0 +1,33 @@
/* Round argument to nearest integral value according to current rounding
direction.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <sysdep.h>
.text
ENTRY(__rinttoll)
fldt 4(%esp)
subl $8, %esp
fistpll (%esp)
popl %eax
popl %edx
ret
END(__rinttoll)
weak_alias (__rinttoll, rinttoll)

2
sysdeps/libm-ieee754/s_cexp.c
View File

@ -91,6 +91,6 @@ __cexp (__complex__ double x)
} }
weak_alias (__cexp, cexp) weak_alias (__cexp, cexp)
#ifdef NO_LONG_DOUBLE #ifdef NO_LONG_DOUBLE
string_alias (__cexp, __cexpl) strong_alias (__cexp, __cexpl)
weak_alias (__cexp, cexpl) weak_alias (__cexp, cexpl)
#endif #endif

61
sysdeps/libm-ieee754/s_clog.c Normal file
View File

@ -0,0 +1,61 @@
/* Compute complex natural logarithm.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <complex.h>
#include <math.h>
#include "math_private.h"
__complex__ double
__clog (__complex__ double x)
{
__complex__ double result;
if (__real__ x == 0.0 && __imag__ x == 0.0)
{
__imag__ result = signbit (__real__ x) ? M_PI : 0.0;
if (signbit (__imag__ x))
__imag__ result = __copysign (__imag__ result, -1.0);
/* Yes, the following line raises an exception. */
__real__ result = -1.0 / fabs (__real__ x);
}
else if (!__isnan (__real__ x) && !__isnan (__imag__ x))
{
__real__ result = __ieee754_log (__ieee754_hypot (__real__ x,
__imag__ x));
__imag__ result = __ieee754_atan2 (__imag__ x, __real__ x);
}
else
{
__imag__ result = __nan ("");
if (__isinf (__real__ x) || __isinf (__imag__ x))
__real__ result = HUGE_VAL;
else
__real__ result = __nan ("");
}
return result;
}
weak_alias (__clog, clog)
#ifdef NO_LONG_DOUBLE
strong_alias (__clog, __clogl)
weak_alias (__clog, clogl)
#endif

57
sysdeps/libm-ieee754/s_clogf.c Normal file
View File

@ -0,0 +1,57 @@
/* Compute complex natural logarithm.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <complex.h>
#include <math.h>
#include "math_private.h"
__complex__ float
__clogf (__complex__ float x)
{
__complex__ float result;
if (__real__ x == 0.0 && __imag__ x == 0.0)
{
__imag__ result = signbit (__real__ x) ? M_PI : 0.0;
if (signbit (__imag__ x))
__imag__ result = __copysignf (__imag__ result, -1.0);
/* Yes, the following line raises an exception. */
__real__ result = -1.0 / fabsf (__real__ x);
}
else if (!__isnanf (__real__ x) && !__isnanf (__imag__ x))
{
__real__ result = __ieee754_logf (__ieee754_hypotf (__real__ x,
__imag__ x));
__imag__ result = __ieee754_atan2f (__imag__ x, __real__ x);
}
else
{
__imag__ result = __nanf ("");
if (__isinff (__real__ x) || __isinff (__imag__ x))
__real__ result = HUGE_VALF;
else
__real__ result = __nanf ("");
}
return result;
}
weak_alias (__clogf, clogf)

57
sysdeps/libm-ieee754/s_clogl.c Normal file
View File

@ -0,0 +1,57 @@
/* Compute complex natural logarithm.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <complex.h>
#include <math.h>
#include "math_private.h"
__complex__ long double
__clogl (__complex__ long double x)
{
__complex__ long double result;
if (__real__ x == 0.0 && __imag__ x == 0.0)
{
__imag__ result = signbit (__real__ x) ? M_PI : 0.0;
if (signbit (__imag__ x))
__imag__ result = __copysignl (__imag__ result, -1.0);
/* Yes, the following line raises an exception. */
__real__ result = -1.0 / fabsl (__real__ x);
}
else if (!__isnanl (__real__ x) && !__isnanl (__imag__ x))
{
__real__ result = __ieee754_logl (__ieee754_hypotl (__real__ x,
__imag__ x));
__imag__ result = __ieee754_atan2l (__imag__ x, __real__ x);
}
else
{
__imag__ result = __nanl ("");
if (__isinfl (__real__ x) || __isinfl (__imag__ x))
__real__ result = HUGE_VALL;
else
__real__ result = __nanl ("");
}
return result;
}
weak_alias (__clogl, clogl)

20
sysdeps/libm-ieee754/s_rintl.c
View File

@ -36,9 +36,9 @@ static const long double
#else #else
static long double static long double
#endif #endif
TWO64[2]={ TWO63[2]={
1.844674407370955161600000e+19, /* 0x403F, 0x00000000, 0x00000000 */ 9.223372036854775808000000e+18, /* 0x403E, 0x00000000, 0x00000000 */
-1.844674407370955161600000e+19, /* 0xC03F, 0x00000000, 0x00000000 */ -9.223372036854775808000000e+18 /* 0xC03E, 0x00000000, 0x00000000 */
}; };
#ifdef __STDC__ #ifdef __STDC__
@ -61,8 +61,8 @@ TWO64[2]={
i0 &= 0xe0000000; i0 &= 0xe0000000;
i0 |= (i1|-i1)&0x80000000; i0 |= (i1|-i1)&0x80000000;
SET_LDOUBLE_MSW(x,i0); SET_LDOUBLE_MSW(x,i0);
w = TWO64[sx]+x; w = TWO63[sx]+x;
t = w-TWO64[sx]; t = w-TWO63[sx];
GET_LDOUBLE_EXP(i0,t); GET_LDOUBLE_EXP(i0,t);
SET_LDOUBLE_EXP(t,(i0&0x7fff)|(sx<<15)); SET_LDOUBLE_EXP(t,(i0&0x7fff)|(sx<<15));
return t; return t;
@ -80,17 +80,17 @@ TWO64[2]={
s_rintf, too. -- drepper@cygnus.com */ s_rintf, too. -- drepper@cygnus.com */
} }
} }
} else if (j0>63) { } else if (j0>62) {
if(j0==0x4000) return x+x; /* inf or NaN */ if(j0==0x4000) return x+x; /* inf or NaN */
else return x; /* x is integral */ else return x; /* x is integral */
} else { } else {
i = ((u_int32_t)(0xffffffff))>>(j0-32); i = ((u_int32_t)(0xffffffff))>>(j0-31);
if((i1&i)==0) return x; /* x is integral */ if((i1&i)==0) return x; /* x is integral */
i>>=1; i>>=1;
if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-32)); if((i1&i)!=0) i1 = (i1&(~i))|((0x40000000)>>(j0-31));
} }
SET_LDOUBLE_WORDS(x,se,i0,i1); SET_LDOUBLE_WORDS(x,se,i0,i1);
w = TWO64[sx]+x; w = TWO63[sx]+x;
return w-TWO64[sx]; return w-TWO63[sx];
} }
weak_alias (__rintl, rintl) weak_alias (__rintl, rintl)

242
sysdeps/libm-ieee754/s_rinttol.c Normal file
View File

@ -0,0 +1,242 @@
/* Round argument to nearest integral value according to current rounding
direction.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <math.h>
#include "math_private.h"
#ifdef NO_LONG_DOUBLE
/* The `long double' is in fact the IEEE `double' type. */
static long double two52[2] =
{
4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
};
long int
__rinttol (long double x)
{
int32_t j0,sx;
u_int32_t i0,i1,i;
long double t, w;
long int result;
EXTRACT_WORDS (i0, i1, x);
sx = i0 >> 31;
j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
if (j0 < 20)
{
if (j0 < 0)
{
if (((i0 & 0x7fffffff) | i1) == 0)
/* The number is 0. */
result = 0;
else
{
i1 |= i0;
i0 &= 0xfffe0000;
i0 |= ((i1 | -i1) >> 12) & 0x80000;
SET_HIGH_WORD (x, i0);
w = two52[sx] + x;
t = w - two52[sx];
GET_HIGH_WORD (i0, t);
if ((i0 & 0x7fffffff) >= 0x3fff0000)
result = sx ? -1 : 1;
else
result = 0;
}
}
else
{
u_int32_t i = 0x000fffff >> j0;
if (((i0 & i) | i1) == 0)
{
/* X is not integral. */
i >>= 1;
if (((i0 & i) | i1) != 0)
{
if (j0 == 19)
i1 = 0x40000000;
else
i0 = (i0 & (~i)) | (0x20000 >> j0);
INSERT_WORDS (x, i0, i1);
w = two52[sx] + x;
x = w - two52[sx];
EXTRACT_WORDS (i0, i1, x);
j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
}
}
result = ((i0 >> (20 - j0)) & 0xfffff) | (0x00100000 >> (20 - j0));
if (sx)
result = -result;
}
}
else if ((unsigned int) j0 < sizeof (long int) * 8 && j0 < 53)
{
i = ((u_int32_t) (0xffffffff)) >> (j0 - 20);
if ((i1 & i) != 0)
{
/* x is not integral. */
i >>= 1;
if ((i1 & i) != 0)
i1 = (i1 & (~i)) | (0x40000000 >> (j0 - 20));
}
INSERT_WORDS (x, i0, i1);
w = two52[sx] + x;
x = w - two52[sx];
EXTRACT_WORDS (i0, i1, x);
j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
result = i0 | 0x00100000;
if (j0 > 20)
{
result <<= j0 - 20;
result |= i1 >> (52 - j0);
}
if (sx)
result = -result;
}
else
/* Too large. The number is either +-inf or NaN or it is too
large to be effected by rounding. The standard leaves it
undefined what to return when the number is too large to fit in
a `long int'. */
result = (long int) x;
return result;
}
#else
static long double two63[2] =
{
9.223372036854775808000000e+18, /* 0x403E, 0x00000000, 0x00000000 */
-9.223372036854775808000000e+18 /* 0xC03E, 0x00000000, 0x00000000 */
};
long int
__rinttol (long double x)
{
int32_t se,j0,sx;
u_int32_t i0,i1,i;
long int result;
long double w, t;
GET_LDOUBLE_WORDS (se, i0, i1, x);
sx = (se >> 15) & 1;
j0 = (se & 0x7fff) - 0x3fff;
if (j0 < 31)
{
if (j0 < 0)
{
if (((se & 0x7fff) | i0 | i1) == 0)
/* The number is 0. */
result = 0;
else
{
i1 |= i0;
i0 &= 0xe0000000;
i0 |= (i1 | -i1) & 0x80000000;
SET_LDOUBLE_MSW (x, i0);
w = two63[sx] + x;
t = w - two63[sx];
GET_LDOUBLE_EXP (i0, t);
if ((i0 & 0x7fff) >= 0x3fff)
result = sx ? -1 : 1;
else
result = 0;
}
}
else
{
u_int32_t i = 0x7fffffff >> j0;
if (((i0 & i) | i1) == 0)
{
/* X is not integral. */
i >>= 1;
if (((i0 & i) | i1) != 0)
{
if (j0 == 31)
i1 = 0x40000000;
else
i0 = (i0 & (~i)) | (0x20000000 >> j0);
SET_LDOUBLE_WORDS (x, se, i0, i1);
w = two63[sx] + x;
x = w - two63[sx];
GET_LDOUBLE_WORDS (se, i0, i1, x);
sx = (se >> 15) & 1;
j0 = (se & 0x7fff) - 0x3fff;
}
}
result = i0 >> (31 - j0);
}
}
else if ((unsigned int) j0 < sizeof (long int) * 8 && j0 < 64)
{
i = ((u_int32_t) (0xffffffff)) >> (j0 - 31);
if ((i1 & i) != 0)
{
/* x is not integral. */
i >>= 1;
if ((i1 & i) != 0)
i1 = (i1 & (~i)) | (0x40000000 >> (j0 - 31));
}
SET_LDOUBLE_WORDS (x, se, i0, i1);
w = two63[sx] + x;
x = w - two63[sx];
GET_LDOUBLE_WORDS (se, i0, i1, x);
j0 = (se & 0x7fff) - 0x3fff;
result = i0;
if (j0 > 31)
{
result <<= j0 - 31;
result |= i1 >> (63 - j0);
}
}
else
/* Too large. The number is either +-inf or NaN or it is too
large to be effected by rounding. The standard leaves it
undefined what to return when the number is too large to fit in
a `long int'. */
result = (long int) x;
return result;
}
#endif
weak_alias (__rinttol, rinttol)

242
sysdeps/libm-ieee754/s_rinttoll.c Normal file
View File

@ -0,0 +1,242 @@
/* Round argument to nearest integral value according to current rounding
direction.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <math.h>
#include "math_private.h"
#ifdef NO_LONG_DOUBLE
/* The `long double' is in fact the IEEE `double' type. */
static long double two52[2] =
{
4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
};
long long int
__rinttoll (long double x)
{
int32_t j0,sx;
u_int32_t i0, i1, i;
long double t, w;
long long int result;
EXTRACT_WORDS (i0, i1, x);
sx = i0 >> 31;
j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
if (j0 < 20)
{
if (j0 < 0)
{
if (((i0 & 0x7fffffff) | i1) == 0)
/* The number is 0. */
result = 0;
else
{
i1 |= i0;
i0 &= 0xfffe0000;
i0 |= ((i1 | -i1) >> 12) & 0x80000;
SET_HIGH_WORD (x, i0);
w = two52[sx] + x;
t = w - two52[sx];
GET_HIGH_WORD (i0, t);
if ((i0 & 0x7fffffff) >= 0x3fff0000)
result = sx ? -1 : 1;
else
result = 0;
}
}
else
{
u_int32_t i = 0x000fffff >> j0;
if (((i0 & i) | i1) == 0)
{
/* X is not integral. */
i >>= 1;
if (((i0 & i) | i1) != 0)
{
if (j0 == 19)
i1 = 0x40000000;
else
i0 = (i0 & (~i)) | (0x20000 >> j0);
INSERT_WORDS (x, i0, i1);
w = two52[sx] + x;
x = w - two52[sx];
EXTRACT_WORDS (i0, i1, x);
j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
}
}
result = ((i0 >> (20 - j0)) & 0xfffff) | (0x00100000 >> (20 - j0));
if (sx)
result = -result;
}
}
else if ((unsigned int) j0 < sizeof (long long int) * 8 && j0 < 53)
{
i = ((u_int32_t) (0xffffffff)) >> (j0 - 20);
if ((i1 & i) != 0)
{
/* x is not integral. */
i >>= 1;
if ((i1 & i) != 0)
i1 = (i1 & (~i)) | (0x40000000 >> (j0 - 20));
}
INSERT_WORDS (x, i0, i1);
w = two52[sx] + x;
x = w - two52[sx];
EXTRACT_WORDS (i0, i1, x);
j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
result = i0 | 0x00100000;
if (j0 > 20)
{
result <<= j0 - 20;
result |= i1 >> (52 - j0);
}
if (sx)
result = -result;
}
else
/* Too large. The number is either +-inf or NaN or it is too
large to be effected by rounding. The standard leaves it
undefined what to return when the number is too large to fit in
a `long int'. */
result = (long long int) x;
return result;
}
#else
static long double two63[2] =
{
9.223372036854775808000000e+18, /* 0x403E, 0x00000000, 0x00000000 */
-9.223372036854775808000000e+18 /* 0xC03E, 0x00000000, 0x00000000 */
};
long long int
__rinttoll (long double x)
{
int32_t se,j0,sx;
u_int32_t i0, i1, i;
long long int result;
long double w, t;
GET_LDOUBLE_WORDS (se, i0, i1, x);
sx = (se >> 15) & 1;
j0 = (se & 0x7fff) - 0x3fff;
if (j0 < 31)
{
if (j0 < 0)
{
if (((se & 0x7fff) | i0 | i1) == 0)
/* The number is 0. */
result = 0;
else
{
i1 |= i0;
i0 &= 0xe0000000;
i0 |= (i1 | -i1) & 0x80000000;
SET_LDOUBLE_MSW (x, i0);
w = two63[sx] + x;
t = w - two63[sx];
GET_LDOUBLE_EXP (i0, t);
if ((i0 & 0x7fff) >= 0x3fff)
result = sx ? -1 : 1;
else
result = 0;
}
}
else
{
u_int32_t i = 0x7fffffff >> j0;
if (((i0 & i) | i1) == 0)
{
/* X is not integral. */
i >>= 1;
if (((i0 & i) | i1) != 0)
{
if (j0 == 31)
i1 = 0x40000000;
else
i0 = (i0 & (~i)) | (0x20000000 >> j0);
SET_LDOUBLE_WORDS (x, se, i0, i1);
w = two63[sx] + x;
x = w - two63[sx];
GET_LDOUBLE_WORDS (se, i0, i1, x);
sx = (se >> 15) & 1;
j0 = (se & 0x7fff) - 0x3fff;
}
}
result = i0 >> (31 - j0);
}
}
else if ((unsigned int) j0 < sizeof (long long int) * 8 && j0 < 64)
{
i = ((u_int32_t) (0xffffffff)) >> (j0 - 31);
if ((i1 & i) != 0)
{
/* x is not integral. */
i >>= 1;
if ((i1 & i) != 0)
i1 = (i1 & (~i)) | (0x40000000 >> (j0 - 31));
}
SET_LDOUBLE_WORDS (x, se, i0, i1);
w = two63[sx] + x;
x = w - two63[sx];
GET_LDOUBLE_WORDS (se, i0, i1, x);
j0 = (se & 0x7fff) - 0x3fff;
result = i0;
if (j0 > 31)
{
result <<= j0 - 31;
result |= i1 >> (63 - j0);
}
}
else
/* Too large. The number is either +-inf or NaN or it is too
large to be effected by rounding. The standard leaves it
undefined what to return when the number is too large to fit in
a `long int'. */
result = (long long int) x;
return result;
}
#endif
weak_alias (__rinttoll, rinttoll)

1
sysdeps/unix/sysv/linux/netatalk/at.h
View File

@ -20,6 +20,7 @@
#define __NETATALK_ATALK_H 1 #define __NETATALK_ATALK_H 1
#include <asm/types.h> #include <asm/types.h>
#include <sys/socket.h>
#include <linux/atalk.h> #include <linux/atalk.h>
#define SOL_ATALK 258 /* sockopt level for atalk */ #define SOL_ATALK 258 /* sockopt level for atalk */

18
time/time.h
View File

@ -22,8 +22,8 @@
#ifndef _TIME_H #ifndef _TIME_H
#if (! defined (__need_time_t) && !defined (__need_clock_t) && \ #if (! defined __need_time_t && !defined __need_clock_t && \
! defined (__need_timespec)) ! defined __need_timespec)
#define _TIME_H 1 #define _TIME_H 1
#include <features.h> #include <features.h>
@ -56,8 +56,7 @@ __BEGIN_DECLS
#endif /* <time.h> included. */ #endif /* <time.h> included. */
#if !defined (__clock_t_defined) && \ #if !defined __clock_t_defined && (defined _TIME_H || defined __need_clock_t)
(defined (_TIME_H) || defined (__need_clock_t))
#define __clock_t_defined 1 #define __clock_t_defined 1
#include <gnu/types.h> #include <gnu/types.h>
@ -68,8 +67,7 @@ typedef __clock_t clock_t;
#endif /* clock_t not defined and <time.h> or need clock_t. */ #endif /* clock_t not defined and <time.h> or need clock_t. */
#undef __need_clock_t #undef __need_clock_t
#if !defined (__time_t_defined) && \ #if !defined __time_t_defined && (defined _TIME_H || defined __need_time_t)
(defined (_TIME_H) || defined (__need_time_t))
#define __time_t_defined 1 #define __time_t_defined 1
#include <gnu/types.h> #include <gnu/types.h>
@ -81,9 +79,9 @@ typedef __time_t time_t;
#undef __need_time_t #undef __need_time_t
#if ! defined (__timespec_defined) && \ #if ! defined __timespec_defined && \
((defined (_TIME_H) && defined (__USE_POSIX)) || \ ((defined _TIME_H && defined __USE_POSIX) || \
defined (__need_timespec)) defined __need_timespec)
#define __timespec_defined 1 #define __timespec_defined 1
/* POSIX.4 structure for a time value. This is like a `struct timeval' but /* POSIX.4 structure for a time value. This is like a `struct timeval' but
@ -235,7 +233,7 @@ extern long int __tzname_max __P ((void));
extern void tzset __P ((void)); extern void tzset __P ((void));
#endif #endif
#if defined(__USE_SVID) || defined(__USE_XOPEN) #if defined __USE_SVID || defined __USE_XOPEN
extern int daylight; extern int daylight;
extern long int timezone; extern long int timezone;
#endif #endif