diff options
| -rw-r--r-- | ChangeLog | 80 | ||||
| -rw-r--r-- | fedora/branch.mk | 4 | ||||
| -rw-r--r-- | fedora/glibc.spec.in | 15 | ||||
| -rw-r--r-- | grp/Makefile | 4 | ||||
| -rw-r--r-- | grp/compat-initgroups.c | 98 | ||||
| -rw-r--r-- | grp/initgroups.c | 119 | ||||
| -rw-r--r-- | nscd/Makefile | 7 | ||||
| -rw-r--r-- | nscd/cache.c | 4 | ||||
| -rw-r--r-- | nscd/connections.c | 12 | ||||
| -rw-r--r-- | nscd/initgrcache.c | 391 | ||||
| -rw-r--r-- | nscd/nscd-client.h | 27 | ||||
| -rw-r--r-- | nscd/nscd.c | 13 | ||||
| -rw-r--r-- | nscd/nscd.h | 7 | ||||
| -rw-r--r-- | nscd/nscd_getai.c | 42 | ||||
| -rw-r--r-- | nscd/nscd_getgr_r.c | 48 | ||||
| -rw-r--r-- | nscd/nscd_gethst_r.c | 39 | ||||
| -rw-r--r-- | nscd/nscd_getpw_r.c | 35 | ||||
| -rw-r--r-- | nscd/nscd_helper.c | 2 | ||||
| -rw-r--r-- | nscd/nscd_initgroups.c | 168 | ||||
| -rw-r--r-- | nscd/nscd_proto.h | 5 | ||||
| -rw-r--r-- | nscd/selinux.c | 3 | ||||
| -rw-r--r-- | posix/tst-gnuglob.c | 12 | ||||
| -rw-r--r-- | sunrpc/clnt_udp.c | 1 | ||||
| -rw-r--r-- | sunrpc/get_myaddr.c | 4 | ||||
| -rw-r--r-- | sunrpc/pmap_clnt.c | 4 | ||||
| -rw-r--r-- | sunrpc/pmap_rmt.c | 1 | ||||
| -rw-r--r-- | sysdeps/alpha/fpu/bits/mathinline.h | 8 | ||||
| -rw-r--r-- | sysdeps/generic/glob.c | 66 | ||||
| -rw-r--r-- | sysdeps/powerpc/fpu/bits/mathinline.h | 4 | ||||
| -rw-r--r-- | sysdeps/sparc/fpu/bits/mathinline.h | 4 | ||||
| -rw-r--r-- | sysdeps/unix/sysv/linux/ia64/bits/siginfo.h | 6 |
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, ¬found, 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, ¬found, 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. */ |