Fix dlfcn/failtestmod.c warning.
[glibc.git] / nscd / grpcache.c
blobdf59fa79a1d039a4b528d10ed15cd25cefc387e7
1 /* Cache handling for group lookup.
2 Copyright (C) 1998-2014 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published
8 by the Free Software Foundation; version 2 of the License, or
9 (at your option) any later version.
11 This program 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
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, see <http://www.gnu.org/licenses/>. */
19 #include <alloca.h>
20 #include <assert.h>
21 #include <errno.h>
22 #include <error.h>
23 #include <grp.h>
24 #include <libintl.h>
25 #include <stdbool.h>
26 #include <stddef.h>
27 #include <stdio.h>
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <unistd.h>
32 #include <sys/mman.h>
33 #include <sys/socket.h>
34 #include <stackinfo.h>
36 #include "nscd.h"
37 #include "dbg_log.h"
38 #ifdef HAVE_SENDFILE
39 # include <kernel-features.h>
40 #endif
42 /* This is the standard reply in case the service is disabled. */
43 static const gr_response_header disabled =
45 .version = NSCD_VERSION,
46 .found = -1,
47 .gr_name_len = 0,
48 .gr_passwd_len = 0,
49 .gr_gid = -1,
50 .gr_mem_cnt = 0,
53 /* This is the struct describing how to write this record. */
54 const struct iovec grp_iov_disabled =
56 .iov_base = (void *) &disabled,
57 .iov_len = sizeof (disabled)
61 /* This is the standard reply in case we haven't found the dataset. */
62 static const gr_response_header notfound =
64 .version = NSCD_VERSION,
65 .found = 0,
66 .gr_name_len = 0,
67 .gr_passwd_len = 0,
68 .gr_gid = -1,
69 .gr_mem_cnt = 0,
73 static time_t
74 cache_addgr (struct database_dyn *db, int fd, request_header *req,
75 const void *key, struct group *grp, uid_t owner,
76 struct hashentry *const he, struct datahead *dh, int errval)
78 bool all_written = true;
79 ssize_t total;
80 time_t t = time (NULL);
82 /* We allocate all data in one memory block: the iov vector,
83 the response header and the dataset itself. */
84 struct dataset
86 struct datahead head;
87 gr_response_header resp;
88 char strdata[0];
89 } *dataset;
91 assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
93 time_t timeout = MAX_TIMEOUT_VALUE;
94 if (grp == NULL)
96 if (he != NULL && errval == EAGAIN)
98 /* If we have an old record available but cannot find one
99 now because the service is not available we keep the old
100 record and make sure it does not get removed. */
101 if (reload_count != UINT_MAX)
102 /* Do not reset the value if we never not reload the record. */
103 dh->nreloads = reload_count - 1;
105 /* Reload with the same time-to-live value. */
106 timeout = dh->timeout = t + db->postimeout;
108 total = 0;
110 else
112 /* We have no data. This means we send the standard reply for this
113 case. */
114 total = sizeof (notfound);
116 if (fd != -1
117 && TEMP_FAILURE_RETRY (send (fd, &notfound, total,
118 MSG_NOSIGNAL)) != total)
119 all_written = false;
121 /* If we have a transient error or cannot permanently store
122 the result, so be it. */
123 if (errno == EAGAIN || __builtin_expect (db->negtimeout == 0, 0))
125 /* Mark the old entry as obsolete. */
126 if (dh != NULL)
127 dh->usable = false;
129 else if ((dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len, 1)) != NULL)
131 timeout = datahead_init_neg (&dataset->head,
132 (sizeof (struct dataset)
133 + req->key_len), total,
134 db->negtimeout);
136 /* This is the reply. */
137 memcpy (&dataset->resp, &notfound, total);
139 /* Copy the key data. */
140 memcpy (dataset->strdata, key, req->key_len);
142 /* If necessary, we also propagate the data to disk. */
143 if (db->persistent)
145 // XXX async OK?
146 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
147 msync ((void *) pval,
148 ((uintptr_t) dataset & pagesize_m1)
149 + sizeof (struct dataset) + req->key_len, MS_ASYNC);
152 (void) cache_add (req->type, &dataset->strdata, req->key_len,
153 &dataset->head, true, db, owner, he == NULL);
155 pthread_rwlock_unlock (&db->lock);
157 /* Mark the old entry as obsolete. */
158 if (dh != NULL)
159 dh->usable = false;
163 else
165 /* Determine the I/O structure. */
166 size_t gr_name_len = strlen (grp->gr_name) + 1;
167 size_t gr_passwd_len = strlen (grp->gr_passwd) + 1;
168 size_t gr_mem_cnt = 0;
169 uint32_t *gr_mem_len;
170 size_t gr_mem_len_total = 0;
171 char *gr_name;
172 char *cp;
173 const size_t key_len = strlen (key);
174 const size_t buf_len = 3 * sizeof (grp->gr_gid) + key_len + 1;
175 size_t alloca_used = 0;
176 char *buf = alloca_account (buf_len, alloca_used);
177 ssize_t n;
178 size_t cnt;
180 /* We need this to insert the `bygid' entry. */
181 int key_offset;
182 n = snprintf (buf, buf_len, "%d%c%n%s", grp->gr_gid, '\0',
183 &key_offset, (char *) key) + 1;
185 /* Determine the length of all members. */
186 while (grp->gr_mem[gr_mem_cnt])
187 ++gr_mem_cnt;
188 gr_mem_len = alloca_account (gr_mem_cnt * sizeof (uint32_t), alloca_used);
189 for (gr_mem_cnt = 0; grp->gr_mem[gr_mem_cnt]; ++gr_mem_cnt)
191 gr_mem_len[gr_mem_cnt] = strlen (grp->gr_mem[gr_mem_cnt]) + 1;
192 gr_mem_len_total += gr_mem_len[gr_mem_cnt];
195 total = (offsetof (struct dataset, strdata)
196 + gr_mem_cnt * sizeof (uint32_t)
197 + gr_name_len + gr_passwd_len + gr_mem_len_total);
199 /* If we refill the cache, first assume the reconrd did not
200 change. Allocate memory on the cache since it is likely
201 discarded anyway. If it turns out to be necessary to have a
202 new record we can still allocate real memory. */
203 bool dataset_temporary = false;
204 bool dataset_malloced = false;
205 dataset = NULL;
207 if (he == NULL)
208 dataset = (struct dataset *) mempool_alloc (db, total + n, 1);
210 if (dataset == NULL)
212 /* We cannot permanently add the result in the moment. But
213 we can provide the result as is. Store the data in some
214 temporary memory. */
215 if (! __libc_use_alloca (alloca_used + total + n))
217 dataset = malloc (total + n);
218 /* Perhaps we should log a message that we were unable
219 to allocate memory for a large request. */
220 if (dataset == NULL)
221 goto out;
222 dataset_malloced = true;
224 else
225 dataset = alloca_account (total + n, alloca_used);
227 /* We cannot add this record to the permanent database. */
228 dataset_temporary = true;
231 timeout = datahead_init_pos (&dataset->head, total + n,
232 total - offsetof (struct dataset, resp),
233 he == NULL ? 0 : dh->nreloads + 1,
234 db->postimeout);
236 dataset->resp.version = NSCD_VERSION;
237 dataset->resp.found = 1;
238 dataset->resp.gr_name_len = gr_name_len;
239 dataset->resp.gr_passwd_len = gr_passwd_len;
240 dataset->resp.gr_gid = grp->gr_gid;
241 dataset->resp.gr_mem_cnt = gr_mem_cnt;
243 cp = dataset->strdata;
245 /* This is the member string length array. */
246 cp = mempcpy (cp, gr_mem_len, gr_mem_cnt * sizeof (uint32_t));
247 gr_name = cp;
248 cp = mempcpy (cp, grp->gr_name, gr_name_len);
249 cp = mempcpy (cp, grp->gr_passwd, gr_passwd_len);
251 for (cnt = 0; cnt < gr_mem_cnt; ++cnt)
252 cp = mempcpy (cp, grp->gr_mem[cnt], gr_mem_len[cnt]);
254 /* Finally the stringified GID value. */
255 memcpy (cp, buf, n);
256 char *key_copy = cp + key_offset;
257 assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
259 assert (cp == dataset->strdata + total - offsetof (struct dataset,
260 strdata));
262 /* Now we can determine whether on refill we have to create a new
263 record or not. */
264 if (he != NULL)
266 assert (fd == -1);
268 if (total + n == dh->allocsize
269 && total - offsetof (struct dataset, resp) == dh->recsize
270 && memcmp (&dataset->resp, dh->data,
271 dh->allocsize - offsetof (struct dataset, resp)) == 0)
273 /* The data has not changed. We will just bump the
274 timeout value. Note that the new record has been
275 allocated on the stack and need not be freed. */
276 dh->timeout = dataset->head.timeout;
277 ++dh->nreloads;
279 /* If the new record was allocated via malloc, then we must free
280 it here. */
281 if (dataset_malloced)
282 free (dataset);
284 else
286 /* We have to create a new record. Just allocate
287 appropriate memory and copy it. */
288 struct dataset *newp
289 = (struct dataset *) mempool_alloc (db, total + n, 1);
290 if (newp != NULL)
292 /* Adjust pointers into the memory block. */
293 gr_name = (char *) newp + (gr_name - (char *) dataset);
294 cp = (char *) newp + (cp - (char *) dataset);
295 key_copy = (char *) newp + (key_copy - (char *) dataset);
297 dataset = memcpy (newp, dataset, total + n);
298 dataset_temporary = false;
301 /* Mark the old record as obsolete. */
302 dh->usable = false;
305 else
307 /* We write the dataset before inserting it to the database
308 since while inserting this thread might block and so would
309 unnecessarily let the receiver wait. */
310 assert (fd != -1);
312 #ifdef HAVE_SENDFILE
313 if (__builtin_expect (db->mmap_used, 1) && ! dataset_temporary)
315 assert (db->wr_fd != -1);
316 assert ((char *) &dataset->resp > (char *) db->data);
317 assert ((char *) dataset - (char *) db->head
318 + total
319 <= (sizeof (struct database_pers_head)
320 + db->head->module * sizeof (ref_t)
321 + db->head->data_size));
322 ssize_t written = sendfileall (fd, db->wr_fd,
323 (char *) &dataset->resp
324 - (char *) db->head,
325 dataset->head.recsize);
326 if (written != dataset->head.recsize)
328 # ifndef __ASSUME_SENDFILE
329 if (written == -1 && errno == ENOSYS)
330 goto use_write;
331 # endif
332 all_written = false;
335 else
336 # ifndef __ASSUME_SENDFILE
337 use_write:
338 # endif
339 #endif
340 if (writeall (fd, &dataset->resp, dataset->head.recsize)
341 != dataset->head.recsize)
342 all_written = false;
345 /* Add the record to the database. But only if it has not been
346 stored on the stack. */
347 if (! dataset_temporary)
349 /* If necessary, we also propagate the data to disk. */
350 if (db->persistent)
352 // XXX async OK?
353 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
354 msync ((void *) pval,
355 ((uintptr_t) dataset & pagesize_m1) + total + n,
356 MS_ASYNC);
359 /* NB: in the following code we always must add the entry
360 marked with FIRST first. Otherwise we end up with
361 dangling "pointers" in case a latter hash entry cannot be
362 added. */
363 bool first = true;
365 /* If the request was by GID, add that entry first. */
366 if (req->type == GETGRBYGID)
368 if (cache_add (GETGRBYGID, cp, key_offset, &dataset->head, true,
369 db, owner, he == NULL) < 0)
370 goto out;
372 first = false;
374 /* If the key is different from the name add a separate entry. */
375 else if (strcmp (key_copy, gr_name) != 0)
377 if (cache_add (GETGRBYNAME, key_copy, key_len + 1,
378 &dataset->head, true, db, owner, he == NULL) < 0)
379 goto out;
381 first = false;
384 /* We have to add the value for both, byname and byuid. */
385 if ((req->type == GETGRBYNAME || db->propagate)
386 && __builtin_expect (cache_add (GETGRBYNAME, gr_name,
387 gr_name_len,
388 &dataset->head, first, db, owner,
389 he == NULL)
390 == 0, 1))
392 if (req->type == GETGRBYNAME && db->propagate)
393 (void) cache_add (GETGRBYGID, cp, key_offset, &dataset->head,
394 false, db, owner, false);
397 out:
398 pthread_rwlock_unlock (&db->lock);
402 if (__builtin_expect (!all_written, 0) && debug_level > 0)
404 char buf[256];
405 dbg_log (_("short write in %s: %s"), __FUNCTION__,
406 strerror_r (errno, buf, sizeof (buf)));
409 return timeout;
413 union keytype
415 void *v;
416 gid_t g;
420 static int
421 lookup (int type, union keytype key, struct group *resultbufp, char *buffer,
422 size_t buflen, struct group **grp)
424 if (type == GETGRBYNAME)
425 return __getgrnam_r (key.v, resultbufp, buffer, buflen, grp);
426 else
427 return __getgrgid_r (key.g, resultbufp, buffer, buflen, grp);
431 static time_t
432 addgrbyX (struct database_dyn *db, int fd, request_header *req,
433 union keytype key, const char *keystr, uid_t uid,
434 struct hashentry *he, struct datahead *dh)
436 /* Search for the entry matching the key. Please note that we don't
437 look again in the table whether the dataset is now available. We
438 simply insert it. It does not matter if it is in there twice. The
439 pruning function only will look at the timestamp. */
440 size_t buflen = 1024;
441 char *buffer = (char *) alloca (buflen);
442 struct group resultbuf;
443 struct group *grp;
444 bool use_malloc = false;
445 int errval = 0;
447 if (__glibc_unlikely (debug_level > 0))
449 if (he == NULL)
450 dbg_log (_("Haven't found \"%s\" in group cache!"), keystr);
451 else
452 dbg_log (_("Reloading \"%s\" in group cache!"), keystr);
455 while (lookup (req->type, key, &resultbuf, buffer, buflen, &grp) != 0
456 && (errval = errno) == ERANGE)
458 errno = 0;
460 if (__glibc_unlikely (buflen > 32768))
462 char *old_buffer = buffer;
463 buflen *= 2;
464 buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
465 if (buffer == NULL)
467 /* We ran out of memory. We cannot do anything but
468 sending a negative response. In reality this should
469 never happen. */
470 grp = NULL;
471 buffer = old_buffer;
473 /* We set the error to indicate this is (possibly) a
474 temporary error and that it does not mean the entry
475 is not available at all. */
476 errval = EAGAIN;
477 break;
479 use_malloc = true;
481 else
482 /* Allocate a new buffer on the stack. If possible combine it
483 with the previously allocated buffer. */
484 buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
487 time_t timeout = cache_addgr (db, fd, req, keystr, grp, uid, he, dh, errval);
489 if (use_malloc)
490 free (buffer);
492 return timeout;
496 void
497 addgrbyname (struct database_dyn *db, int fd, request_header *req,
498 void *key, uid_t uid)
500 union keytype u = { .v = key };
502 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
506 time_t
507 readdgrbyname (struct database_dyn *db, struct hashentry *he,
508 struct datahead *dh)
510 request_header req =
512 .type = GETGRBYNAME,
513 .key_len = he->len
515 union keytype u = { .v = db->data + he->key };
517 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
521 void
522 addgrbygid (struct database_dyn *db, int fd, request_header *req,
523 void *key, uid_t uid)
525 char *ep;
526 gid_t gid = strtoul ((char *) key, &ep, 10);
528 if (*(char *) key == '\0' || *ep != '\0') /* invalid numeric uid */
530 if (debug_level > 0)
531 dbg_log (_("Invalid numeric gid \"%s\"!"), (char *) key);
533 errno = EINVAL;
534 return;
537 union keytype u = { .g = gid };
539 addgrbyX (db, fd, req, u, key, uid, NULL, NULL);
543 time_t
544 readdgrbygid (struct database_dyn *db, struct hashentry *he,
545 struct datahead *dh)
547 char *ep;
548 gid_t gid = strtoul (db->data + he->key, &ep, 10);
550 /* Since the key has been added before it must be OK. */
551 assert (*(db->data + he->key) != '\0' && *ep == '\0');
553 request_header req =
555 .type = GETGRBYGID,
556 .key_len = he->len
558 union keytype u = { .g = gid };
560 return addgrbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);