summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJakub Jelinek <jakub@redhat.com>2004-09-30 09:05:55 +0000
committerJakub Jelinek <jakub@redhat.com>2004-09-30 09:05:55 +0000
commit6a87697239310dd529781d9db1ee705eeaa5405e (patch)
treed89bd4ede05cf7918178e39da5950535725717d8
parentbd307f4e23f985b55276724a00f88e07309e68be (diff)
Updated to fedora-glibc-20040930T0838cvs/fedora-glibc-2_3_3-61
-rw-r--r--ChangeLog80
-rw-r--r--fedora/branch.mk4
-rw-r--r--fedora/glibc.spec.in15
-rw-r--r--grp/Makefile4
-rw-r--r--grp/compat-initgroups.c98
-rw-r--r--grp/initgroups.c119
-rw-r--r--nscd/Makefile7
-rw-r--r--nscd/cache.c4
-rw-r--r--nscd/connections.c12
-rw-r--r--nscd/initgrcache.c391
-rw-r--r--nscd/nscd-client.h27
-rw-r--r--nscd/nscd.c13
-rw-r--r--nscd/nscd.h7
-rw-r--r--nscd/nscd_getai.c42
-rw-r--r--nscd/nscd_getgr_r.c48
-rw-r--r--nscd/nscd_gethst_r.c39
-rw-r--r--nscd/nscd_getpw_r.c35
-rw-r--r--nscd/nscd_helper.c2
-rw-r--r--nscd/nscd_initgroups.c168
-rw-r--r--nscd/nscd_proto.h5
-rw-r--r--nscd/selinux.c3
-rw-r--r--posix/tst-gnuglob.c12
-rw-r--r--sunrpc/clnt_udp.c1
-rw-r--r--sunrpc/get_myaddr.c4
-rw-r--r--sunrpc/pmap_clnt.c4
-rw-r--r--sunrpc/pmap_rmt.c1
-rw-r--r--sysdeps/alpha/fpu/bits/mathinline.h8
-rw-r--r--sysdeps/generic/glob.c66
-rw-r--r--sysdeps/powerpc/fpu/bits/mathinline.h4
-rw-r--r--sysdeps/sparc/fpu/bits/mathinline.h4
-rw-r--r--sysdeps/unix/sysv/linux/ia64/bits/siginfo.h6
31 files changed, 1028 insertions, 205 deletions
diff --git a/ChangeLog b/ChangeLog
index cf39515d6d..4bd6ca1116 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,12 +1,92 @@
+2004-09-30 Ulrich Drepper <drepper@redhat.com>
+
+ * nscd/nscd.c (termination_handler): Reset timestamp so that
+ clients immediately stop using the database.
+
+ * nscd/nscd-client.h (__nscd_get_map_ref): Drop volatile from last
+ parameter.
+ (__nscd_drop_map_ref): Change second parameter to be a reference to
+ a variable. Update variable when cycle count changed.
+ * nscd/nscd_helper.c (__nscd_get_map_ref): Remove volatile here, too.
+ * nscd/nscd_getai.c: Correctly use __nscd_drop_map_ref. Reinitialize
+ all variables and avoid memory leak in case of retries.
+ * nscd/nscd_getgr_r.c: Likewise.
+ * nscd/nscd_gethst_r.c: Likewise.
+ * nscd/nscd_getpw_r.c: Likewise.
+ * nscd/nscd_initgroups.c: Likewise.
+
+ * nscd/nscd.h: Add declaration of addinitgroups and
+ readdinitgroups.
+
+2004-09-30 Andreas Jaeger <aj@suse.de>
+
+ * nscd/Makefile (CFLAGS-nscd_initgroups.c): Set to -fpie.
+ (CFLAGS-initgrcache.c): Set to -fexceptions.
+
+2004-09-29 Ulrich Drepper <drepper@redhat.com>
+
+ * sysdeps/generic/glob.c (glob_in_dir): Don't blindly trust
+ readdir results; for symlinks or files of unknown type check using
+ stat whether the file exists.
+
+ * posix/tst-gnuglob.c (find_file): Handle leading "./". Fix
+ recognition of files.
+
2004-09-29 Jakub Jelinek <jakub@redhat.com>
* time/tzfile.c (tzfile_mtime): New variable.
(__tzfile_read): Reread the file if mtime is different.
+2004-09-28 Jakub Jelinek <jakub@redhat.com>
+
+ * sysdeps/alpha/fpu/bits/mathinline.h (__fdimf, __fdim, fdimf, fdim):
+ Handle +inf/+inf.
+ * sysdeps/powerpc/fpu/bits/mathinline.h (fdim, fdimf): Likewise.
+ * sysdeps/sparc/fpu/bits/mathinline.h (fdim, fdimf): Likewise.
+
+2004-09-29 Ulrich Drepper <drepper@redhat.com>
+
+ * nscd/nscd_gethst_r.c (nscd_gethst_r): Use correct constant for
+ testing result of __nscd_get_map_ref.
+
+2004-09-29 Jakub Jelinek <jakub@redhat.com>
+
* sysdeps/i386/fpu/s_fdim.S (__fdim): Handle +inf/+inf.
* sysdeps/i386/fpu/s_fdimf.S (__fdimf): Likewise.
* sysdeps/i386/fpu/s_fdiml.S (__fdiml): Likewise.
+004-09-29 Ulrich Drepper <drepper@redhat.com>
+
+ * grp/initgroups.c: Move compat_call implementation...
+ * grp/compat-initgroups.c: ...to here. New file.
+ * grp/Makefile (distribute): Add compat-initgroups.c.
+ (CFLAGS-initgroups.c): Add -DUSE_NSCD=1.
+ * mscd/initgrcache.c: New file.
+ * nscd/nscd_initgroups.c: New file.
+ * nscd/Makefile (routines): Add nscd_initgroups.
+ (nscd-modules): Add initgrcache.
+ * nscd/cache.c (prune_cache): Add support for INITGROUPS entries.
+ * nscd/connections.c: Handle INITGROUPS requests.
+ * nscd/nscd-client.h: Define INITGROUPS, initgr_response_header.
+ Add initgrdata element to struct datahead. Fix typo in comment.
+ * nscd/nscd_proto.h: Declare __nscd_getgrouplist. Fix parameter
+ type in __nscd_getgrgrid_r.
+ * nscd/selinux.c (perms): Add INITGROUPS entry.
+
+ * nscd/nscd_getai.c: No need to include <sys/mman.h>.
+
+ * sunrpc/get_myaddr.c (get_myaddress): Account for interfaces without
+ assigned addresses.
+ * sunrpc/pmap_clnt.c (__get_myaddress): Likewise.
+ * sunrpc/pmap_rmt.c (getbroadcastnets): Likewise.
+ * sunrpc/clnt_udp.c (is_network_up): Likewise.
+
+ * nscd/nscd.c: Define getaddrinfo hidden so that it is never found
+ outside.
+
+ * sysdeps/unix/sysv/linux/ia64/bits/siginfo.h (si_segvflags):
+ Renamed from si_flags due to conflict with si_flags from <elf.h>.
+
2004-09-28 Ulrich Drepper <drepper@redhat.com>
* nscd/nscd_getai.c: Use NO_MAPPING instead of MAP_FAILED for test
diff --git a/fedora/branch.mk b/fedora/branch.mk
index b85d5f7846..9f401a0c8b 100644
--- a/fedora/branch.mk
+++ b/fedora/branch.mk
@@ -1,5 +1,5 @@
# This file is updated automatically by Makefile.
glibc-branch := fedora
glibc-base := HEAD
-fedora-sync-date := 2004-09-29 08:21 UTC
-fedora-sync-tag := fedora-glibc-20040929T0821
+fedora-sync-date := 2004-09-30 08:38 UTC
+fedora-sync-tag := fedora-glibc-20040930T0838
diff --git a/fedora/glibc.spec.in b/fedora/glibc.spec.in
index 2d32470640..a6d0d71af2 100644
--- a/fedora/glibc.spec.in
+++ b/fedora/glibc.spec.in
@@ -1,4 +1,4 @@
-%define glibcrelease 60
+%define glibcrelease 61
%define auxarches i586 i686 athlon sparcv9 alphaev6
%define prelinkarches noarch
%define nptlarches i386 i686 athlon x86_64 ia64 s390 s390x sparcv9 ppc ppc64
@@ -708,10 +708,10 @@ gzip -9nvf $RPM_BUILD_ROOT%{_infodir}/libc*
ln -sf libbsd-compat.a $RPM_BUILD_ROOT%{_prefix}/%{_lib}/libbsd.a
-install -m 644 fedora/nsswitch.conf $RPM_BUILD_ROOT/etc/nsswitch.conf
+install -p -m 644 fedora/nsswitch.conf $RPM_BUILD_ROOT/etc/nsswitch.conf
mkdir -p $RPM_BUILD_ROOT/etc/default
-install -m 644 nis/nss $RPM_BUILD_ROOT/etc/default/nss
+install -p -m 644 nis/nss $RPM_BUILD_ROOT/etc/default/nss
# Take care of setuids
# -- new security review sez that this shouldn't be needed anymore
@@ -1239,6 +1239,15 @@ rm -f *.filelist*
%endif
%changelog
+* Thu Sep 30 2004 Jakub Jelinek <jakub@redhat.com> 2.3.3-61
+- update from CVS
+ - some nscd fixes (#134193)
+ - cache initgroups in nscd (#132850)
+ - reread /etc/localtime in tzset () even if just mtime changed
+ (#133481)
+ - fix glob (#126460)
+ - another get_myaddress fix
+
* Wed Sep 29 2004 Jakub Jelinek <jakub@redhat.com> 2.3.3-60
- update from CVS
- fix get_myaddress (#133982)
diff --git a/grp/Makefile b/grp/Makefile
index 54e86394ba..e6ca864a49 100644
--- a/grp/Makefile
+++ b/grp/Makefile
@@ -22,7 +22,7 @@
subdir := grp
headers := grp.h
-distribute := tst_fgetgrent.c tst_fgetgrent.sh
+distribute := tst_fgetgrent.c tst_fgetgrent.sh compat-initgroups.c
routines := fgetgrent initgroups setgroups \
getgrent getgrgid getgrnam putgrent \
@@ -54,7 +54,7 @@ CFLAGS-getgrent.c = -fexceptions
CFLAGS-fgetgrent.c = -fexceptions
CFLAGS-fgetgrent_r.c = -fexceptions -D_IO_MTSAFE_IO
CFLAGS-putgrent.c = -fexceptions -D_IO_MTSAFE_IO
-CFLAGS-initgroups.c = -fexceptions
+CFLAGS-initgroups.c = -DUSE_NSCD=1 -fexceptions
CFLAGS-getgrgid.c = -fexceptions
endif
diff --git a/grp/compat-initgroups.c b/grp/compat-initgroups.c
new file mode 100644
index 0000000000..585c4aecbb
--- /dev/null
+++ b/grp/compat-initgroups.c
@@ -0,0 +1,98 @@
+/* Prototype for the setgrent functions we use here. */
+typedef enum nss_status (*set_function) (void);
+
+/* Prototype for the endgrent functions we use here. */
+typedef enum nss_status (*end_function) (void);
+
+/* Prototype for the setgrent functions we use here. */
+typedef enum nss_status (*get_function) (struct group *, char *,
+ size_t, int *);
+
+static enum nss_status
+compat_call (service_user *nip, const char *user, gid_t group, long int *start,
+ long int *size, gid_t **groupsp, long int limit, int *errnop)
+{
+ struct group grpbuf;
+ size_t buflen = __sysconf (_SC_GETGR_R_SIZE_MAX);
+ char *tmpbuf;
+ enum nss_status status;
+ set_function setgrent_fct;
+ get_function getgrent_fct;
+ end_function endgrent_fct;
+ gid_t *groups = *groupsp;
+
+ getgrent_fct = __nss_lookup_function (nip, "getgrent_r");
+ if (getgrent_fct == NULL)
+ return NSS_STATUS_UNAVAIL;
+
+ setgrent_fct = __nss_lookup_function (nip, "setgrent");
+ if (setgrent_fct)
+ {
+ status = DL_CALL_FCT (setgrent_fct, ());
+ if (status != NSS_STATUS_SUCCESS)
+ return status;
+ }
+
+ endgrent_fct = __nss_lookup_function (nip, "endgrent");
+
+ tmpbuf = __alloca (buflen);
+
+ do
+ {
+ while ((status = DL_CALL_FCT (getgrent_fct,
+ (&grpbuf, tmpbuf, buflen, errnop)),
+ status == NSS_STATUS_TRYAGAIN)
+ && *errnop == ERANGE)
+ {
+ buflen *= 2;
+ tmpbuf = __alloca (buflen);
+ }
+
+ if (status != NSS_STATUS_SUCCESS)
+ goto done;
+
+ if (grpbuf.gr_gid != group)
+ {
+ char **m;
+
+ for (m = grpbuf.gr_mem; *m != NULL; ++m)
+ if (strcmp (*m, user) == 0)
+ {
+ /* Matches user. Insert this group. */
+ if (__builtin_expect (*start == *size, 0))
+ {
+ /* Need a bigger buffer. */
+ gid_t *newgroups;
+ long int newsize;
+
+ if (limit > 0 && *size == limit)
+ /* We reached the maximum. */
+ goto done;
+
+ if (limit <= 0)
+ newsize = 2 * *size;
+ else
+ newsize = MIN (limit, 2 * *size);
+
+ newgroups = realloc (groups, newsize * sizeof (*groups));
+ if (newgroups == NULL)
+ goto done;
+ *groupsp = groups = newgroups;
+ *size = newsize;
+ }
+
+ groups[*start] = grpbuf.gr_gid;
+ *start += 1;
+
+ break;
+ }
+ }
+ }
+ while (status == NSS_STATUS_SUCCESS);
+
+ done:
+ if (endgrent_fct)
+ DL_CALL_FCT (endgrent_fct, ());
+
+ return NSS_STATUS_SUCCESS;
+}
diff --git a/grp/initgroups.c b/grp/initgroups.c
index 858dd314e5..9e79273f3e 100644
--- a/grp/initgroups.c
+++ b/grp/initgroups.c
@@ -27,19 +27,14 @@
#include <sys/types.h>
#include <nsswitch.h>
+#include "../nscd/nscd-client.h"
+#include "../nscd/nscd_proto.h"
+
+
/* Type of the lookup function. */
typedef enum nss_status (*initgroups_dyn_function) (const char *, gid_t,
long int *, long int *,
gid_t **, long int, int *);
-/* Prototype for the setgrent functions we use here. */
-typedef enum nss_status (*set_function) (void);
-
-/* Prototype for the endgrent functions we use here. */
-typedef enum nss_status (*end_function) (void);
-
-/* Prototype for the setgrent functions we use here. */
-typedef enum nss_status (*get_function) (struct group *, char *,
- size_t, int *);
/* The lookup function for the first entry of this service. */
extern int __nss_group_lookup (service_user **nip, const char *name,
@@ -48,99 +43,29 @@ extern void *__nss_lookup_function (service_user *ni, const char *fct_name);
extern service_user *__nss_group_database attribute_hidden;
-static enum nss_status
-compat_call (service_user *nip, const char *user, gid_t group, long int *start,
- long int *size, gid_t **groupsp, long int limit, int *errnop)
-{
- struct group grpbuf;
- size_t buflen = __sysconf (_SC_GETGR_R_SIZE_MAX);
- char *tmpbuf;
- enum nss_status status;
- set_function setgrent_fct;
- get_function getgrent_fct;
- end_function endgrent_fct;
- gid_t *groups = *groupsp;
-
- getgrent_fct = __nss_lookup_function (nip, "getgrent_r");
- if (getgrent_fct == NULL)
- return NSS_STATUS_UNAVAIL;
-
- setgrent_fct = __nss_lookup_function (nip, "setgrent");
- if (setgrent_fct)
- {
- status = DL_CALL_FCT (setgrent_fct, ());
- if (status != NSS_STATUS_SUCCESS)
- return status;
- }
- endgrent_fct = __nss_lookup_function (nip, "endgrent");
+#include "compat-initgroups.c"
- tmpbuf = __alloca (buflen);
-
- do
- {
- while ((status = DL_CALL_FCT (getgrent_fct,
- (&grpbuf, tmpbuf, buflen, errnop)),
- status == NSS_STATUS_TRYAGAIN)
- && *errnop == ERANGE)
- {
- buflen *= 2;
- tmpbuf = __alloca (buflen);
- }
-
- if (status != NSS_STATUS_SUCCESS)
- goto done;
-
- if (grpbuf.gr_gid != group)
- {
- char **m;
-
- for (m = grpbuf.gr_mem; *m != NULL; ++m)
- if (strcmp (*m, user) == 0)
- {
- /* Matches user. Insert this group. */
- if (__builtin_expect (*start == *size, 0))
- {
- /* Need a bigger buffer. */
- gid_t *newgroups;
- long int newsize;
-
- if (limit > 0 && *size == limit)
- /* We reached the maximum. */
- goto done;
-
- if (limit <= 0)
- newsize = 2 * *size;
- else
- newsize = MIN (limit, 2 * *size);
-
- newgroups = realloc (groups, newsize * sizeof (*groups));
- if (newgroups == NULL)
- goto done;
- *groupsp = groups = newgroups;
- *size = newsize;
- }
-
- groups[*start] = grpbuf.gr_gid;
- *start += 1;
-
- break;
- }
- }
- }
- while (status == NSS_STATUS_SUCCESS);
-
- done:
- if (endgrent_fct)
- DL_CALL_FCT (endgrent_fct, ());
-
- return NSS_STATUS_SUCCESS;
-}
static int
internal_getgrouplist (const char *user, gid_t group, long int *size,
gid_t **groupsp, long int limit)
{
+#ifdef USE_NSCD
+ if (__nss_not_use_nscd_group > 0
+ && ++__nss_not_use_nscd_group > NSS_NSCD_RETRY)
+ __nss_not_use_nscd_group = 0;
+ if (!__nss_not_use_nscd_group)
+ {
+ int n = __nscd_getgrouplist (user, group, size, groupsp, limit);
+ if (n >= 0)
+ return n;
+
+ /* nscd is not usable. */
+ __nss_not_use_nscd_group = 1;
+ }
+#endif
+
service_user *nip = NULL;
initgroups_dyn_function fct;
enum nss_status status = NSS_STATUS_UNAVAIL;
@@ -205,6 +130,10 @@ getgrouplist (const char *user, gid_t group, gid_t *groups, int *ngroups)
newgroups = (gid_t *) malloc (size * sizeof (gid_t));
if (__builtin_expect (newgroups == NULL, 0))
/* No more memory. */
+ // XXX This is wrong. The user provided memory, we have to use
+ // XXX it. The internal functions must be called with the user
+ // XXX provided buffer and not try to increase the size if it is
+ // XXX too small. For initgroups a flag could say: increase size.
return -1;
result = internal_getgrouplist (user, group, &size, &newgroups, -1);
diff --git a/nscd/Makefile b/nscd/Makefile
index 8ae0e3f939..d597cf77cb 100644
--- a/nscd/Makefile
+++ b/nscd/Makefile
@@ -21,7 +21,7 @@
#
subdir := nscd
-routines := nscd_getpw_r nscd_getgr_r nscd_gethst_r nscd_getai
+routines := nscd_getpw_r nscd_getgr_r nscd_gethst_r nscd_getai nscd_initgroups
aux := nscd_helper
include ../Makeconfig
@@ -32,7 +32,7 @@ vpath %.c ../locale/programs
nscd-modules := nscd connections pwdcache getpwnam_r getpwuid_r grpcache \
getgrnam_r getgrgid_r hstcache gethstbyad_r gethstbynm2_r \
dbg_log nscd_conf nscd_stat cache mem nscd_setup_thread \
- xmalloc xstrdup aicache
+ xmalloc xstrdup aicache initgrcache
ifeq ($(have-thread-library),yes)
@@ -66,6 +66,8 @@ include ../Rules
CFLAGS-nscd_getpw_r.c = -fexceptions
CFLAGS-nscd_getgr_r.c = -fexceptions
CFLAGS-nscd_gethst_r.c = -fexceptions
+CFLAGS-nscd_getai.c = -fexceptions
+CFLAGS-nscd_initgroups.c = -fexceptions
nscd-cflags = -DIS_IN_nscd=1
ifeq (yesyes,$(have-fpie)$(build-shared))
@@ -93,6 +95,7 @@ CFLAGS-mem.c = $(nscd-cflags)
CFLAGS-nscd_setup_thread.c = $(nscd-cflags)
CFLAGS-aicache.c = $(nscd-cflags)
CFLAGS-selinux.c = $(nscd-cflags)
+CFLAGS-initgrcache.c = $(nscd-cflags)
ifeq (yesyes,$(have-fpie)$(build-shared))
$(objpfx)nscd: $(addprefix $(objpfx),$(nscd-modules:=.o))
diff --git a/nscd/cache.c b/nscd/cache.c
index 468b8d272a..efac4b3bcc 100644
--- a/nscd/cache.c
+++ b/nscd/cache.c
@@ -317,6 +317,10 @@ prune_cache (struct database_dyn *table, time_t now)
readdhstai (table, runp, dh);
break;
+ case INITGROUPS:
+ readdinitgroups (table, runp, dh);
+ break;
+
default:
assert (! "should never happen");
}
diff --git a/nscd/connections.c b/nscd/connections.c
index fe65b661d7..53795bb3b9 100644
--- a/nscd/connections.c
+++ b/nscd/connections.c
@@ -85,7 +85,8 @@ const char *serv2str[LASTREQ] =
[GETFDPW] = "GETFDPW",
[GETFDGR] = "GETFDGR",
[GETFDHST] = "GETFDHST",
- [GETAI] = "GETAI"
+ [GETAI] = "GETAI",
+ [INITGROUPS] = "INITGROUPS"
};
/* The control data structures for the services. */
@@ -154,6 +155,7 @@ static struct database_dyn *const serv2db[LASTREQ] =
[GETFDGR] = &dbs[grpdb],
[GETFDHST] = &dbs[hstdb],
[GETAI] = &dbs[hstdb],
+ [INITGROUPS] = &dbs[grpdb]
};
@@ -604,9 +606,11 @@ cannot handle old request version %d; current version is %d"),
struct database_dyn *db = serv2db[req->type];
+ // XXX Clean up so that each new command need not introduce a
+ // XXX new conditional.
if ((__builtin_expect (req->type, GETPWBYNAME) >= GETPWBYNAME
&& __builtin_expect (req->type, LASTDBREQ) <= LASTDBREQ)
- || req->type == GETAI)
+ || req->type == GETAI || req->type == INITGROUPS)
{
if (__builtin_expect (debug_level, 0) > 0)
{
@@ -719,6 +723,10 @@ cannot handle old request version %d; current version is %d"),
addhstai (db, fd, req, key, uid);
break;
+ case INITGROUPS:
+ addinitgroups (db, fd, req, key, uid);
+ break;
+
case GETSTAT:
case SHUTDOWN:
case INVALIDATE:
diff --git a/nscd/initgrcache.c b/nscd/initgrcache.c
new file mode 100644
index 0000000000..124b4bae62
--- /dev/null
+++ b/nscd/initgrcache.c
@@ -0,0 +1,391 @@
+/* Cache handling for host lookup.
+ Copyright (C) 2004 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include <assert.h>
+#include <errno.h>
+#include <grp.h>
+#include <libintl.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <dbg_log.h>
+#include <nscd.h>
+
+#include "../nss/nsswitch.h"
+
+
+/* Type of the lookup function. */
+typedef enum nss_status (*initgroups_dyn_function) (const char *, gid_t,
+ long int *, long int *,
+ gid_t **, long int, int *);
+
+
+static const initgr_response_header notfound =
+{
+ .version = NSCD_VERSION,
+ .found = 0,
+ .ngrps = 0
+};
+
+
+#include "../grp/compat-initgroups.c"
+
+
+static void
+addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
+ void *key, uid_t uid, struct hashentry *he,
+ struct datahead *dh)
+{
+ /* Search for the entry matching the key. Please note that we don't
+ look again in the table whether the dataset is now available. We
+ simply insert it. It does not matter if it is in there twice. The
+ pruning function only will look at the timestamp. */
+
+
+ /* We allocate all data in one memory block: the iov vector,
+ the response header and the dataset itself. */
+ struct dataset
+ {
+ struct datahead head;
+ initgr_response_header resp;
+ char strdata[0];
+ } *dataset = NULL;
+
+ if (__builtin_expect (debug_level > 0, 0))
+ {
+ if (he == NULL)
+ dbg_log (_("Haven't found \"%s\" in group cache!"), (char *) key);
+ else
+ dbg_log (_("Reloading \"%s\" in group cache!"), (char *) key);
+ }
+
+ static service_user *group_database;
+ service_user *nip = NULL;
+ int no_more;
+
+ if (group_database != NULL)
+ {
+ nip = group_database;
+ no_more = 0;
+ }
+ else
+ no_more = __nss_database_lookup ("group", NULL,
+ "compat [NOTFOUND=return] files", &nip);
+
+ /* We always use sysconf even if NGROUPS_MAX is defined. That way, the
+ limit can be raised in the kernel configuration without having to
+ recompile libc. */
+ long int limit = __sysconf (_SC_NGROUPS_MAX);
+
+ long int size;
+ if (limit > 0)
+ /* We limit the size of the intially allocated array. */
+ size = MIN (limit, 64);
+ else
+ /* No fixed limit on groups. Pick a starting buffer size. */
+ size = 16;
+
+ long int start = 0;
+ bool all_tryagain = true;
+
+ /* This is temporary memory, we need not (ad must not) call
+ mempool_alloc. */
+ // XXX This really should use alloca. need to change the backends.
+ gid_t *groups = (gid_t *) malloc (size * sizeof (gid_t));
+ if (__builtin_expect (groups == NULL, 0))
+ /* No more memory. */
+ goto out;
+
+ /* Nothing added yet. */
+ while (! no_more)
+ {
+ enum nss_status status;
+ initgroups_dyn_function fct;
+ fct = __nss_lookup_function (nip, "initgroups_dyn");
+
+ if (fct == NULL)
+ {
+ status = compat_call (nip, key, -1, &start, &size, &groups,
+ limit, &errno);
+
+ if (nss_next_action (nip, NSS_STATUS_UNAVAIL) != NSS_ACTION_CONTINUE)
+ break;
+ }
+ else
+ status = DL_CALL_FCT (fct, (key, -1, &start, &size, &groups,
+ limit, &errno));
+
+ if (status != NSS_STATUS_TRYAGAIN)
+ all_tryagain = false;
+
+ /* This is really only for debugging. */
+ if (NSS_STATUS_TRYAGAIN > status || status > NSS_STATUS_RETURN)
+ __libc_fatal ("illegal status in internal_getgrouplist");
+
+ if (status != NSS_STATUS_SUCCESS
+ && nss_next_action (nip, status) == NSS_ACTION_RETURN)
+ break;
+
+ if (nip->next == NULL)
+ no_more = -1;
+ else
+ nip = nip->next;
+ }
+
+ ssize_t total;
+ ssize_t written;
+ out:
+ if (start == 0)
+ {
+ /* Nothing found. Create a negative result record. */
+ written = total = sizeof (notfound);
+
+ if (he != NULL && all_tryagain)
+ {
+ /* If we have an old record available but cannot find one now
+ because the service is not available we keep the old record
+ and make sure it does not get removed. */
+ if (reload_count != UINT_MAX && dh->nreloads == reload_count)
+ /* Do not reset the value if we never not reload the record. */
+ dh->nreloads = reload_count - 1;
+ }
+ else
+ {
+ /* We have no data. This means we send the standard reply for this
+ case. */
+ if (fd != -1)
+ written = TEMP_FAILURE_RETRY (write (fd, &notfound, total));
+
+ dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
+ /* If we cannot permanently store the result, so be it. */
+ if (dataset != NULL)
+ {
+ dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
+ dataset->head.recsize = total;
+ dataset->head.notfound = true;
+ dataset->head.nreloads = 0;
+ dataset->head.usable = true;
+
+ /* Compute the timeout time. */
+ dataset->head.timeout = time (NULL) + db->negtimeout;
+
+ /* This is the reply. */
+ memcpy (&dataset->resp, &notfound, total);
+
+ /* Copy the key data. */
+ char *key_copy = memcpy (dataset->strdata, key, req->key_len);
+
+ /* If necessary, we also propagate the data to disk. */
+ if (db->persistent)
+ {
+ // XXX async OK?
+ uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
+ msync ((void *) pval,
+ ((uintptr_t) dataset & pagesize_m1)
+ + sizeof (struct dataset) + req->key_len, MS_ASYNC);
+ }
+
+ /* Now get the lock to safely insert the records. */
+ pthread_rwlock_rdlock (&db->lock);
+
+ if (cache_add (req->type, key_copy, req->key_len,
+ &dataset->head, true, db, uid) < 0)
+ /* Ensure the data can be recovered. */
+ dataset->head.usable = false;
+
+ pthread_rwlock_unlock (&db->lock);
+
+ /* Mark the old entry as obsolete. */
+ if (dh != NULL)
+ dh->usable = false;
+ }
+ else
+ ++db->head->addfailed;
+ }
+ }
+ else
+ {
+
+ written = total = sizeof (struct dataset) + start * sizeof (int32_t);
+
+ /* If we refill the cache, first assume the reconrd did not
+ change. Allocate memory on the cache since it is likely
+ discarded anyway. If it turns out to be necessary to have a
+ new record we can still allocate real memory. */
+ bool alloca_used = false;
+ dataset = NULL;
+
+ if (he == NULL)
+ {
+ dataset = (struct dataset *) mempool_alloc (db,
+ total + req->key_len);
+ if (dataset == NULL)
+ ++db->head->addfailed;
+ }
+
+ if (dataset == NULL)
+ {
+ /* We cannot permanently add the result in the moment. But
+ we can provide the result as is. Store the data in some
+ temporary memory. */
+ dataset = (struct dataset *) alloca (total + req->key_len);
+
+ /* We cannot add this record to the permanent database. */
+ alloca_used = true;
+ }
+
+ dataset->head.allocsize = total + req->key_len;
+ dataset->head.recsize = total - offsetof (struct dataset, resp);
+ dataset->head.notfound = false;
+ dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
+ dataset->head.usable = true;
+
+ /* Compute the timeout time. */
+ dataset->head.timeout = time (NULL) + db->postimeout;
+
+ dataset->resp.version = NSCD_VERSION;
+ dataset->resp.found = 1;
+ dataset->resp.ngrps = start;
+
+ char *cp = dataset->strdata;
+
+ /* Copy the GID values. If the size of the types match this is
+ very simple. */
+ if (sizeof (gid_t) == sizeof (int32_t))
+ cp = mempcpy (cp, groups, start * sizeof (gid_t));
+ else
+ {
+ gid_t *gcp = (gid_t *) cp;
+
+ for (int i = 0; i < start; ++i)
+ *gcp++ = groups[i];
+
+ cp = (char *) gcp;
+ }
+
+ /* Finally the user name. */
+ memcpy (cp, key, req->key_len);
+
+ /* Now we can determine whether on refill we have to create a new
+ record or not. */
+ if (he != NULL)
+ {
+ assert (fd == -1);
+
+ if (total + req->key_len == dh->allocsize
+ && total - offsetof (struct dataset, resp) == dh->recsize
+ && memcmp (&dataset->resp, dh->data,
+ dh->allocsize - offsetof (struct dataset, resp)) == 0)
+ {
+ /* The data has not changed. We will just bump the
+ timeout value. Note that the new record has been
+ allocated on the stack and need not be freed. */
+ dh->timeout = dataset->head.timeout;
+ ++dh->nreloads;
+ }
+ else
+ {
+ /* We have to create a new record. Just allocate
+ appropriate memory and copy it. */
+ struct dataset *newp
+ = (struct dataset *) mempool_alloc (db, total + req->key_len);
+ if (newp != NULL)
+ {
+ /* Adjust pointer into the memory block. */
+ cp = (char *) newp + (cp - (char *) dataset);
+
+ dataset = memcpy (newp, dataset, total + req->key_len);
+ alloca_used = false;
+ }
+
+ /* Mark the old record as obsolete. */
+ dh->usable = false;
+ }
+ }
+ else
+ {
+ /* We write the dataset before inserting it to the database
+ since while inserting this thread might block and so would
+ unnecessarily let the receiver wait. */
+ assert (fd != -1);
+
+ written = TEMP_FAILURE_RETRY (write (fd, &dataset->resp, total));
+ }
+
+
+ /* Add the record to the database. But only if it has not been
+ stored on the stack. */
+ if (! alloca_used)
+ {
+ /* If necessary, we also propagate the data to disk. */
+ if (db->persistent)
+ {
+ // XXX async OK?
+ uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
+ msync ((void *) pval,
+ ((uintptr_t) dataset & pagesize_m1) + total +
+ req->key_len, MS_ASYNC);
+ }
+
+ /* Now get the lock to safely insert the records. */
+ pthread_rwlock_rdlock (&db->lock);
+
+ if (cache_add (INITGROUPS, cp, req->key_len, &dataset->head, true,
+ db, uid) < 0)
+ /* Could not allocate memory. Make sure the data gets
+ discarded. */
+ dataset->head.usable = false;
+
+ pthread_rwlock_unlock (&db->lock);
+ }
+ }
+
+ free (groups);
+
+ if (__builtin_expect (written != total, 0) && debug_level > 0)
+ {
+ char buf[256];
+ dbg_log (_("short write in %s: %s"), __FUNCTION__,
+ strerror_r (errno, buf, sizeof (buf)));
+ }
+}
+
+
+void
+addinitgroups (struct database_dyn *db, int fd, request_header *req, void *key,
+ uid_t uid)
+{
+ addinitgroupsX (db, fd, req, key, uid, NULL, NULL);
+}
+
+
+void
+readdinitgroups (struct database_dyn *db, struct hashentry *he,
+ struct datahead *dh)
+{
+ request_header req =
+ {
+ .type = INITGROUPS,
+ .key_len = he->len
+ };
+
+ addinitgroupsX (db, -1, &req, db->data + he->key, he->owner, he, dh);
+}
diff --git a/nscd/nscd-client.h b/nscd/nscd-client.h
index 4451349278..2e7f27b8d5 100644
--- a/nscd/nscd-client.h
+++ b/nscd/nscd-client.h
@@ -62,6 +62,7 @@ typedef enum
GETFDGR,
GETFDHST,
GETAI,
+ INITGROUPS,
LASTREQ
} request_type;
@@ -140,6 +141,15 @@ struct nscd_ai_result
char *addrs;
};
+/* Structure sent in reply to initgroups query. Note that this struct is
+ sent also if the service is disabled or there is no record found. */
+typedef struct
+{
+ int32_t version;
+ int32_t found;
+ nscd_ssize_t ngrps;
+} initgr_response_header;
+
/* Type for offsets in data part of database. */
typedef uint32_t ref_t;
@@ -173,6 +183,7 @@ struct datahead
gr_response_header grdata;
hst_response_header hstdata;
ai_response_header aidata;
+ initgr_response_header initgrdata;
nscd_ssize_t align1;
nscd_time_t align2;
} data[0];
@@ -244,7 +255,7 @@ struct mapped_database
const struct database_pers_head *head;
const char *data;
size_t mapsize;
- int counter; /* > 0 indicates it isusable. */
+ int counter; /* > 0 indicates it is usable. */
};
#define NO_MAPPING ((struct mapped_database *) -1l)
@@ -265,20 +276,24 @@ extern int __nscd_open_socket (const char *key, size_t keylen,
extern struct mapped_database *__nscd_get_map_ref (request_type type,
const char *name,
struct locked_map_ptr *mapptr,
- volatile int *gc_cyclep);
+ int *gc_cyclep);
/* Unmap database. */
extern void __nscd_unmap (struct mapped_database *mapped);
/* Drop reference of mapping. */
static inline int __nscd_drop_map_ref (struct mapped_database *map,
- int gc_cycle)
+ int *gc_cycle)
{
if (map != NO_MAPPING)
{
- if (__builtin_expect (map->head->gc_cycle != gc_cycle, 0))
- /* We might have read inconsistent data. */
- return -1;
+ int now_cycle = map->head->gc_cycle;
+ if (__builtin_expect (now_cycle != *gc_cycle, 0))
+ {
+ /* We might have read inconsistent data. */
+ *gc_cycle = now_cycle;
+ return -1;
+ }
if (atomic_decrement_val (&map->counter) == 0)
__nscd_unmap (map);
diff --git a/nscd/nscd.c b/nscd/nscd.c
index 7f8f58fde6..2a4cb2291d 100644
--- a/nscd/nscd.c
+++ b/nscd/nscd.c
@@ -438,9 +438,14 @@ termination_handler (int signum)
/* Synchronize memory. */
for (int cnt = 0; cnt < lastdb; ++cnt)
- if (dbs[cnt].persistent)
- // XXX async OK?
- msync (dbs[cnt].head, dbs[cnt].memsize, MS_ASYNC);
+ {
+ /* Make sure nobody keeps using the database. */
+ dbs[cnt].head->timestamp = 0;
+
+ if (dbs[cnt].persistent)
+ // XXX async OK?
+ msync (dbs[cnt].head, dbs[cnt].memsize, MS_ASYNC);
+ }
/* Shutdown the SELinux AVC. */
if (selinux_enabled)
@@ -496,6 +501,8 @@ write_pid (const char *file)
into nscd. There currently is no special getaddrinfo version for
use in nscd. In case it should be necessary such a version must be
created and this dummy version should be removed. */
+extern void getaddrinfo (void) __attribute ((visibility ("hidden")));
+
void
getaddrinfo (void)
{
diff --git a/nscd/nscd.h b/nscd/nscd.h
index 01c8ca11e0..3a9660d3ec 100644
--- a/nscd/nscd.h
+++ b/nscd/nscd.h
@@ -199,6 +199,13 @@ extern void addhstai (struct database_dyn *db, int fd, request_header *req,
extern void readdhstai (struct database_dyn *db, struct hashentry *he,
struct datahead *dh);
+
+/* initgrcache.c */
+extern void addinitgroups (struct database_dyn *db, int fd,
+ request_header *req, void *key, uid_t uid);
+extern void readdinitgroups (struct database_dyn *db, struct hashentry *he,
+ struct datahead *dh);
+
/* mem.c */
extern void *mempool_alloc (struct database_dyn *db, size_t len);
extern void gc (struct database_dyn *db);
diff --git a/nscd/nscd_getai.c b/nscd/nscd_getai.c
index a9eac48ac8..a683976d87 100644
--- a/nscd/nscd_getai.c
+++ b/nscd/nscd_getai.c
@@ -23,7 +23,6 @@
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include <sys/mman.h>
#include <not-cancel.h>
#include "nscd-client.h"
@@ -40,7 +39,6 @@ libc_locked_map_ptr (map_handle);
handling. */
libc_freeres_fn (ai_map_free)
{
-
if (map_handle.mapped != NO_MAPPING)
free (map_handle.mapped);
}
@@ -50,19 +48,21 @@ int
__nscd_getai (const char *key, struct nscd_ai_result **result, int *h_errnop)
{
size_t keylen = strlen (key) + 1;
+ int gc_cycle;
+
+ /* If the mapping is available, try to search there instead of
+ communicating with the nscd. */
+ struct mapped_database *mapped;
+ mapped = __nscd_get_map_ref (GETFDHST, "hosts", &map_handle, &gc_cycle);
+
+ retry:;
const ai_response_header *ai_resp = NULL;
struct nscd_ai_result *resultbuf = NULL;
const char *recend = (const char *) ~UINTMAX_C (0);
char *respdata = NULL;
int retval = -1;
int sock = -1;
- int gc_cycle;
- /* If the mapping is available, try to search there instead of
- communicating with the nscd. */
- struct mapped_database *mapped = __nscd_get_map_ref (GETFDHST, "hosts",
- &map_handle, &gc_cycle);
- retry:
if (mapped != NO_MAPPING)
{
const struct datahead *found = __nscd_cache_search (GETAI, key, keylen,
@@ -131,6 +131,11 @@ __nscd_getai (const char *key, struct nscd_ai_result **result, int *h_errnop)
retval = 0;
*result = resultbuf;
}
+ else
+ {
+ free (resultbuf);
+ *h_errnop = NETDB_INTERNAL;
+ }
}
else
{
@@ -155,11 +160,22 @@ __nscd_getai (const char *key, struct nscd_ai_result **result, int *h_errnop)
if (sock != -1)
close_not_cancel_no_status (sock);
out:
- if (__nscd_drop_map_ref (mapped, gc_cycle) != 0)
- /* When we come here this means there has been a GC cycle while we
- were looking for the data. This means the data might have been
- inconsistent. Retry. */
- goto retry;
+ if (__nscd_drop_map_ref (mapped, &gc_cycle) != 0 && retval != -1)
+ {
+ /* When we come here this means there has been a GC cycle while we
+ were looking for the data. This means the data might have been
+ inconsistent. Retry if possible. */
+ if ((gc_cycle & 1) != 0)
+ {
+ /* nscd is just running gc now. Disable using the mapping. */
+ __nscd_unmap (mapped);
+ mapped = NO_MAPPING;
+ }
+
+ free (resultbuf);
+
+ goto retry;
+ }
return retval;
}
diff --git a/nscd/nscd_getgr_r.c b/nscd/nscd_getgr_r.c
index 3a66bb849b..1b94bf584f 100644
--- a/nscd/nscd_getgr_r.c
+++ b/nscd/nscd_getgr_r.c
@@ -18,6 +18,7 @@
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
+#include <alloca.h>
#include <assert.h>
#include <errno.h>
#include <grp.h>
@@ -72,7 +73,6 @@ libc_locked_map_ptr (map_handle);
handling. */
libc_freeres_fn (gr_map_free)
{
-
if (map_handle.mapped != NO_MAPPING)
free (map_handle.mapped);
}
@@ -84,19 +84,21 @@ nscd_getgr_r (const char *key, size_t keylen, request_type type,
struct group *resultbuf, char *buffer, size_t buflen,
struct group **result)
{
- const gr_response_header *gr_resp = NULL;
- const uint32_t *len = NULL;
- const char *gr_name = NULL;
- size_t gr_name_len = 0;
- int retval = -1;
int gc_cycle;
- const char *recend = (const char *) ~UINTMAX_C (0);
+ const uint32_t *len = NULL;
+ size_t lensize = 0;
/* If the mapping is available, try to search there instead of
communicating with the nscd. */
struct mapped_database *mapped = __nscd_get_map_ref (GETFDGR, "group",
&map_handle, &gc_cycle);
- retry:
+ retry:;
+ const gr_response_header *gr_resp = NULL;
+ const char *gr_name = NULL;
+ size_t gr_name_len = 0;
+ int retval = -1;
+ const char *recend = (const char *) ~UINTMAX_C (0);
+
if (mapped != NO_MAPPING)
{
const struct datahead *found = __nscd_cache_search (type, key, keylen,
@@ -176,10 +178,17 @@ nscd_getgr_r (const char *key, size_t keylen, request_type type,
resultbuf->gr_gid = gr_resp->gr_gid;
/* Read the length information, group name, and password. */
- if (len == NULL)
+ if (gr_name == NULL)
{
/* Allocate array to store lengths. */
- len = (uint32_t *) alloca (gr_resp->gr_mem_cnt * sizeof (uint32_t));
+ if (lensize == 0)
+ {
+ lensize = gr_resp->gr_mem_cnt * sizeof (uint32_t);
+ len = (uint32_t *) alloca (lensize);
+ }
+ else if (gr_resp->gr_mem_cnt * sizeof (uint32_t) > lensize)
+ len = extend_alloca (len, lensize,
+ gr_resp->gr_mem_cnt * sizeof (uint32_t));
vec[0].iov_base = (void *) len;
vec[0].iov_len = gr_resp->gr_mem_cnt * sizeof (uint32_t);
@@ -248,11 +257,20 @@ nscd_getgr_r (const char *key, size_t keylen, request_type type,
if (sock != -1)
close_not_cancel_no_status (sock);
out:
- if (__nscd_drop_map_ref (mapped, gc_cycle) != 0)
- /* When we come here this means there has been a GC cycle while we
- were looking for the data. This means the data might have been
- inconsistent. Retry. */
- goto retry;
+ if (__nscd_drop_map_ref (mapped, &gc_cycle) != 0 && retval != -1)
+ {
+ /* When we come here this means there has been a GC cycle while we
+ were looking for the data. This means the data might have been
+ inconsistent. Retry if possible. */
+ if ((gc_cycle & 1) != 0)
+ {
+ /* nscd is just running gc now. Disable using the mapping. */
+ __nscd_unmap (mapped);
+ mapped = NO_MAPPING;
+ }
+
+ goto retry;
+ }
return retval;
}
diff --git a/nscd/nscd_gethst_r.c b/nscd/nscd_gethst_r.c
index 42327dd317..407be1441f 100644
--- a/nscd/nscd_gethst_r.c
+++ b/nscd/nscd_gethst_r.c
@@ -27,7 +27,6 @@
#include <string.h>
#include <unistd.h>
#include <arpa/nameser.h>
-#include <sys/mman.h>
#include <not-cancel.h>
#include "nscd-client.h"
@@ -94,7 +93,6 @@ libc_locked_map_ptr (map_handle);
handling. */
libc_freeres_fn (gr_map_free)
{
-
if (map_handle.mapped != NO_MAPPING)
free (map_handle.mapped);
}
@@ -106,22 +104,24 @@ nscd_gethst_r (const char *key, size_t keylen, request_type type,
struct hostent *resultbuf, char *buffer, size_t buflen,
struct hostent **result, int *h_errnop)
{
+ int gc_cycle;
+ int nretries = 0;
+
+ /* If the mapping is available, try to search there instead of
+ communicating with the nscd. */
+ struct mapped_database *mapped;
+ mapped = __nscd_get_map_ref (GETFDHST, "hosts", &map_handle, &gc_cycle);
+
+ retry:;
const hst_response_header *hst_resp = NULL;
const char *h_name = NULL;
const uint32_t *aliases_len = NULL;
const char *addr_list = NULL;
size_t addr_list_len = 0;
int retval = -1;
- int gc_cycle;
const char *recend = (const char *) ~UINTMAX_C (0);
int sock = -1;
-
- /* If the mapping is available, try to search there instead of
- communicating with the nscd. */
- struct mapped_database *mapped = __nscd_get_map_ref (GETFDHST, "hosts",
- &map_handle, &gc_cycle);
- retry:
- if (mapped != MAP_FAILED)
+ if (mapped != NO_MAPPING)
{
const struct datahead *found = __nscd_cache_search (type, key, keylen,
mapped);
@@ -355,11 +355,20 @@ nscd_gethst_r (const char *key, size_t keylen, request_type type,
if (sock != -1)
close_not_cancel_no_status (sock);
out:
- if (__nscd_drop_map_ref (mapped, gc_cycle) != 0)
- /* When we come here this means there has been a GC cycle while we
- were looking for the data. This means the data might have been
- inconsistent. Retry. */
- goto retry;
+ if (__nscd_drop_map_ref (mapped, &gc_cycle) != 0 && retval != -1)
+ {
+ /* When we come here this means there has been a GC cycle while we
+ were looking for the data. This means the data might have been
+ inconsistent. Retry if possible. */
+ if ((gc_cycle & 1) != 0 || ++nretries == 5)
+ {
+ /* nscd is just running gc now. Disable using the mapping. */
+ __nscd_unmap (mapped);
+ mapped = NO_MAPPING;
+ }
+
+ goto retry;
+ }
return retval;
}
diff --git a/nscd/nscd_getpw_r.c b/nscd/nscd_getpw_r.c
index 0d15a0cc3f..b04dcfaa99 100644
--- a/nscd/nscd_getpw_r.c
+++ b/nscd/nscd_getpw_r.c
@@ -72,7 +72,6 @@ libc_locked_map_ptr (map_handle);
handling. */
libc_freeres_fn (gr_map_free)
{
-
if (map_handle.mapped != NO_MAPPING)
free (map_handle.mapped);
}
@@ -84,17 +83,18 @@ nscd_getpw_r (const char *key, size_t keylen, request_type type,
struct passwd *resultbuf, char *buffer, size_t buflen,
struct passwd **result)
{
+ int gc_cycle;
+ /* If the mapping is available, try to search there instead of
+ communicating with the nscd. */
+ struct mapped_database *mapped;
+ mapped = __nscd_get_map_ref (GETFDPW, "passwd", &map_handle, &gc_cycle);
+
+ retry:;
const pw_response_header *pw_resp = NULL;
const char *pw_name = NULL;
int retval = -1;
- int gc_cycle;
const char *recend = (const char *) ~UINTMAX_C (0);
- /* If the mapping is available, try to search there instead of
- communicating with the nscd. */
- struct mapped_database *mapped = __nscd_get_map_ref (GETFDPW, "passwd",
- &map_handle, &gc_cycle);
- retry:
if (mapped != NO_MAPPING)
{
const struct datahead *found = __nscd_cache_search (type, key, keylen,
@@ -199,11 +199,22 @@ nscd_getpw_r (const char *key, size_t keylen, request_type type,
if (sock != -1)
close_not_cancel_no_status (sock);
out:
- if (__nscd_drop_map_ref (mapped, gc_cycle) != 0)
- /* When we come here this means there has been a GC cycle while we
- were looking for the data. This means the data might have been
- inconsistent. Retry. */
- goto retry;
+ if (__nscd_drop_map_ref (mapped, &gc_cycle) != 0 && retval != -1)
+ {
+ /* When we come here this means there has been a GC cycle while we
+ were looking for the data. This means the data might have been
+ inconsistent. Retry if possible. */
+ if ((gc_cycle & 1) != 0)
+ {
+ /* nscd is just running gc now. Disable using the mapping. */
+ __nscd_unmap (mapped);
+ mapped = NO_MAPPING;
+ }
+
+ free (resultbuf);
+
+ goto retry;
+ }
return retval;
}
diff --git a/nscd/nscd_helper.c b/nscd/nscd_helper.c
index ae8dd6c91f..3c8693a93d 100644
--- a/nscd/nscd_helper.c
+++ b/nscd/nscd_helper.c
@@ -214,7 +214,7 @@ get_mapping (request_type type, const char *key,
struct mapped_database *
__nscd_get_map_ref (request_type type, const char *name,
- struct locked_map_ptr *mapptr, volatile int *gc_cyclep)
+ struct locked_map_ptr *mapptr, int *gc_cyclep)
{
struct mapped_database *cur = mapptr->mapped;
if (cur == NO_MAPPING)
diff --git a/nscd/nscd_initgroups.c b/nscd/nscd_initgroups.c
new file mode 100644
index 0000000000..ea32ab6bcc
--- /dev/null
+++ b/nscd/nscd_initgroups.c
@@ -0,0 +1,168 @@
+/* Copyright (C) 2004 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include <assert.h>
+#include <errno.h>
+#include <grp.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <not-cancel.h>
+
+#include "nscd-client.h"
+#include "nscd_proto.h"
+
+
+libc_locked_map_ptr (map_handle);
+/* Note that we only free the structure if necessary. The memory
+ mapping is not removed since it is not visible to the malloc
+ handling. */
+libc_freeres_fn (gr_map_free)
+{
+ if (map_handle.mapped != NO_MAPPING)
+ free (map_handle.mapped);
+}
+
+
+int
+__nscd_getgrouplist (const char *user, gid_t group, long int *size,
+ gid_t **groupsp, long int limit)
+{
+ size_t userlen = strlen (user) + 1;
+ int gc_cycle;
+
+ /* If the mapping is available, try to search there instead of
+ communicating with the nscd. */
+ struct mapped_database *mapped;
+ mapped = __nscd_get_map_ref (GETFDGR, "group", &map_handle, &gc_cycle);
+
+ retry:;
+ const initgr_response_header *initgr_resp = NULL;
+ char *respdata = NULL;
+ int retval = -1;
+ int sock = -1;
+
+ if (mapped != NO_MAPPING)
+ {
+ const struct datahead *found = __nscd_cache_search (INITGROUPS, user,
+ userlen, mapped);
+ if (found != NULL)
+ {
+ initgr_resp = &found->data[0].initgrdata;
+ respdata = (char *) (initgr_resp + 1);
+ char *recend = (char *) found->data + found->recsize;
+
+ if (respdata + initgr_resp->ngrps * sizeof (int32_t) > recend)
+ goto out;
+ }
+ }
+
+ /* If we do not have the cache mapped, try to get the data over the
+ socket. */
+ initgr_response_header initgr_resp_mem;
+ if (initgr_resp == NULL)
+ {
+ sock = __nscd_open_socket (user, userlen, INITGROUPS, &initgr_resp_mem,
+ sizeof (initgr_resp_mem));
+ if (sock == -1)
+ /* nscd not running or wrong version or hosts caching disabled. */
+ __nss_not_use_nscd_group = 1;
+
+ initgr_resp = &initgr_resp_mem;
+ }
+
+ if (initgr_resp->found == 1)
+ {
+ /* The following code assumes that gid_t and int32_t are the
+ same size. This is the case for al existing implementation.
+ If this should change some code needs to be added which
+ doesn't use memcpy but instead copies each array element one
+ by one. */
+ assert (sizeof (int32_t) == sizeof (gid_t));
+
+ /* Make sure we have enough room. We always count GROUP in even
+ though we might not end up adding it. */
+ if (*size < initgr_resp->ngrps + 1)
+ {
+ gid_t *newp = realloc (*groupsp,
+ (initgr_resp->ngrps + 1) * sizeof (gid_t));
+ if (newp == NULL)
+ /* We cannot increase the buffer size. */
+ goto out;
+
+ *groupsp = newp;
+ *size = initgr_resp->ngrps + 1;
+ }
+
+ if (respdata == NULL)
+ {
+ /* Read the data from the socket. */
+ if ((size_t) TEMP_FAILURE_RETRY (__read (sock, *groupsp,
+ initgr_resp->ngrps
+ * sizeof (gid_t)))
+ == initgr_resp->ngrps * sizeof (gid_t))
+ retval = initgr_resp->ngrps;
+ }
+ else
+ {
+ /* Just copy the data. */
+ retval = initgr_resp->ngrps;
+ memcpy (*groupsp, respdata, retval * sizeof (gid_t));
+ }
+
+ /* Check whether GROUP is part of the mix. If not, add it. */
+ if (retval >= 0)
+ {
+ int cnt;
+ for (cnt = 0; cnt < retval; ++cnt)
+ if ((*groupsp)[cnt] == group)
+ break;
+
+ if (cnt == retval)
+ (*groupsp)[retval++] = group;
+ }
+ }
+ else
+ {
+ /* The `errno' to some value != ERANGE. */
+ __set_errno (ENOENT);
+ /* Even though we have not found anything, the result is zero. */
+ retval = 0;
+ }
+
+ if (sock != -1)
+ close_not_cancel_no_status (sock);
+ out:
+ if (__nscd_drop_map_ref (mapped, &gc_cycle) != 0 && retval != -1)
+ {
+ /* When we come here this means there has been a GC cycle while we
+ were looking for the data. This means the data might have been
+ inconsistent. Retry if possible. */
+ if ((gc_cycle & 1) != 0)
+ {
+ /* nscd is just running gc now. Disable using the mapping. */
+ __nscd_unmap (mapped);
+ mapped = NO_MAPPING;
+ }
+
+ goto retry;
+ }
+
+ return retval;
+}
diff --git a/nscd/nscd_proto.h b/nscd/nscd_proto.h
index eb685a5eb0..64d9bd0043 100644
--- a/nscd/nscd_proto.h
+++ b/nscd/nscd_proto.h
@@ -45,7 +45,7 @@ extern int __nscd_getpwuid_r (uid_t uid, struct passwd *resultbuf,
extern int __nscd_getgrnam_r (const char *name, struct group *resultbuf,
char *buffer, size_t buflen,
struct group **result);
-extern int __nscd_getgrgid_r (uid_t uid, struct group *resultbuf,
+extern int __nscd_getgrgid_r (gid_t gid, struct group *resultbuf,
char *buffer, size_t buflen,
struct group **result);
extern int __nscd_gethostbyname_r (const char *name,
@@ -62,5 +62,6 @@ extern int __nscd_gethostbyaddr_r (const void *addr, socklen_t len, int type,
struct hostent **result, int *h_errnop);
extern int __nscd_getai (const char *key, struct nscd_ai_result **result,
int *h_errnop);
-
+extern int __nscd_getgrouplist (const char *user, gid_t group, long int *size,
+ gid_t **groupsp, long int limit);
#endif /* _NSCD_PROTO_H */
diff --git a/nscd/selinux.c b/nscd/selinux.c
index 0f975f71f6..77651e05c3 100644
--- a/nscd/selinux.c
+++ b/nscd/selinux.c
@@ -56,7 +56,8 @@ static const int perms[LASTREQ] =
[GETFDPW] = NSCD__SHMEMPWD,
[GETFDGR] = NSCD__SHMEMGRP,
[GETFDHST] = NSCD__SHMEMHOST,
- [GETAI] = NSCD__GETHOST
+ [GETAI] = NSCD__GETHOST,
+ [INITGROUPS] = NSCD__GETGRP
};
/* Store an entry ref to speed AVC decisions. */
diff --git a/posix/tst-gnuglob.c b/posix/tst-gnuglob.c
index b15dad12ef..72f3fa4a3e 100644
--- a/posix/tst-gnuglob.c
+++ b/posix/tst-gnuglob.c
@@ -30,7 +30,7 @@
#include <sys/stat.h>
-/* #define DEBUG */
+// #define DEBUG
#ifdef DEBUG
# define PRINTF(fmt, args...) printf (fmt, ##args)
#else
@@ -106,6 +106,9 @@ find_file (const char *s)
if (strcmp (s, ".") == 0)
return 0;
+ if (s[0] == '.' && s[1] == '/')
+ s += 2;
+
while (*s != '\0')
{
char *endp = strchrnul (s, '/');
@@ -126,6 +129,10 @@ find_file (const char *s)
errno = ENOENT;
return -1;
}
+
+ if (*endp == '\0')
+ return idx + 1;
+
if (filesystem[idx].type != DT_DIR
&& (idx + 1 >= nfiles
|| filesystem[idx].level >= filesystem[idx + 1].level))
@@ -136,9 +143,6 @@ find_file (const char *s)
++idx;
- if (*endp == '\0')
- return idx;
-
s = endp + 1;
++level;
}
diff --git a/sunrpc/clnt_udp.c b/sunrpc/clnt_udp.c
index 1836ff3433..f3787dd1a5 100644
--- a/sunrpc/clnt_udp.c
+++ b/sunrpc/clnt_udp.c
@@ -244,6 +244,7 @@ is_network_up (int sock)
while (run != NULL)
{
if ((run->ifa_flags & IFF_UP) != 0
+ && run->ifa_addr != NULL
&& run->ifa_addr->sa_family == AF_INET)
break;
diff --git a/sunrpc/get_myaddr.c b/sunrpc/get_myaddr.c
index c0beee9c59..4449c53c06 100644
--- a/sunrpc/get_myaddr.c
+++ b/sunrpc/get_myaddr.c
@@ -76,7 +76,9 @@ get_myaddress (struct sockaddr_in *addr)
run = ifa;
while (run != NULL)
{
- if ((run->ifa_flags & IFF_UP) && run->ifa_addr->sa_family == AF_INET
+ if ((run->ifa_flags & IFF_UP)
+ && run->ifa_addr != NULL
+ && run->ifa_addr->sa_family == AF_INET
&& (!(run->ifa_flags & IFF_LOOPBACK)
|| (loopback == 1 && (run->ifa_flags & IFF_LOOPBACK))))
{
diff --git a/sunrpc/pmap_clnt.c b/sunrpc/pmap_clnt.c
index aa5740c8a0..3e42960893 100644
--- a/sunrpc/pmap_clnt.c
+++ b/sunrpc/pmap_clnt.c
@@ -70,7 +70,9 @@ __get_myaddress (struct sockaddr_in *addr)
run = ifa;
while (run != NULL)
{
- if ((run->ifa_flags & IFF_UP) && run->ifa_addr->sa_family == AF_INET
+ if ((run->ifa_flags & IFF_UP)
+ && run->ifa_addr != NULL
+ && run->ifa_addr->sa_family == AF_INET
&& ((run->ifa_flags & IFF_LOOPBACK) || loopback == 0))
{
*addr = *((struct sockaddr_in *) run->ifa_addr);
diff --git a/sunrpc/pmap_rmt.c b/sunrpc/pmap_rmt.c
index 4ff707ad15..644d503a1f 100644
--- a/sunrpc/pmap_rmt.c
+++ b/sunrpc/pmap_rmt.c
@@ -191,6 +191,7 @@ getbroadcastnets (struct in_addr *addrs, int naddrs)
{
if ((run->ifa_flags & IFF_BROADCAST) != 0
&& (run->ifa_flags & IFF_UP) != 0
+ && run->ifa_addr != NULL
&& run->ifa_addr->sa_family == AF_INET)
/* Copy the broadcast address. */
addrs[i++] = ((struct sockaddr_in *) run->ifa_broadaddr)->sin_addr;
diff --git a/sysdeps/alpha/fpu/bits/mathinline.h b/sysdeps/alpha/fpu/bits/mathinline.h
index d3a76bad2b..187bd42f33 100644
--- a/sysdeps/alpha/fpu/bits/mathinline.h
+++ b/sysdeps/alpha/fpu/bits/mathinline.h
@@ -149,25 +149,25 @@ __MATH_INLINE double __NTH (floor (double __x)) { return __floor(__x); }
__MATH_INLINE float
__NTH (__fdimf (float __x, float __y))
{
- return __x < __y ? 0.0f : __x - __y;
+ return __x <= __y ? 0.0f : __x - __y;
}
__MATH_INLINE float
__NTH (fdimf (float __x, float __y))
{
- return __x < __y ? 0.0f : __x - __y;
+ return __x <= __y ? 0.0f : __x - __y;
}
__MATH_INLINE double
__NTH (__fdim (double __x, double __y))
{
- return __x < __y ? 0.0 : __x - __y;
+ return __x <= __y ? 0.0 : __x - __y;
}
__MATH_INLINE double
__NTH (fdim (double __x, double __y))
{
- return __x < __y ? 0.0 : __x - __y;
+ return __x <= __y ? 0.0 : __x - __y;
}
/* Test for negative number. Used in the signbit() macro. */
diff --git a/sysdeps/generic/glob.c b/sysdeps/generic/glob.c
index a6d6ada8bd..658599ec1f 100644
--- a/sysdeps/generic/glob.c
+++ b/sysdeps/generic/glob.c
@@ -1273,6 +1273,34 @@ weak_alias (__glob_pattern_p, glob_pattern_p)
#endif /* !GLOB_ONLY_P */
+/* We put this in a separate function mainly to allow the memory
+ allocated with alloca to be recycled. */
+#if !defined _LIBC || !defined GLOB_ONLY_P
+static int
+link_exists_p (const char *dir, size_t dirlen, const char *fname,
+ glob_t *pglob, int flags)
+{
+ size_t fnamelen = strlen (fname);
+ char *fullname = (char *) __alloca (dirlen + 1 + fnamelen + 1);
+ struct stat st;
+ struct stat64 st64;
+
+# ifdef HAVE_MEMPCPY
+ mempcpy (mempcpy (mempcpy (fullname, dir, dirlen), "/", 1),
+ fname, fnamelen + 1);
+# else
+ memcpy (fullname, dir, dirlen);
+ fullname[dirlen] = '/';
+ memcpy (&fullname[dirlen + 1], fname, fnamelen + 1);
+# endif
+
+ return (((flags & GLOB_ALTDIRFUNC)
+ ? (*pglob->gl_stat) (fullname, &st)
+ : __stat64 (fullname, &st64)) == 0);
+}
+#endif
+
+
/* Like `glob', but PATTERN is a final pathname component,
and matches are searched for in DIRECTORY.
The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done.
@@ -1285,6 +1313,7 @@ glob_in_dir (pattern, directory, flags, errfunc, pglob)
int (*errfunc) (const char *, int);
glob_t *pglob;
{
+ size_t dirlen = strlen (directory);
__ptr_t stream = NULL;
struct globlink
{
@@ -1315,7 +1344,6 @@ glob_in_dir (pattern, directory, flags, errfunc, pglob)
struct stat64 st64;
# endif
size_t patlen = strlen (pattern);
- size_t dirlen = strlen (directory);
char *fullname = (char *) __alloca (dirlen + 1 + patlen + 1);
# ifdef HAVE_MEMPCPY
@@ -1428,22 +1456,32 @@ glob_in_dir (pattern, directory, flags, errfunc, pglob)
if (fnmatch (pattern, name, fnm_flags) == 0)
{
- struct globlink *new = (struct globlink *)
- __alloca (sizeof (struct globlink));
- len = NAMLEN (d);
- new->name = (char *) malloc (len + 1);
- if (new->name == NULL)
- goto memory_error;
+ /* If the file we found is a symlink we have to
+ make sure the target file exists. */
+ if (
+#ifdef HAVE_D_TYPE
+ (d->d_type != DT_UNKNOWN && d->d_type != DT_LNK) ||
+#endif
+ link_exists_p (directory, dirlen, name, pglob,
+ flags))
+ {
+ struct globlink *new = (struct globlink *)
+ __alloca (sizeof (struct globlink));
+ len = NAMLEN (d);
+ new->name = (char *) malloc (len + 1);
+ if (new->name == NULL)
+ goto memory_error;
#ifdef HAVE_MEMPCPY
- *((char *) mempcpy ((__ptr_t) new->name, name, len))
- = '\0';
+ *((char *) mempcpy ((__ptr_t) new->name, name, len))
+ = '\0';
#else
- memcpy ((__ptr_t) new->name, name, len);
- new->name[len] = '\0';
+ memcpy ((__ptr_t) new->name, name, len);
+ new->name[len] = '\0';
#endif
- new->next = names;
- names = new;
- ++nfound;
+ new->next = names;
+ names = new;
+ ++nfound;
+ }
}
}
}
diff --git a/sysdeps/powerpc/fpu/bits/mathinline.h b/sysdeps/powerpc/fpu/bits/mathinline.h
index 491d529091..44f7dbec52 100644
--- a/sysdeps/powerpc/fpu/bits/mathinline.h
+++ b/sysdeps/powerpc/fpu/bits/mathinline.h
@@ -109,14 +109,14 @@ __MATH_INLINE double fdim (double __x, double __y) __THROW;
__MATH_INLINE double
__NTH (fdim (double __x, double __y))
{
- return __x < __y ? 0 : __x - __y;
+ return __x <= __y ? 0 : __x - __y;
}
__MATH_INLINE float fdimf (float __x, float __y) __THROW;
__MATH_INLINE float
__NTH (fdimf (float __x, float __y))
{
- return __x < __y ? 0 : __x - __y;
+ return __x <= __y ? 0 : __x - __y;
}
#endif /* __USE_ISOC99 */
diff --git a/sysdeps/sparc/fpu/bits/mathinline.h b/sysdeps/sparc/fpu/bits/mathinline.h
index 8811314278..2b578d04cd 100644
--- a/sysdeps/sparc/fpu/bits/mathinline.h
+++ b/sysdeps/sparc/fpu/bits/mathinline.h
@@ -223,14 +223,14 @@ __MATH_INLINE double fdim (double __x, double __y) __THROW;
__MATH_INLINE double
fdim (double __x, double __y) __THROW
{
- return __x < __y ? 0 : __x - __y;
+ return __x <= __y ? 0 : __x - __y;
}
__MATH_INLINE float fdimf (float __x, float __y) __THROW;
__MATH_INLINE float
fdimf (float __x, float __y) __THROW
{
- return __x < __y ? 0 : __x - __y;
+ return __x <= __y ? 0 : __x - __y;
}
# endif /* !__NO_MATH_INLINES */
diff --git a/sysdeps/unix/sysv/linux/ia64/bits/siginfo.h b/sysdeps/unix/sysv/linux/ia64/bits/siginfo.h
index 52d00e9da9..66310c65b3 100644
--- a/sysdeps/unix/sysv/linux/ia64/bits/siginfo.h
+++ b/sysdeps/unix/sysv/linux/ia64/bits/siginfo.h
@@ -122,11 +122,11 @@ typedef struct siginfo
# define si_band _sifields._sigpoll.si_band
# define si_fd _sifields._sigpoll.si_fd
-#ifdef __USE_GNU
+# ifdef __USE_GNU
# define si_imm _sifields._sigfault._si_imm
-# define si_flags _sifields._sigfault._si_flags
+# define si_segvflags _sifields._sigfault._si_flags
# define si_isr _sifields._sigfault._si_isr
-#endif
+# endif
/* Values for `si_code'. Positive values are reserved for kernel-generated
signals. */