Update.
[glibc.git] / nscd / grpcache.c
blobc565f5a68278232252b079c19ffd901ee6dee61f
1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2002, 2003, 2004 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, write to the Free
18 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 02111-1307 USA. */
21 #include <alloca.h>
22 #include <assert.h>
23 #include <errno.h>
24 #include <error.h>
25 #include <grp.h>
26 #include <libintl.h>
27 #include <stdbool.h>
28 #include <stddef.h>
29 #include <stdio.h>
30 #include <stdint.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <sys/mman.h>
35 #include <stackinfo.h>
37 #include "nscd.h"
38 #include "dbg_log.h"
40 /* This is the standard reply in case the service is disabled. */
41 static const gr_response_header disabled =
43 .version = NSCD_VERSION,
44 .found = -1,
45 .gr_name_len = 0,
46 .gr_passwd_len = 0,
47 .gr_gid = -1,
48 .gr_mem_cnt = 0,
51 /* This is the struct describing how to write this record. */
52 const struct iovec grp_iov_disabled =
54 .iov_base = (void *) &disabled,
55 .iov_len = sizeof (disabled)
59 /* This is the standard reply in case we haven't found the dataset. */
60 static const gr_response_header notfound =
62 .version = NSCD_VERSION,
63 .found = 0,
64 .gr_name_len = 0,
65 .gr_passwd_len = 0,
66 .gr_gid = -1,
67 .gr_mem_cnt = 0,
71 static void
72 cache_addgr (struct database_dyn *db, int fd, request_header *req,
73 const void *key, struct group *grp, uid_t owner,
74 struct hashentry *he, struct datahead *dh, int errval)
76 ssize_t total;
77 ssize_t written;
78 time_t t = time (NULL);
80 /* We allocate all data in one memory block: the iov vector,
81 the response header and the dataset itself. */
82 struct dataset
84 struct datahead head;
85 gr_response_header resp;
86 char strdata[0];
87 } *dataset;
89 assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
91 if (grp == NULL)
93 if (he != NULL && errval == EAGAIN)
95 /* If we have an old record available but cannot find one
96 now because the service is not available we keep the old
97 record and make sure it does not get removed. */
98 if (reload_count != UINT_MAX)
99 /* Do not reset the value if we never not reload the record. */
100 dh->nreloads = reload_count - 1;
102 written = total = 0;
104 else
106 /* We have no data. This means we send the standard reply for this
107 case. */
108 total = sizeof (notfound);
110 written = TEMP_FAILURE_RETRY (write (fd, &notfound, total));
112 dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
113 /* If we cannot permanently store the result, so be it. */
114 if (dataset != NULL)
116 dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
117 dataset->head.recsize = total;
118 dataset->head.notfound = true;
119 dataset->head.nreloads = 0;
120 dataset->head.usable = true;
122 /* Compute the timeout time. */
123 dataset->head.timeout = t + db->negtimeout;
125 /* This is the reply. */
126 memcpy (&dataset->resp, &notfound, total);
128 /* Copy the key data. */
129 memcpy (dataset->strdata, key, req->key_len);
131 /* If necessary, we also propagate the data to disk. */
132 if (db->persistent)
134 // XXX async OK?
135 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
136 msync ((void *) pval,
137 ((uintptr_t) dataset & pagesize_m1)
138 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
141 /* Now get the lock to safely insert the records. */
142 pthread_rwlock_rdlock (&db->lock);
144 if (cache_add (req->type, &dataset->strdata, req->key_len,
145 &dataset->head, true, db, owner) < 0)
146 /* Ensure the data can be recovered. */
147 dataset->head.usable = false;
149 pthread_rwlock_unlock (&db->lock);
151 /* Mark the old entry as obsolete. */
152 if (dh != NULL)
153 dh->usable = false;
155 else
156 ++db->head->addfailed;
159 else
161 /* Determine the I/O structure. */
162 size_t gr_name_len = strlen (grp->gr_name) + 1;
163 size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
164 size_t gr_mem_cnt = 0;
165 uint32_t *gr_mem_len;
166 size_t gr_mem_len_total = 0;
167 char *gr_name;
168 char *cp;
169 const size_t key_len = strlen (key);
170 const size_t buf_len = 3 + sizeof (grp->gr_gid) + key_len + 1;
171 char *buf = alloca (buf_len);
172 ssize_t n;
173 size_t cnt;
175 /* We need this to insert the `bygid' entry. */
176 int key_offset;
177 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
178 &key_offset, (char *) key) + 1;
180 /* Determine the length of all members. */
181 while (grp->gr_mem[gr_mem_cnt])
182 ++gr_mem_cnt;
183 gr_mem_len = (uint32_t *) alloca (gr_mem_cnt * sizeof (uint32_t));
184 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
186 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
187 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
190 written = total = (sizeof (struct dataset)
191 + gr_mem_cnt * sizeof (uint32_t)
192 + gr_name_len + gr_passwd_len + gr_mem_len_total);
194 /* If we refill the cache, first assume the reconrd did not
195 change. Allocate memory on the cache since it is likely
196 discarded anyway. If it turns out to be necessary to have a
197 new record we can still allocate real memory. */
198 bool alloca_used = false;
199 dataset = NULL;
201 if (he == NULL)
203 dataset = (struct dataset *) mempool_alloc (db, total + n);
204 if (dataset == NULL)
205 ++db->head->addfailed;
208 if (dataset == NULL)
210 /* We cannot permanently add the result in the moment. But
211 we can provide the result as is. Store the data in some
212 temporary memory. */
213 dataset = (struct dataset *) alloca (total + n);
215 /* We cannot add this record to the permanent database. */
216 alloca_used = true;
219 dataset->head.allocsize = total + n;
220 dataset->head.recsize = total - offsetof (struct dataset, resp);
221 dataset->head.notfound = false;
222 dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
223 dataset->head.usable = true;
225 /* Compute the timeout time. */
226 dataset->head.timeout = t + db->postimeout;
228 dataset->resp.version = NSCD_VERSION;
229 dataset->resp.found = 1;
230 dataset->resp.gr_name_len = gr_name_len;
231 dataset->resp.gr_passwd_len = gr_passwd_len;
232 dataset->resp.gr_gid = grp->gr_gid;
233 dataset->resp.gr_mem_cnt = gr_mem_cnt;
235 cp = dataset->strdata;
237 /* This is the member string length array. */
238 cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
239 gr_name = cp;
240 cp = mempcpy (cp, grp->gr_name, gr_name_len);
241 cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
243 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
244 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
246 /* Finally the stringified GID value. */
247 memcpy (cp, buf, n);
248 char *key_copy = cp + key_offset;
249 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
251 /* Now we can determine whether on refill we have to create a new
252 record or not. */
253 if (he != NULL)
255 assert (fd == -1);
257 if (total + n == dh->allocsize
258 && total - offsetof (struct dataset, resp) == dh->recsize
259 && memcmp (&dataset->resp, dh->data,
260 dh->allocsize - offsetof (struct dataset, resp)) == 0)
262 /* The data has not changed. We will just bump the
263 timeout value. Note that the new record has been
264 allocated on the stack and need not be freed. */
265 dh->timeout = dataset->head.timeout;
266 ++dh->nreloads;
268 else
270 /* We have to create a new record. Just allocate
271 appropriate memory and copy it. */
272 struct dataset *newp
273 = (struct dataset *) mempool_alloc (db, total + n);
274 if (newp != NULL)
276 /* Adjust pointers into the memory block. */
277 gr_name = (char *) newp + (gr_name - (char *) dataset);
278 cp = (char *) newp + (cp - (char *) dataset);
280 dataset = memcpy (newp, dataset, total + n);
281 alloca_used = false;
284 /* Mark the old record as obsolete. */
285 dh->usable = false;
288 else
290 /* We write the dataset before inserting it to the database
291 since while inserting this thread might block and so would
292 unnecessarily let the receiver wait. */
293 assert (fd != -1);
295 written = TEMP_FAILURE_RETRY (write (fd, &dataset->resp, total));
298 /* Add the record to the database. But only if it has not been
299 stored on the stack. */
300 if (! alloca_used)
302 /* If necessary, we also propagate the data to disk. */
303 if (db->persistent)
305 // XXX async OK?
306 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
307 msync ((void *) pval,
308 ((uintptr_t) dataset & pagesize_m1) + total + n,
309 MS_ASYNC);
312 /* Now get the lock to safely insert the records. */
313 pthread_rwlock_rdlock (&db->lock);
315 /* NB: in the following code we always must add the entry
316 marked with FIRST first. Otherwise we end up with
317 dangling "pointers" in case a latter hash entry cannot be
318 added. */
319 bool first = req->type == GETGRBYNAME;
321 /* If the request was by GID, add that entry first. */
322 if (req->type != GETGRBYNAME)
324 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
325 db, owner) < 0)
327 /* Could not allocate memory. Make sure the data gets
328 discarded. */
329 dataset->head.usable = false;
330 goto out;
333 /* If the key is different from the name add a separate entry. */
334 else if (strcmp (key_copy, gr_name) != 0)
336 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
337 &dataset->head, first, db, owner) < 0)
339 /* Could not allocate memory. Make sure the data gets
340 discarded. */
341 dataset->head.usable = false;
342 goto out;
345 first = false;
348 /* We have to add the value for both, byname and byuid. */
349 if (__builtin_expect (cache_add (GETGRBYNAME, gr_name, gr_name_len,
350 &dataset->head, first, db, owner)
351 == 0, 1))
353 if (req->type == GETGRBYNAME)
354 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
355 req->type != GETGRBYNAME, db, owner);
357 else if (first)
358 /* Could not allocate memory. Make sure the data gets
359 discarded. */
360 dataset->head.usable = false;
362 out:
363 pthread_rwlock_unlock (&db->lock);
367 if (__builtin_expect (written != total, 0) && debug_level > 0)
369 char buf[256];
370 dbg_log (_("short write in %s: %s"), __FUNCTION__,
371 strerror_r (errno, buf, sizeof (buf)));
376 union keytype
378 void *v;
379 gid_t g;
383 static int
384 lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
385 size_t buflen, struct group **grp)
387 if (type == GETGRBYNAME)
388 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
389 else
390 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
394 static void
395 addgrbyX (struct database_dyn *db, int fd, request_header *req,
396 union keytype key, const char *keystr, uid_t uid,
397 struct hashentry *he, struct datahead *dh)
399 /* Search for the entry matching the key. Please note that we don't
400 look again in the table whether the dataset is now available. We
401 simply insert it. It does not matter if it is in there twice. The
402 pruning function only will look at the timestamp. */
403 size_t buflen = 1024;
404 char *buffer = (char *) alloca (buflen);
405 struct group resultbuf;
406 struct group *grp;
407 bool use_malloc = false;
408 int errval = 0;
410 if (__builtin_expect (debug_level > 0, 0))
412 if (he == NULL)
413 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
414 else
415 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
418 #if 0
419 uid_t oldeuid = 0;
420 if (db->secure)
422 oldeuid = geteuid ();
423 pthread_seteuid_np (uid);
425 #endif
427 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
428 && (errval = errno) == ERANGE)
430 char *old_buffer = buffer;
431 errno = 0;
432 #define INCR 1024
434 if (__builtin_expect (buflen > 32768, 0))
436 buflen += INCR;
437 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
438 if (buffer == NULL)
440 /* We ran out of memory. We cannot do anything but
441 sending a negative response. In reality this should
442 never happen. */
443 grp = NULL;
444 buffer = old_buffer;
446 /* We set the error to indicate this is (possibly) a
447 temporary error and that it does not mean the entry
448 is not available at all. */
449 errval = EAGAIN;
450 break;
452 use_malloc = true;
454 else
455 /* Allocate a new buffer on the stack. If possible combine it
456 with the previously allocated buffer. */
457 buffer = (char *) extend_alloca (buffer, buflen, buflen + INCR);
460 #if 0
461 if (db->secure)
462 pthread_seteuid_np (oldeuid);
463 #endif
465 cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
467 if (use_malloc)
468 free (buffer);
472 void
473 addgrbyname (struct database_dyn *db, int fd, request_header *req,
474 void *key, uid_t uid)
476 union keytype u = { .v = key };
478 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
482 void
483 readdgrbyname (struct database_dyn *db, struct hashentry *he,
484 struct datahead *dh)
486 request_header req =
488 .type = GETGRBYNAME,
489 .key_len = he->len
491 union keytype u = { .v = db->data + he->key };
493 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
497 void
498 addgrbygid (struct database_dyn *db, int fd, request_header *req,
499 void *key, uid_t uid)
501 char *ep;
502 gid_t gid = strtoul ((char *) key, &ep, 10);
504 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
506 if (debug_level > 0)
507 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
509 errno = EINVAL;
510 return;
513 union keytype u = { .g = gid };
515 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
519 void
520 readdgrbygid (struct database_dyn *db, struct hashentry *he,
521 struct datahead *dh)
523 char *ep;
524 gid_t gid = strtoul (db->data + he->key, &ep, 10);
526 /* Since the key has been added before it must be OK. */
527 assert (*(db->data + he->key) != '\0' && *ep == '\0');
529 request_header req =
531 .type = GETGRBYGID,
532 .key_len = he->len
534 union keytype u = { .g = gid };
536 addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);