Updated to fedora-glibc-20060907T0853
[glibc/history.git] / nscd / initgrcache.c
blobf1f859c552c55886640f682feb35c73f2a89e1ac
1 /* Cache handling for host lookup.
2 Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License version 2 as
8 published by the Free Software Foundation.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software Foundation,
17 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19 #include <assert.h>
20 #include <errno.h>
21 #include <grp.h>
22 #include <libintl.h>
23 #include <string.h>
24 #include <time.h>
25 #include <unistd.h>
26 #include <sys/mman.h>
28 #include "dbg_log.h"
29 #include "nscd.h"
30 #ifdef HAVE_SENDFILE
31 # include <kernel-features.h>
32 #endif
34 #include "../nss/nsswitch.h"
37 /* Type of the lookup function. */
38 typedef enum nss_status (*initgroups_dyn_function) (const char *, gid_t,
39 long int *, long int *,
40 gid_t **, long int, int *);
43 static const initgr_response_header notfound =
45 .version = NSCD_VERSION,
46 .found = 0,
47 .ngrps = 0
51 #include "../grp/compat-initgroups.c"
54 static void
55 addinitgroupsX (struct database_dyn *db, int fd, request_header *req,
56 void *key, uid_t uid, struct hashentry *he,
57 struct datahead *dh)
59 /* Search for the entry matching the key. Please note that we don't
60 look again in the table whether the dataset is now available. We
61 simply insert it. It does not matter if it is in there twice. The
62 pruning function only will look at the timestamp. */
65 /* We allocate all data in one memory block: the iov vector,
66 the response header and the dataset itself. */
67 struct dataset
69 struct datahead head;
70 initgr_response_header resp;
71 char strdata[0];
72 } *dataset = NULL;
74 if (__builtin_expect (debug_level > 0, 0))
76 if (he == NULL)
77 dbg_log (_("Haven't found \"%s\" in group cache!"), (char *) key);
78 else
79 dbg_log (_("Reloading \"%s\" in group cache!"), (char *) key);
82 static service_user *group_database;
83 service_user *nip = NULL;
84 int no_more;
86 if (group_database != NULL)
88 nip = group_database;
89 no_more = 0;
91 else
92 no_more = __nss_database_lookup ("group", NULL,
93 "compat [NOTFOUND=return] files", &nip);
95 /* We always use sysconf even if NGROUPS_MAX is defined. That way, the
96 limit can be raised in the kernel configuration without having to
97 recompile libc. */
98 long int limit = __sysconf (_SC_NGROUPS_MAX);
100 long int size;
101 if (limit > 0)
102 /* We limit the size of the intially allocated array. */
103 size = MIN (limit, 64);
104 else
105 /* No fixed limit on groups. Pick a starting buffer size. */
106 size = 16;
108 long int start = 0;
109 bool all_tryagain = true;
110 bool any_success = false;
112 /* This is temporary memory, we need not (ad must not) call
113 mempool_alloc. */
114 // XXX This really should use alloca. need to change the backends.
115 gid_t *groups = (gid_t *) malloc (size * sizeof (gid_t));
116 if (__builtin_expect (groups == NULL, 0))
117 /* No more memory. */
118 goto out;
120 /* Nothing added yet. */
121 while (! no_more)
123 long int prev_start = start;
124 enum nss_status status;
125 initgroups_dyn_function fct;
126 fct = __nss_lookup_function (nip, "initgroups_dyn");
128 if (fct == NULL)
130 status = compat_call (nip, key, -1, &start, &size, &groups,
131 limit, &errno);
133 if (nss_next_action (nip, NSS_STATUS_UNAVAIL) != NSS_ACTION_CONTINUE)
134 break;
136 else
137 status = DL_CALL_FCT (fct, (key, -1, &start, &size, &groups,
138 limit, &errno));
140 /* Remove duplicates. */
141 long int cnt = prev_start;
142 while (cnt < start)
144 long int inner;
145 for (inner = 0; inner < prev_start; ++inner)
146 if (groups[inner] == groups[cnt])
147 break;
149 if (inner < prev_start)
150 groups[cnt] = groups[--start];
151 else
152 ++cnt;
155 if (status != NSS_STATUS_TRYAGAIN)
156 all_tryagain = false;
158 /* This is really only for debugging. */
159 if (NSS_STATUS_TRYAGAIN > status || status > NSS_STATUS_RETURN)
160 __libc_fatal ("illegal status in internal_getgrouplist");
162 any_success |= status == NSS_STATUS_SUCCESS;
164 if (status != NSS_STATUS_SUCCESS
165 && nss_next_action (nip, status) == NSS_ACTION_RETURN)
166 break;
168 if (nip->next == NULL)
169 no_more = -1;
170 else
171 nip = nip->next;
174 ssize_t total;
175 ssize_t written;
176 out:
177 if (!any_success)
179 /* Nothing found. Create a negative result record. */
180 written = total = sizeof (notfound);
182 if (he != NULL && all_tryagain)
184 /* If we have an old record available but cannot find one now
185 because the service is not available we keep the old record
186 and make sure it does not get removed. */
187 if (reload_count != UINT_MAX && dh->nreloads == reload_count)
188 /* Do not reset the value if we never not reload the record. */
189 dh->nreloads = reload_count - 1;
191 else
193 /* We have no data. This means we send the standard reply for this
194 case. */
195 if (fd != -1)
196 written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
197 MSG_NOSIGNAL));
199 dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
200 /* If we cannot permanently store the result, so be it. */
201 if (dataset != NULL)
203 dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
204 dataset->head.recsize = total;
205 dataset->head.notfound = true;
206 dataset->head.nreloads = 0;
207 dataset->head.usable = true;
209 /* Compute the timeout time. */
210 dataset->head.timeout = time (NULL) + db->negtimeout;
212 /* This is the reply. */
213 memcpy (&dataset->resp, &notfound, total);
215 /* Copy the key data. */
216 char *key_copy = memcpy (dataset->strdata, key, req->key_len);
218 /* If necessary, we also propagate the data to disk. */
219 if (db->persistent)
221 // XXX async OK?
222 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
223 msync ((void *) pval,
224 ((uintptr_t) dataset & pagesize_m1)
225 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
228 /* Now get the lock to safely insert the records. */
229 pthread_rwlock_rdlock (&db->lock);
231 if (cache_add (req->type, key_copy, req->key_len,
232 &dataset->head, true, db, uid) < 0)
233 /* Ensure the data can be recovered. */
234 dataset->head.usable = false;
236 pthread_rwlock_unlock (&db->lock);
238 /* Mark the old entry as obsolete. */
239 if (dh != NULL)
240 dh->usable = false;
242 else
243 ++db->head->addfailed;
246 else
249 written = total = sizeof (struct dataset) + start * sizeof (int32_t);
251 /* If we refill the cache, first assume the reconrd did not
252 change. Allocate memory on the cache since it is likely
253 discarded anyway. If it turns out to be necessary to have a
254 new record we can still allocate real memory. */
255 bool alloca_used = false;
256 dataset = NULL;
258 if (he == NULL)
260 dataset = (struct dataset *) mempool_alloc (db,
261 total + req->key_len);
262 if (dataset == NULL)
263 ++db->head->addfailed;
266 if (dataset == NULL)
268 /* We cannot permanently add the result in the moment. But
269 we can provide the result as is. Store the data in some
270 temporary memory. */
271 dataset = (struct dataset *) alloca (total + req->key_len);
273 /* We cannot add this record to the permanent database. */
274 alloca_used = true;
277 dataset->head.allocsize = total + req->key_len;
278 dataset->head.recsize = total - offsetof (struct dataset, resp);
279 dataset->head.notfound = false;
280 dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
281 dataset->head.usable = true;
283 /* Compute the timeout time. */
284 dataset->head.timeout = time (NULL) + db->postimeout;
286 dataset->resp.version = NSCD_VERSION;
287 dataset->resp.found = 1;
288 dataset->resp.ngrps = start;
290 char *cp = dataset->strdata;
292 /* Copy the GID values. If the size of the types match this is
293 very simple. */
294 if (sizeof (gid_t) == sizeof (int32_t))
295 cp = mempcpy (cp, groups, start * sizeof (gid_t));
296 else
298 gid_t *gcp = (gid_t *) cp;
300 for (int i = 0; i < start; ++i)
301 *gcp++ = groups[i];
303 cp = (char *) gcp;
306 /* Finally the user name. */
307 memcpy (cp, key, req->key_len);
309 /* Now we can determine whether on refill we have to create a new
310 record or not. */
311 if (he != NULL)
313 assert (fd == -1);
315 if (total + req->key_len == dh->allocsize
316 && total - offsetof (struct dataset, resp) == dh->recsize
317 && memcmp (&dataset->resp, dh->data,
318 dh->allocsize - offsetof (struct dataset, resp)) == 0)
320 /* The data has not changed. We will just bump the
321 timeout value. Note that the new record has been
322 allocated on the stack and need not be freed. */
323 dh->timeout = dataset->head.timeout;
324 ++dh->nreloads;
326 else
328 /* We have to create a new record. Just allocate
329 appropriate memory and copy it. */
330 struct dataset *newp
331 = (struct dataset *) mempool_alloc (db, total + req->key_len);
332 if (newp != NULL)
334 /* Adjust pointer into the memory block. */
335 cp = (char *) newp + (cp - (char *) dataset);
337 dataset = memcpy (newp, dataset, total + req->key_len);
338 alloca_used = false;
341 /* Mark the old record as obsolete. */
342 dh->usable = false;
345 else
347 /* We write the dataset before inserting it to the database
348 since while inserting this thread might block and so would
349 unnecessarily let the receiver wait. */
350 assert (fd != -1);
352 #ifdef HAVE_SENDFILE
353 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
355 assert (db->wr_fd != -1);
356 assert ((char *) &dataset->resp > (char *) db->data);
357 assert ((char *) &dataset->resp - (char *) db->head
358 + total
359 <= (sizeof (struct database_pers_head)
360 + db->head->module * sizeof (ref_t)
361 + db->head->data_size));
362 written = sendfileall (fd, db->wr_fd,
363 (char *) &dataset->resp
364 - (char *) db->head, total);
365 # ifndef __ASSUME_SENDFILE
366 if (written == -1 && errno == ENOSYS)
367 goto use_write;
368 # endif
370 else
371 # ifndef __ASSUME_SENDFILE
372 use_write:
373 # endif
374 #endif
375 written = writeall (fd, &dataset->resp, total);
379 /* Add the record to the database. But only if it has not been
380 stored on the stack. */
381 if (! alloca_used)
383 /* If necessary, we also propagate the data to disk. */
384 if (db->persistent)
386 // XXX async OK?
387 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
388 msync ((void *) pval,
389 ((uintptr_t) dataset & pagesize_m1) + total +
390 req->key_len, MS_ASYNC);
393 /* Now get the lock to safely insert the records. */
394 pthread_rwlock_rdlock (&db->lock);
396 if (cache_add (INITGROUPS, cp, req->key_len, &dataset->head, true,
397 db, uid) < 0)
398 /* Could not allocate memory. Make sure the data gets
399 discarded. */
400 dataset->head.usable = false;
402 pthread_rwlock_unlock (&db->lock);
406 free (groups);
408 if (__builtin_expect (written != total, 0) && debug_level > 0)
410 char buf[256];
411 dbg_log (_("short write in %s: %s"), __FUNCTION__,
412 strerror_r (errno, buf, sizeof (buf)));
417 void
418 addinitgroups (struct database_dyn *db, int fd, request_header *req, void *key,
419 uid_t uid)
421 addinitgroupsX (db, fd, req, key, uid, NULL, NULL);
425 void
426 readdinitgroups (struct database_dyn *db, struct hashentry *he,
427 struct datahead *dh)
429 request_header req =
431 .type = INITGROUPS,
432 .key_len = he->len
435 addinitgroupsX (db, -1, &req, db->data + he->key, he->owner, he, dh);